Joins in Impala SELECT Statements

A join query is a SELECT statement that combines data from two or more tables, and returns a result set containing items from some or all of those tables. It is a way to cross-reference and correlate related data that is organized into multiple tables, typically using identifiers that are repeated in each of the joined tables.

Syntax:

Impala supports a wide variety of JOIN clauses. Left, right, semi, full, and outer joins are supported in all Impala versions. The CROSS JOIN operator is available in Impala 1.2.2 and higher. During performance tuning, you can override the reordering of join clauses that Impala does internally by including the keyword STRAIGHT_JOIN immediately after the SELECT and any DISTINCT or ALL keywords.

  1. SELECT select_list FROM
  2.   table_or_subquery1 [INNER] JOIN table_or_subquery2 |
  3.   table_or_subquery1 {LEFT [OUTER] | RIGHT [OUTER] | FULL [OUTER]} JOIN table_or_subquery2 |
  4.   table_or_subquery1 {LEFT | RIGHT} SEMI JOIN table_or_subquery2 |
  5.   table_or_subquery1 {LEFT | RIGHT} ANTI JOIN table_or_subquery2 |
  6.     [ ON col1 = col2 [AND col3 = col4 ...] |
  7.       USING (col1 [, col2 ...]) ]
  8.   [other_join_clause ...]
  9. [ WHERE where_clauses ]
  11. SELECT select_list FROM
  12.   table_or_subquery1, table_or_subquery2 [, table_or_subquery3 ...]
  13.   [other_join_clause ...]
  14. WHERE
  15.     col1 = col2 [AND col3 = col4 ...]
  17. SELECT select_list FROM
  18.   table_or_subquery1 CROSS JOIN table_or_subquery2
  19.   [other_join_clause ...]
  20. [ WHERE where_clauses ]

SQL-92 and SQL-89 Joins:

Queries with the explicit JOIN keywords are known as SQL-92 style joins, referring to the level of the SQL standard where they were introduced. The corresponding ON or USING clauses clearly show which columns are used as the join keys in each case:

  1. SELECT t1.c1, t2.c2 FROM t1 JOIN t2
  2.   ON t1.id = t2.id and t1.type_flag = t2.type_flag
  3.   WHERE t1.c1 > 100;
  5. SELECT t1.c1, t2.c2 FROM t1 JOIN t2
  6.   USING (id, type_flag)
  7.   WHERE t1.c1 > 100;

The ON clause is a general way to compare columns across the two tables, even if the column names are different. The USING clause is a shorthand notation for specifying the join columns, when the column names are the same in both tables. You can code equivalent WHERE clauses that compare the columns, instead of ON or USING clauses, but that practice is not recommended because mixing the join comparisons with other filtering clauses is typically less readable and harder to maintain.

Queries with a comma-separated list of tables and subqueries are known as SQL-89 style joins. In these queries, the equality comparisons between columns of the joined tables go in the WHERE clause alongside other kinds of comparisons. This syntax is easy to learn, but it is also easy to accidentally remove a WHERE clause needed for the join to work correctly.

  1. SELECT t1.c1, t2.c2 FROM t1, t2
  2.   WHERE
  3.   t1.id = t2.id AND t1.type_flag = t2.type_flag
  4.   AND t1.c1 > 100;

Self-joins:

Impala can do self-joins, for example to join on two different columns in the same table to represent parent-child relationships or other tree-structured data. There is no explicit syntax for this; just use the same table name for both the left-hand and right-hand table, and assign different table aliases to use when referring to the fully qualified column names:

  1. -- Combine fields from both parent and child rows.
  2. SELECT lhs.id, rhs.parent, lhs.c1, rhs.c2 FROM tree_data lhs, tree_data rhs WHERE lhs.id = rhs.parent;

Inner and outer joins:

An inner join is the most common and familiar type: rows in the result set contain the requested columns from the appropriate tables, for all combinations of rows where the join columns of the tables have identical values. If a column with the same name occurs in both tables, use a fully qualified name or a column alias to refer to the column in the select list or other clauses. Impala performs inner joins by default for both SQL-89 and SQL-92 join syntax:

  1. -- The following 3 forms are all equivalent.
  2. SELECT t1.id, c1, c2 FROM t1, t2 WHERE t1.id = t2.id;
  3. SELECT t1.id, c1, c2 FROM t1 JOIN t2 ON t1.id = t2.id;
  4. SELECT t1.id, c1, c2 FROM t1 INNER JOIN t2 ON t1.id = t2.id;

