 So in this module, students, we will look at the trivial join. We will look at the Cartesian product. We will look at other types of joins. And we will also look at some other interesting things which are listed and shown in the outline of this module. So we'll also look at the trade join qualifying column references. And of course, using the aliases qualifying column references means that how do you distinguish between which column names in a table? You are referring to in a query such that the query runs unambiguously, right? So as we proceed, you will understand what I'm saying. The two tables which we have been considering in our modules, table one, T1 and T2. Now a trivial join is just select a static from this table over here. Now some people say that this is not a join at all, but this is a trivial join. It's just a matter of perspective. Now let's look at full and equal join, which is on the next slide. So how do we go about it? So what we have is just called as a cross join or a Cartesian product. So where is the join? Over here is the join over here. So this results in a large number of rows. So why it is called a Cartesian product? Because say for example, we have these tables over here with that many rows. Now this Cartesian product is going to result in six million rows. That's a big number. There's a lot of numbers. And it is called a join, a cross join because each row of each table is crossed with each row in every other table to produce all possible combinations. So this results in a very large number of rows because the possible row count is the product of the number of rows in each table, which is six million in this case. Even though the individual tables are small, in cases like this, a where clause will normally be used to reduce the result to a more manageable number, where clause. Understand? So this is the Cartesian product. Now you can see over here that for these two tables over here, we have this repetition over here. We have this repetition over here. So the full are the equal join. This comma is the join operator. The join and cross join types are equivalent to the comma join operator. For example, the following statements are all the same. This statement, this statement, this, this, they are all the same. They are different ways of getting the same result, but all are employing the comma join over here. And over here, we are explicitly writing join. Over here, we are explicitly writing cross join. But they are all the same. I believe everybody understands this. Now let's move on to the straight join. So what is a straight join? What can happen that normally the MySQL optimizer considers itself free to determine the order in which to scan tables to retrieve rows most quickly. On occasion, the optimizer will make a non optimal choice. If you find this happening, you can override the optimal choice using the straight join keyword. A joint performed with straight join is like a cross join, but forces or tables should be joined in the order named in the from clause. Okay. So over here, we have this. You can see straight join from this is the optimal choice, which is going to be there from T1 join T2 straight join over here. Straight join can be specified at two points in a select statement. You can specify it between the select keyword and the selection list to have a global effect on all cross joins to the statement, or you can specify in the from clause. The following two statements are equivalent. This and this, they are equivalent. They are the same. They're equivalent statements. All right. I believe everybody understands this. Qualifying the column references. References to the table columns throughout the select statement must resolve unambiguously to a single table named in the from clause. If only one table is named, there is no ambiguity because all columns must be columns of that table. Obviously, if multiple tables are named, any column name that appears in only one table is similarly unambiguous. However, if a column name appears in multiple tables, references to the column must be qualified by the table name using table underscore name dot column underscore name, which is given over here. Table underscore name column underscore name. This is the syntax. And this is the example over here. So we have this and this. They are same. But because of this and this not same, there is no ambiguity. Things are very clear. Qualifying the column table aliases. Sometimes a table name qualifier is not sufficient to resolve a column reference. For example, if you are joining a table to itself, joining a table to itself, you are using it multiple times within the query and it doesn't help to qualify a column name with the table name because the column names are same. In this case, table aliases are useful for communicating your intent. You can assign an alias to any instance of the table and refer to columns from that instance as alias underscore name dot column underscore name syntax. All right. The following query joins the table to itself, but assigns an alias to one instance of the table to allow column references to be specified unambiguously. So joining the table with itself, joining the table. These are the aliases from. So this is how it's going to work and that's all I have to cover in this module.