El principio de MapReduce para implementar operaciones SQL básicas:
El principio de realización de Join:
select s.sname, c.cname from class c join student s on c.uid = s.uid;
Etiquete los datos de diferentes tablas en el valor de salida del mapa y juzgue la fuente de datos de acuerdo con la etiqueta en la etapa de reducción. El proceso de MapReduce es el siguiente:
Unión común:
Escenarios aplicables: aplicable a todos los tipos de asociaciones de tablas y tipos de combinación que no son compatibles con otros tipos de combinaciones, como: combinación externa completa
Etapa del mapa : lea los datos de la tabla de origen y utilice la columna en la condición Join on como clave cuando se genere el mapa. Si el Join tiene varias claves asociadas, la combinación de estas claves asociadas se utiliza como clave; la El valor generado por el mapa es la preocupación después de la combinación. La columna (necesaria en seleccionar o dónde), y la información de la etiqueta de la tabla también se incluye en el valor para indicar a qué tabla corresponde el valor.
Etapa aleatoria : Hash de acuerdo con el valor de la clave, y empuje la clave / valor a diferentes reductores de acuerdo con el valor de hash, para garantizar que las mismas claves en las dos tablas estén en la misma reducción.
Fase de reducción : completa la operación de unión según el valor de la clave, durante la cual se identifican los datos en diferentes tablas a través del Tag.
Unirse al mapa:
Escenarios aplicables: tablas pequeñas (tablas de dimensiones) se unen a tablas grandes (tablas de hechos), no se aplica a la combinación externa Derecha / Completa.
Si la tabla asociada es lo suficientemente pequeña, la tabla pequeña se puede cargar en la memoria del mapeador y la unión se puede completar en el lado del mapa para reducir la mezcla y reducir las etapas. La tarea local de MapReduce leerá la pequeña tabla de HDFS antes de la tarea de unión de MapReduce real, luego la convertirá en un archivo tar y, finalmente, cargará el archivo en la caché de HDFS. Durante la operación de la tarea local de MapReduce, puede fallar debido a memoria insuficiente hive.mapjoin.localtask.max.memory.usageEl tamaño de la memoria que puede utilizar la tarea local se puede cambiar mediante la configuración .
El principio de realización de Group By:
select uid,city, count(*) from student group by uid,city;
Debido a que MapReduce necesita extraer datos de la tabla de múltiples bloques de archivos, habrá un paso de ordenación aleatoria
Agregación del lado del mapa: agregación previa del lado del mapa, lo que reduce la cantidad de datos aleatorios, similar al Combiner en MR. De forma predeterminada, Hive usará la agregación del lado del mapa tanto como sea posible, pero si Hash Map no puede reducir de manera efectiva el uso de memoria, se degradará a agregación ordinaria, es decir, el lado del mapa solo hace Shuffle Write y Reducer realiza operaciones de agregación reales .
Sesgo: el plan de consulta generado tiene dos tareas MapReduce. En el primer MapReduce, el conjunto de resultados de salida del mapa se distribuye aleatoriamente a la reducción, y cada reducción realiza una operación de agregación parcial y genera el resultado. El resultado de este procesamiento es que el mismo Group By Key se puede distribuir a diferentes reductores, para lograr el propósito de balanceo de carga; la segunda tarea MapReduce luego se distribuye para reducir según el Group By Key de acuerdo con los resultados de los datos preprocesados. (este proceso se puede garantizar que el mismo Group By Key se distribuye a la misma reducción), y finalmente se completa la operación de agregación final.
El principio de realización de Distinct:
select city, count(distinct uid) from student group by city;
- El primer paso es calcular parte del valor en el mapeador. City y uid se utilizarán como clave. Si es distinto y ha aparecido antes, entonces este cálculo se ignora. El primer paso es usar la combinación como clave, y el segundo paso es usar la ciudad como clave.
- ReduceSink se ejecuta durante mapper.close (), y el resultado se genera durante GroupByOperator.close (). Tenga en cuenta que aunque la clave es ciudad y uid, la partición se basa en la ciudad al reducir.
- El valor calculado por distinto en el primer paso es inútil, y debe calcularse mediante reducción para ser exacto. Aquí simplemente reduzca las filas con la misma combinación de teclas.
- Distinct juzga si hacer +1 o no comparando lastInvoke (porque la reducción está ordenada, por lo que se juzga si el campo de distict ha cambiado, si no ha cambiado, no será +1)
Explique el plan de ejecución:
hive> explain select city, count(distinct uid) from student group by city;
OK
ABSTRACT SYNTAX TREE:
(TOK_QUERY (TOK_FROM (TOK_TABREF (TOK_TABNAME student))) (TOK_INSERT (TOK_DESTINATION (TOK_DIR TOK_TMP_FILE)) (TOK_SELECT (TOK_SELEXPR (TOK_TABLE_OR_COL city)) (TOK_SELEXPR (TOK_FUNCTIONDI city (TOK_TABLE_OR_COL uid)))) (TOK_GROUPBY (TOK_TABLE_OR_COL city))))
STAGE DEPENDENCIES://显示各个阶段的依赖关系
Stage-1 is a root stage//阶段一
Stage-0 is a root stage//阶段二
STAGE PLANS:
Stage: Stage-1
Map Reduce
Alias -> Map Operator Tree://Map阶段
student
TableScan //TableScan以student表作为输入
alias: student
Select Operator//列裁剪，取出uid，city字段
expressions:
expr: city
type: string
expr: uid
type: string
outputColumnNames: city, uid
Group By Operator //map聚集
aggregations:
expr: city(DISTINCT uid) //group by Operator 的聚集表达式
bucketGroup: false
keys:
expr: city
type: string
expr: uid
type: string
mode: hash //hash方式
outputColumnNames: _col0, _col1, _col2 //为临时结果字段按规则起的临时字段名
Reduce Output Operator
key expressions: //输出的键
expr: _col0 //city
type: string
expr: _col1 //uid
type: string
sort order: ++
Map-reduce partition columns: //这里是按group by的字段分区的
expr: _col0 //这里表示city
type: string
tag: -1
value expressions:
expr: _col2
type: bigint
Reduce Operator Tree:
Group By Operator //第二次聚集
aggregations:
expr: city(DISTINCT KEY._col1:0._col0) //uid:city
bucketGroup: false
keys:
expr: KEY._col0 //city
type: string
mode: mergepartial //合并
outputColumnNames: _col0, _col1
Select Operator //列裁剪
expressions:
expr: _col0
type: string
expr: _col1
type: bigint
outputColumnNames: _col0, _col1
File Output Operator //输出结果到文件
compressed: false
GlobalTableId: 0
table:
input format: org.apache.hadoop.mapred.TextInputFormat
output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
Stage: Stage-0
Fetch Operator
limit: -1
Parámetros relacionados
# 是否开启mapper端聚合
hive.map.aggr
# 是否开启，如果数据倾斜，是否优化group by为两个MR job
#该配置会触发hive增加额外的mr过程，随机化key后进行聚合操作得到中间结果，再对中间结果执行最终的聚合操作。
#count(distinct)操作比较特殊，无法进行中间的聚合操作，因此该参数对有count(distinct)操作的sql不适用。
hive.groupby.skewindata
# 用于map端聚合的hashtable最大可用内存，如果超过该内存比例，将flush到磁盘
hive.map.aggr.hash.force.flush.memory.threshold
# 可以用于mapper端hatable的内存比例
hive.map.aggr.hash.percentmemory (Default: 0.5) – Percent of total map task memory that can be used for hash table.
# 如果hashtable大小/输入行数 大于该阈值，那么停止hash聚合,转为sort-based aggregation
hive.map.aggr.hash.min.reduction (Default: 0.5)
# 每隔多少行，检测hashtable大小和input row比例是否超过阈值
hive.groupby.mapaggr.checkinterval
# 是否开启bucket group by
hive.optimize.groupby
# 是否自动转换common join为map join
set hive.auto.convert.join=true;
# 如果join的小表和小于该阈值，会尝试将Common join 转换成map join。通过explain命令，可以发现Operator树中有conditional Operator。 如果n-1张表大小和，小于该阈值，则生成conditional tasks。
hive.smalltable.filesize or hive.mapjoin.smalltable.filesize
# 如果join的小表小于该阈值，会直接将Common join转换成Map join。需要考虑到数据解压之后的实际大小，hive表在被解压后，文件大小可能会增大10倍。
hive.auto.convert.join.noconditionaltask.size
Referencia:
proceso de compilación de Hivesql