An outer join retrieves all rows from the left-hand table, or the right-hand table, or both; wherever there is no matching data in the table on the other side of the join, the corresponding columns in the result set are set to NULL. To perform an outer join, include the OUTER keyword in the join operator, along with either LEFT, RIGHT, or FULL:

  1. SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.id = t2.id;
  2. SELECT * FROM t1 RIGHT OUTER JOIN t2 ON t1.id = t2.id;
  3. SELECT * FROM t1 FULL OUTER JOIN t2 ON t1.id = t2.id;

For outer joins, Impala requires SQL-92 syntax; that is, the JOIN keyword instead of comma-separated table names. Impala does not support vendor extensions such as (+) or *= notation for doing outer joins with SQL-89 query syntax.

Equijoins and Non-Equijoins:

By default, Impala requires an equality comparison between the left-hand and right-hand tables, either through ON, USING, or WHERE clauses. These types of queries are classified broadly as equijoins. Inner, outer, full, and semi joins can all be equijoins based on the presence of equality tests between columns in the left-hand and right-hand tables.

In Impala 1.2.2 and higher, non-equijoin queries are also possible, with comparisons such as != or < between the join columns. These kinds of queries require care to avoid producing huge result sets that could exceed resource limits. Once you have planned a non-equijoin query that produces a result set of acceptable size, you can code the query using the CROSS JOIN operator, and add the extra comparisons in the WHERE clause:

  1. SELECT * FROM t1 CROSS JOIN t2 WHERE t1.total > t2.maximum_price;

In Impala 2.3 and higher, additional non-equijoin queries are possible due to the addition of nested loop joins. These queries typically involve SEMI JOIN, ANTI JOIN, or FULL OUTER JOIN clauses. Impala sometimes also uses nested loop joins internally when evaluating OUTER JOIN queries involving complex type columns. Query phases involving nested loop joins do not use the spill-to-disk mechanism if they exceed the memory limit. Impala decides internally when to use each join mechanism; you cannot specify any query hint to choose between the nested loop join or the original hash join algorithm.

  1. SELECT * FROM t1 LEFT OUTER JOIN t2 ON t1.int_col < t2.int_col;

Semi-joins:

Semi-joins are a relatively rarely used variation. With the left semi-join, only data from the left-hand table is returned, for rows where there is matching data in the right-hand table, based on comparisons between join columns in ON or WHERE clauses. Only one instance of each row from the left-hand table is returned, regardless of how many matching rows exist in the right-hand table. A right semi-join (available in Impala 2.0 and higher) reverses the comparison and returns data from the right-hand table.

  1. SELECT t1.c1, t1.c2, t1.c2 FROM t1 LEFT SEMI JOIN t2 ON t1.id = t2.id;

Natural joins (not supported):

Impala does not support the NATURAL JOIN operator, again to avoid inconsistent or huge result sets. Natural joins do away with the ON and USING clauses, and instead automatically join on all columns with the same names in the left-hand and right-hand tables. This kind of query is not recommended for rapidly evolving data structures such as are typically used in Hadoop. Thus, Impala does not support the NATURAL JOIN syntax, which can produce different query results as columns are added to or removed from tables.

If you do have any queries that use NATURAL JOIN, make sure to rewrite them with explicit USING clauses, because Impala could interpret the NATURAL keyword as a table alias:

  1. -- 'NATURAL' is interpreted as an alias for 't1' and Impala attempts an inner join,
  2. -- resulting in an error because inner joins require explicit comparisons between columns.
  3. SELECT t1.c1, t2.c2 FROM t1 NATURAL JOIN t2;
  4. ERROR: NotImplementedException: Join with 't2' requires at least one conjunctive equality predicate.
  5.   To perform a Cartesian product between two tables, use a CROSS JOIN.
  7. -- If you expect the tables to have identically named columns with matching values,
  8. -- list the corresponding column names in a USING clause.
  9. SELECT t1.c1, t2.c2 FROM t1 JOIN t2 USING (id, type_flag, name, address);

Anti-joins (Impala 2.0 and higher only):

Impala supports the LEFT ANTI JOIN and RIGHT ANTI JOIN clauses in Impala 2.0 and higher. The LEFT or RIGHT keyword is required for this kind of join. For LEFT ANTI JOIN, this clause returns those values from the left-hand table that have no matching value in the right-hand table. RIGHT ANTI JOIN reverses the comparison and returns values from the right-hand table. You can express this negative relationship either through the ANTI JOIN clause or through a NOT EXISTS operator with a subquery.

