join kind helpers

dbms/src/Interpreters/ExpressionActions.cpp

@@ -1112,7 +1112,7 @@ void ExpressionActions::optimizeArrayJoin()
 BlockInputStreamPtr ExpressionActions::createStreamWithNonJoinedDataIfFullOrRightJoin(const Block & source_header, UInt64 max_block_size) const
 {
     for (const auto & action : actions)
-        if (action.join && (action.join->getKind() == ASTTableJoin::Kind::Full || action.join->getKind() == ASTTableJoin::Kind::Right))
+        if (action.join && isRightOrFull(action.join->getKind()))
             return action.join->createStreamWithNonJoinedRows(
                 source_header, action.join_key_names_left, action.columns_added_by_join, max_block_size);
 

dbms/src/Interpreters/InterpreterSelectQuery.cpp

@@ -569,7 +569,7 @@ void InterpreterSelectQuery::executeImpl(Pipeline & pipeline, const BlockInputSt
             if (expressions.hasJoin())
             {
                 const ASTTableJoin & join = static_cast<const ASTTableJoin &>(*query.join()->table_join);
-                if (join.kind == ASTTableJoin::Kind::Full || join.kind == ASTTableJoin::Kind::Right)
+                if (isRightOrFull(join.kind))
                     pipeline.stream_with_non_joined_data = expressions.before_join->createStreamWithNonJoinedDataIfFullOrRightJoin(
                         pipeline.firstStream()->getHeader(), settings.max_block_size);
 

dbms/src/Interpreters/Join.cpp

@@ -220,13 +220,6 @@ struct KeyGetterForType
 };
 
 
-/// Do I need to use the hash table maps_*_full, in which we remember whether the row was joined.
-static bool getFullness(ASTTableJoin::Kind kind)
-{
-    return kind == ASTTableJoin::Kind::Right || kind == ASTTableJoin::Kind::Full;
-}
-
-
 void Join::init(Type type_)
 {
     type = type_;
@@ -340,7 +333,7 @@ void Join::setSampleBlock(const Block & block)
     }
 
     /// In case of LEFT and FULL joins, if use_nulls, convert joined columns to Nullable.
-    if (use_nulls && (kind == ASTTableJoin::Kind::Left || kind == ASTTableJoin::Kind::Full))
+    if (use_nulls && isLeftOrFull(kind))
         for (size_t i = 0; i < num_columns_to_add; ++i)
             convertColumnToNullable(sample_block_with_columns_to_add.getByPosition(i));
 }
@@ -476,7 +469,7 @@ bool Join::insertFromBlock(const Block & block)
     blocks.push_back(block);
     Block * stored_block = &blocks.back();
 
-    if (getFullness(kind))
+    if (isRightOrFull(kind))
     {
         /** Move the key columns to the beginning of the block.
           * This is where NonJoinedBlockInputStream will expect.
@@ -511,9 +504,9 @@ bool Join::insertFromBlock(const Block & block)
         stored_block->safeGetByPosition(i).column = stored_block->safeGetByPosition(i).column->convertToFullColumnIfConst();
 
     /// In case of LEFT and FULL joins, if use_nulls, convert joined columns to Nullable.
-    if (use_nulls && (kind == ASTTableJoin::Kind::Left || kind == ASTTableJoin::Kind::Full))
+    if (use_nulls && isLeftOrFull(kind))
     {
-        for (size_t i = getFullness(kind) ? keys_size : 0; i < size; ++i)
+        for (size_t i = isFull(kind) ? keys_size : 0; i < size; ++i)
         {
             convertColumnToNullable(stored_block->getByPosition(i));
         }
@@ -721,7 +714,7 @@ void Join::joinBlockImpl(
       * Because if they are constants, then in the "not joined" rows, they may have different values
       *  - default values, which can differ from the values of these constants.
       */
-    if (getFullness(kind))
+    if (isRightOrFull(kind))
     {
         for (size_t i = 0; i < existing_columns; ++i)
         {
@@ -741,7 +734,7 @@ void Join::joinBlockImpl(
       *  but they will not be used at this stage of joining (and will be in `AdderNonJoined`), and they need to be skipped.
       */
     size_t num_columns_to_skip = 0;
-    if (getFullness(kind))
+    if (isRightOrFull(kind))
         num_columns_to_skip = keys_size;
 
     /// Add new columns to the block.
@@ -798,7 +791,7 @@ void Join::joinBlockImpl(
 
     if (strictness == ASTTableJoin::Strictness::Any)
     {
-        if (kind == ASTTableJoin::Kind::Inner || kind == ASTTableJoin::Kind::Right)
+        if (isInnerOrRight(kind))
         {
             /// If ANY INNER | RIGHT JOIN - filter all the columns except the new ones.
             for (size_t i = 0; i < existing_columns; ++i)

dbms/src/Interpreters/SyntaxAnalyzer.cpp

@@ -573,7 +573,7 @@ void collectJoinedColumns(AnalyzedJoin & analyzed_join, const ASTSelectQuery & s
     else if (table_join.on_expression)
         collectJoinedColumnsFromJoinOnExpr(analyzed_join, table_join);
 
-    bool make_nullable = join_use_nulls && (table_join.kind == ASTTableJoin::Kind::Left || table_join.kind == ASTTableJoin::Kind::Full);
+    bool make_nullable = join_use_nulls && isLeftOrFull(table_join.kind);
 
     analyzed_join.calculateAvailableJoinedColumns(make_nullable);
 }

dbms/src/Parsers/ASTTablesInSelectQuery.h

@@ -106,6 +106,11 @@ struct ASTTableJoin : public IAST
     void formatImpl(const FormatSettings & settings, FormatState & state, FormatStateStacked frame) const override;
 };
 
+inline bool isFull(ASTTableJoin::Kind kind)         { return kind == ASTTableJoin::Kind::Full; }
+inline bool isRightOrFull(ASTTableJoin::Kind kind)  { return kind == ASTTableJoin::Kind::Right || kind == ASTTableJoin::Kind::Full; }
+inline bool isLeftOrFull(ASTTableJoin::Kind kind)   { return kind == ASTTableJoin::Kind::Left  || kind == ASTTableJoin::Kind::Full; }
+inline bool isInnerOrRight(ASTTableJoin::Kind kind) { return kind == ASTTableJoin::Kind::Inner || kind == ASTTableJoin::Kind::Right; }
+
 
 /// Specification of ARRAY JOIN.
 struct ASTArrayJoin : public IAST