[HINT_EXPLAIN]

标准 SQL 写法的表连接查询

SQL 示例如下：

select [HINT_EXPLAIN] * from pt1 left join t2 on pt1.p1=t2.p2 where p1+p2>4 and p2 < 6

使用标准 SQL 写法的表连接查询的显示输出由如下模块依情况进行组合，且一个模块的输出中也可能包含其他模块的输出：

• SQL 引擎
• 多表 Join 框架
• Pipelined Join 执行过程
• 串行 Join 执行过程
• 取数据过程

SQL 引擎

{
    "measurement": "microsecond",
    "explain": {
        // <UniversalTableJoinImp explain 结果>
        "rows": 10,                             //查询返回的记录数
        "cost": 237                             //查询耗时
    },
}

多表 Join 框架

• numPipelinedStages：能用 pipeline 的 join 数量。
• numSerialStages：不能用 pipeline 的 join 数量。
• pipelinedStages：包含 Pipelined Join 执行过程的 explain 结果。下节将详细介绍。
• serialStages：包含串行 Join 执行过程的 explain 结果。后文将详细介绍。

"numPipelinedStages": 2, 
"numSerialStages": 3,              
"pipelinedStages": {
    // <Pipelined Join 执行过程的 explain 结果>
},
"serialStages": {
    // <串行 Join 执行过程的 explain 结果>
}

Pipelined Join 执行过程如下：

• rows：pipeline 阶段产生结果的行数。
• cost：pipeline 阶段总耗时。
• numTasks：pipeline 任务数。
• most：耗时最长的任务。
  • cost：此 pipeline 运行耗时。
  • segments：此 pipeline 每张表的分区 path，如果是内存表则为""，如果是分区表但被剪枝则为"<Empty Segment>"。
  • explain：
    • left：取数据过程的 explain 结果，如果是分区表但被剪枝则为 "sql":"<Empty Segment>"。
    • right：取数据过程的 explain 结果。
    • join：
      • script：join 操作的脚本。
      • predicates：下推到此次 join 的谓词。
      • rows：此次 join 的结果行数。
      • cost：join 运行耗时。
  • least：耗时最短的任务，格式与most相同。
  • resultPartitionInfo：join 结果的分区信息。
    • isPartitioned：join 结果是否分区，如果为 true 则有下面的字段。
    • estimatedRows：估计的总行数。
    • domainType：结果复用的 database 的分区方式，如果没有复用，值为 NULL。
    • domainScheme：如果 "domainType" 不为 NULL，其分区 scheme。
    • partitionColumns：结果分区列。
    • useSeqPartition：结果是否用 SEQ 方式分区。
  • totalExecutionCost：执行 pipeline 任务的总耗时（不包含生成分区表的耗时）。
  • totalAppendCost：结果生成分区表的总耗时。
  • final：最终查询结果。如果 pipeline 覆盖所有 join，会有一次最终查询，下面是对应的 explain 结果、
    • sql：最终查询 SQL。
    • rows：最终查询的结果行数 。
    • cost：最终查询耗时。
    • explain：最终查询的 explain 结果。