Complex type considerations:

When referring to a column with a complex type (STRUCT, ARRAY, or MAP) in a query, you use join notation to “unpack” the scalar fields of the struct, the elements of the array, or the key-value pairs of the map. (The join notation is not required for aggregation operations, such as COUNT() or SUM() for array elements.) Because Impala recognizes which complex type elements are associated with which row of the result set, you use the same syntax as for a cross or cartesian join, without an explicit join condition. See Complex Types (Impala 2.3 or higher only) for details about Impala support for complex types.

Usage notes:

You typically use join queries in situations like these:

  • When related data arrives from different sources, with each data set physically residing in a separate table. For example, you might have address data from business records that you cross-check against phone listings or census data.

    Note: Impala can join tables of different file formats, including Impala-managed tables and HBase tables. For example, you might keep small dimension tables in HBase, for convenience of single-row lookups and updates, and for the larger fact tables use Parquet or other binary file format optimized for scan operations. Then, you can issue a join query to cross-reference the fact tables with the dimension tables.

  • When data is normalized, a technique for reducing data duplication by dividing it across multiple tables. This kind of organization is often found in data that comes from traditional relational database systems. For example, instead of repeating some long string such as a customer name in multiple tables, each table might contain a numeric customer ID. Queries that need to display the customer name could “join” the table that specifies which customer ID corresponds to which name.

  • When certain columns are rarely needed for queries, so they are moved into separate tables to reduce overhead for common queries. For example, a biography field might be rarely needed in queries on employee data. Putting that field in a separate table reduces the amount of I/O for common queries on employee addresses or phone numbers. Queries that do need the biography column can retrieve it by performing a join with that separate table.
  • In Impala 2.3 or higher, when referring to complex type columns in queries. See Complex Types (Impala 2.3 or higher only) for details.

When comparing columns with the same names in ON or WHERE clauses, use the fully qualified names such as db_name.table_name, or assign table aliases, column aliases, or both to make the code more compact and understandable:

  1. select t1.c1 as first_id, t2.c2 as second_id from
  2.   t1 join t2 on first_id = second_id;
  4. select fact.custno, dimension.custno from
  5.   customer_data as fact join customer_address as dimension
  6.   using (custno)

Note:

Performance for join queries is a crucial aspect for Impala, because complex join queries are resource-intensive operations. An efficient join query produces much less network traffic and CPU overhead than an inefficient one. For best results:

  • Make sure that both table and column statistics are available for all the tables involved in a join query, and especially for the columns referenced in any join conditions. Impala uses the statistics to automatically deduce an efficient join order. Use SHOW TABLE STATS table_name and SHOW COLUMN STATS table_name to check if statistics are already present. Issue the COMPUTE STATS table_name for a nonpartitioned table, or (in Impala 2.1.0 and higher) COMPUTE INCREMENTAL STATS table_name for a partitioned table, to collect the initial statistics at both the table and column levels, and to keep the statistics up to date after any substantial INSERT or LOAD DATA operations.
  • If table or column statistics are not available, join the largest table first. You can check the existence of statistics with the SHOW TABLE STATS table_name and SHOW COLUMN STATS table_name statements.
  • If table or column statistics are not available, join subsequent tables according to which table has the most selective filter, based on overall size and WHERE clauses. Joining the table with the most selective filter results in the fewest number of rows being returned.

For more information and examples of performance for join queries, see Performance Considerations for Join Queries.

To control the result set from a join query, include the names of corresponding column names in both tables in an ON or USING clause, or by coding equality comparisons for those columns in the WHERE clause.

  1. [localhost:21000] > select c_last_name, ca_city from customer join customer_address where c_customer_sk = ca_address_sk;
  2. +-------------+-----------------+
  3. | c_last_name | ca_city         |
  4. +-------------+-----------------+
  5. | Lewis       | Fairfield       |
  6. | Moses       | Fairview        |
  7. | Hamilton    | Pleasant Valley |
  8. | White       | Oak Ridge       |
  9. | Moran       | Glendale        |
  10. ...
  11. | Richards    | Lakewood         |
  12. | Day         | Lebanon          |
  13. | Painter     | Oak Hill         |
  14. | Bentley     | Greenfield       |
  15. | Jones       | Stringtown       |
  16. +-------------+------------------+
  17. Returned 50000 row(s) in 9.82s