"pipelinedStages": {
    "rows": 10,                    
    "cost": 35,                   
    "numTasks": 10,                
    "most": {                     
        "cost": 20,              
        "segments": [
            "20210101/Key1",
            ""
        ],
        "explain": {
            "stage1": {
                "left": {
                    // <取数据过程的 explain 结果>
                },
                "right": {
                    // <取数据过程的 explain 结果>
                },
                "join": {
                    "script": "ej(t1, t2, `id, `id)",     
                    "predicates": [
                        "t1.id > 3",
                        "t2.id < 5"
                    ],
                    "rows": 10,                   
                    "cost": 152                   
                }
            },
            "stage2": {
                "right": {
                    // <取数据过程的 explain 结果>
                },
                "join": {
                    // 与上面 "join" 格式相同
                }
            },
            ...
        }
    },
    "least": {
        // 与 "most" 格式相同
    },
    "resultPartitionInfo": {
        "isPartitioned": true,                  
        "estimatedRows": 50000,                 
        "domainType": "NULL/VALUE/HASH/...",    
        "domainScheme": [1, 2, 3],             
        "partitionColumns": ["col1", "col2"],  
        "useSeqPartition": false                
    "totalExecutionCost": 20,                   
    "totalAppendCost": 30,                     
    "final": {
        "sql": "...",       
        "rows": 10,         
        "cost": 237,       
        "explain": {
            // <最终查询的 explain 结果>
        }
    }
},

串行 Join 执行过程

• rows：串行阶段产生结果的行数。
• cost：串行阶段总耗时。
• stage：编号从 pipeline 后一个编号开始。如果完全没有 pipeline 阶段，第一次 join 会有 "left"，即取左表数据的 explain 结果。
• left：取数据过程的 explain 结果。
• right：取数据过程的 explain 结果。
• resultPartitionInfo：join 结果的分区信息。
  • partitionParamsSet：此次 join 结果是否尝试分区。对除了最后一次以外的join，"partitionParamsSet" 为 true，且有其他字段。
  • forcePartition：是否强制生成分区结果。
  • domainType：结果复用的 database 的分区方式，如果没有复用，值为 NULL。
  • domainScheme：如果 "domainType" 不为 NULL，其分区 scheme。
  • partitionColumns：结果分区列。
  • useSeqPartition：结果是否用 SEQ 方式分区。
  • numForcedPartitions：在 "domainType" 为 NULL 且 "useSeqPartition" 为 false 时默认 HASH 分区的强制分区数量，-1 为未设置。

"serialStages": {
    "rows": 10,                         
    "cost": 30,                         
    "stage3": {
        "left": {
            // <取数据过程的 explain 结果>
        },
        "right": {
            // <取数据过程的 explain 结果>
        },
        "join": {
            "sql": "...",              
            "rows": 10,                 
            "cost": 237,                
            "resultPartitionInfo": {
                "partitionParamsSet": true,             
                                                       
                "forcePartition": true,                 
                "domainType": "NULL/VALUE/HASH/...",    
                "domainScheme": [1, 2, 3],              
                "partitionColumns": ["col1", "col2"],   
                "useSeqPartition": false                
                "numForcedPartitions": -1,                                                                  
            },
            "explain": {
                // <本次 join 查询的 explain 结果>
            }
        }
    },
    "stage4": {
        "right": {
            // <取数据过程的 explain 结果>
        },
        "join": {
            // 与上面的 "join" 格式相同
        }
    },
    ...
},

取数据过程

• sql：取数据的 SQL。
• rows：取到的数据条数。
• cost：取数据 SQL 运行耗时。
• resultPartitionInfo：join 结果的分区信息。
  • partitionParamsSet：取数据结果是否尝试分区；若为 true，且有其他字段。
  • forcePartition：是否强制生成分区结果。
  • domainType：结果复用的 database 的分区方式，如果没有复用，值为 NULL。
  • domainScheme：如果 "domainType" 不为 NULL，其分区 scheme。
  • partitionColumns：结果分区列
  • useSeqPartition：结果是否用 SEQ 方式分区。
  • numForcedPartitions：在 "domainType" 为 NULL 且 "useSeqPartition" 为 false 时默认 HASH 分区的强制分区数量，-1 为未设置。

"sql": "...",       
"rows": 10,          
"cost": 237,        
"resultPartitionInfo": {
    "partitionParamsSet": true,             
    "forcePartition": true,                 
    "domainType": "NULL/VALUE/HASH/...",    
    "domainScheme": [1, 2, 3],              
    "partitionColumns": ["col1", "col2"],   
    "useSeqPartition": false                
    "numForcedPartitions": -1,                                                         
},
"explain": {
    // <取当前表数据的查询的 explain 结果>
}

使用函数写法的 Join 查询

由于分区全部覆盖，使用函数写法的 Join 查询的 explain 的结果维持原先格式。SQL 语句示例：

select [HINT_EXPLAIN] * from ej(pt1,pt2,`p1,`p2)

使用 cj 的特殊情况说明：

在满足以下所有条件时，连续 cj 的输出结果遵循前文所述的标准 SQL 输出结构：

• 查询的 from 是不涉及分区内存表的连续多表 cj，不涉及其他 join 类型。
• 嵌套的任何一次 cj 只能出现在外层 cj 的左表。
  • 这是一个符合条件的例子：cj(cj(cj(t1, t2), t3), t4)
  • 这是一个不符合条件的例子：cj(t1, cj(t2, t3))
• cj 以及 表 的外面可以嵌套任意个子查询，但不能是 pivot by 查询。例子：

  select * from cj(select * from cj(select * from cj(t1, t2), t3), select * from
                  t4)