One potential downside of joins is the possibility of excess resource usage in poorly constructed queries. Impala imposes restrictions on join queries to guard against such issues. To minimize the chance of runaway queries on large data sets, Impala requires every join query to contain at least one equality predicate between the columns of the various tables. For example, if T1 contains 1000 rows and T2 contains 1,000,000 rows, a query SELECT columns FROM t1 JOIN t2 could return up to 1 billion rows (1000 * 1,000,000); Impala requires that the query include a clause such as ON t1.c1 = t2.c2 or WHERE t1.c1 = t2.c2.

Because even with equality clauses, the result set can still be large, as we saw in the previous example, you might use a LIMIT clause to return a subset of the results:

  1. [localhost:21000] > select c_last_name, ca_city from customer, customer_address where c_customer_sk = ca_address_sk limit 10;
  2. +-------------+-----------------+
  3. | c_last_name | ca_city         |
  4. +-------------+-----------------+
  5. | Lewis       | Fairfield       |
  6. | Moses       | Fairview        |
  7. | Hamilton    | Pleasant Valley |
  8. | White       | Oak Ridge       |
  9. | Moran       | Glendale        |
  10. | Sharp       | Lakeview        |
  11. | Wiles       | Farmington      |
  12. | Shipman     | Union           |
  13. | Gilbert     | New Hope        |
  14. | Brunson     | Martinsville    |
  15. +-------------+-----------------+
  16. Returned 10 row(s) in 0.63s

Or you might use additional comparison operators or aggregation functions to condense a large result set into a smaller set of values:

  1. [localhost:21000] > -- Find the names of customers who live in one particular town.
  2. [localhost:21000] > select distinct c_last_name from customer, customer_address where
  3.   c_customer_sk = ca_address_sk
  4.   and ca_city = "Green Acres";
  5. +---------------+
  6. | c_last_name   |
  7. +---------------+
  8. | Hensley       |
  9. | Pearson       |
  10. | Mayer         |
  11. | Montgomery    |
  12. | Ricks         |
  13. ...
  14. | Barrett       |
  15. | Price         |
  16. | Hill          |
  17. | Hansen        |
  18. | Meeks         |
  19. +---------------+
  20. Returned 332 row(s) in 0.97s
  22. [localhost:21000] > -- See how many different customers in this town have names starting with "A".
  23. [localhost:21000] > select count(distinct c_last_name) from customer, customer_address where
  24.   c_customer_sk = ca_address_sk
  25.   and ca_city = "Green Acres"
  26.   and substr(c_last_name,1,1) = "A";
  27. +-----------------------------+
  28. | count(distinct c_last_name) |
  29. +-----------------------------+
  30. | 12                          |
  31. +-----------------------------+
  32. Returned 1 row(s) in 1.00s

Because a join query can involve reading large amounts of data from disk, sending large amounts of data across the network, and loading large amounts of data into memory to do the comparisons and filtering, you might do benchmarking, performance analysis, and query tuning to find the most efficient join queries for your data set, hardware capacity, network configuration, and cluster workload.

The two categories of joins in Impala are known as partitioned joins and broadcast joins. If inaccurate table or column statistics, or some quirk of the data distribution, causes Impala to choose the wrong mechanism for a particular join, consider using query hints as a temporary workaround. For details, see Optimizer Hints.

Handling NULLs in Join Columns:

By default, join key columns do not match if either one contains a NULL value. To treat such columns as equal if both contain NULL, you can use an expression such as A = B OR (A IS NULL AND B IS NULL). In Impala 2.5 and higher, the <=> operator (shorthand for IS NOT DISTINCT FROM) performs the same comparison in a concise and efficient form. The <=> operator is more efficient in for comparing join keys in a NULL-safe manner, because the operator can use a hash join while the OR expression cannot.

Examples:

The following examples refer to these simple tables containing small sets of integers:

  1. [localhost:21000] > create table t1 (x int);
  2. [localhost:21000] > insert into t1 values (1), (2), (3), (4), (5), (6);
  4. [localhost:21000] > create table t2 (y int);
  5. [localhost:21000] > insert into t2 values (2), (4), (6);
  7. [localhost:21000] > create table t3 (z int);
  8. [localhost:21000] > insert into t3 values (1), (3), (5);

The following example demonstrates an anti-join, returning the values from T1 that do not exist in T2 (in this case, the odd numbers 1, 3, and 5):

  1. [localhost:21000] > select x from t1 left anti join t2 on (t1.x = t2.y);
  2. +---+
  3. | x |
  4. +---+
  5. | 1 |
  6. | 3 |
  7. | 5 |
  8. +---+

Related information:

See these tutorials for examples of different kinds of joins:

Parent topic: SELECT Statement