http://git-wip-us.apache.org/repos/asf/hive/blob/16d28b34/ql/src/test/results/clientpositive/llap/vector_nullsafe_join.q.out
----------------------------------------------------------------------
diff --git a/ql/src/test/results/clientpositive/llap/vector_nullsafe_join.q.out 
b/ql/src/test/results/clientpositive/llap/vector_nullsafe_join.q.out
index 06e30d8..cf90430 100644
--- a/ql/src/test/results/clientpositive/llap/vector_nullsafe_join.q.out
+++ b/ql/src/test/results/clientpositive/llap/vector_nullsafe_join.q.out
@@ -49,11 +49,15 @@ POSTHOOK: Output: default@myinput1
 POSTHOOK: Lineage: myinput1.key SIMPLE 
[(myinput1_txt)myinput1_txt.FieldSchema(name:key, type:int, comment:null), ]
 POSTHOOK: Lineage: myinput1.value SIMPLE 
[(myinput1_txt)myinput1_txt.FieldSchema(name:value, type:int, comment:null), ]
 PREHOOK: query: -- merging
-explain select * from myinput1 a join myinput1 b on a.key<=>b.value
+explain vectorization expression select * from myinput1 a join myinput1 b on 
a.key<=>b.value
 PREHOOK: type: QUERY
 POSTHOOK: query: -- merging
-explain select * from myinput1 a join myinput1 b on a.key<=>b.value
+explain vectorization expression select * from myinput1 a join myinput1 b on 
a.key<=>b.value
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -71,12 +75,20 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Map Join Operator
                     condition map:
                          Inner Join 0 to 1
                     keys:
                       0 key (type: int)
                       1 value (type: int)
+                    Map Join Vectorization:
+                        className: VectorMapJoinOperator
+                        native: false
+                        nativeConditionsMet: hive.execution.engine tez IN 
[tez, spark] IS true, One MapJoin Condition IS true, Supports Key Types IS 
true, Not empty key IS true, When Fast Hash Table, then requires no Hybrid Hash 
Join IS true, Small table vectorizes IS true
+                        nativeConditionsNotMet: 
hive.vectorized.execution.mapjoin.native.enabled IS false, No nullsafe IS false
                     nullSafes: [true]
                     outputColumnNames: _col0, _col1, _col5, _col6
                     input vertices:
@@ -85,9 +97,16 @@ STAGE PLANS:
                     Select Operator
                       expressions: _col0 (type: int), _col1 (type: int), _col5 
(type: int), _col6 (type: int)
                       outputColumnNames: _col0, _col1, _col2, _col3
+                      Select Vectorization:
+                          className: VectorSelectOperator
+                          native: true
+                          projectedOutputColumns: [0, 1, 2, 3]
                       Statistics: Num rows: 6 Data size: 26 Basic stats: 
COMPLETE Column stats: NONE
                       File Output Operator
                         compressed: false
+                        File Sink Vectorization:
+                            className: VectorFileSinkOperator
+                            native: false
                         Statistics: Num rows: 6 Data size: 26 Basic stats: 
COMPLETE Column stats: NONE
                         table:
                             input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -95,19 +114,42 @@ STAGE PLANS:
                             serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: value (type: int)
                     sort order: +
                     Map-reduce partition columns: value (type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkLongOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     value expressions: key (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator
@@ -134,10 +176,14 @@ NULL      35      NULL    NULL
 NULL   NULL    10      NULL
 NULL   NULL    48      NULL
 NULL   NULL    NULL    NULL
-PREHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value join myinput1 c on a.key=c.key
+PREHOOK: query: explain vectorization expression select * from myinput1 a join 
myinput1 b on a.key<=>b.value join myinput1 c on a.key=c.key
 PREHOOK: type: QUERY
-POSTHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value join myinput1 c on a.key=c.key
+POSTHOOK: query: explain vectorization expression select * from myinput1 a 
join myinput1 b on a.key<=>b.value join myinput1 c on a.key=c.key
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -155,7 +201,14 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 0) -> 
boolean
                     predicate: key is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Map Join Operator
@@ -166,6 +219,11 @@ STAGE PLANS:
                         0 key (type: int)
                         1 value (type: int)
                         2 key (type: int)
+                      Map Join Vectorization:
+                          className: VectorMapJoinOperator
+                          native: false
+                          nativeConditionsMet: hive.execution.engine tez IN 
[tez, spark] IS true, No nullsafe IS true, Supports Key Types IS true, Not 
empty key IS true, When Fast Hash Table, then requires no Hybrid Hash Join IS 
true, Small table vectorizes IS true
+                          nativeConditionsNotMet: 
hive.vectorized.execution.mapjoin.native.enabled IS false, One MapJoin 
Condition IS false
                       outputColumnNames: _col0, _col1, _col5, _col6, _col10, 
_col11
                       input vertices:
                         1 Map 2
@@ -174,9 +232,16 @@ STAGE PLANS:
                       Select Operator
                         expressions: _col0 (type: int), _col1 (type: int), 
_col5 (type: int), _col6 (type: int), _col10 (type: int), _col11 (type: int)
                         outputColumnNames: _col0, _col1, _col2, _col3, _col4, 
_col5
+                        Select Vectorization:
+                            className: VectorSelectOperator
+                            native: true
+                            projectedOutputColumns: [0, 1, 2, 3, 4, 5]
                         Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                         File Output Operator
                           compressed: false
+                          File Sink Vectorization:
+                              className: VectorFileSinkOperator
+                              native: false
                           Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                           table:
                               input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -184,38 +249,84 @@ STAGE PLANS:
                               serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 1) -> 
boolean
                     predicate: value is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: value (type: int)
                       sort order: +
                       Map-reduce partition columns: value (type: int)
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkLongOperator
+                          native: true
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                       Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                       value expressions: key (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 3 
             Map Operator Tree:
                 TableScan
                   alias: c
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 0) -> 
boolean
                     predicate: key is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: key (type: int)
                       sort order: +
                       Map-reduce partition columns: key (type: int)
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkLongOperator
+                          native: true
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                       Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                       value expressions: value (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator
@@ -233,10 +344,14 @@ POSTHOOK: Input: default@myinput1
 #### A masked pattern was here ####
 10     NULL    NULL    10      10      NULL
 100    100     100     100     100     100
-PREHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value join myinput1 c on a.key<=>c.key
+PREHOOK: query: explain vectorization expression select * from myinput1 a join 
myinput1 b on a.key<=>b.value join myinput1 c on a.key<=>c.key
 PREHOOK: type: QUERY
-POSTHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value join myinput1 c on a.key<=>c.key
+POSTHOOK: query: explain vectorization expression select * from myinput1 a 
join myinput1 b on a.key<=>b.value join myinput1 c on a.key<=>c.key
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -254,6 +369,9 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Map Join Operator
                     condition map:
                          Inner Join 0 to 1
@@ -262,6 +380,11 @@ STAGE PLANS:
                       0 key (type: int)
                       1 value (type: int)
                       2 key (type: int)
+                    Map Join Vectorization:
+                        className: VectorMapJoinOperator
+                        native: false
+                        nativeConditionsMet: hive.execution.engine tez IN 
[tez, spark] IS true, Supports Key Types IS true, Not empty key IS true, When 
Fast Hash Table, then requires no Hybrid Hash Join IS true, Small table 
vectorizes IS true
+                        nativeConditionsNotMet: 
hive.vectorized.execution.mapjoin.native.enabled IS false, One MapJoin 
Condition IS false, No nullsafe IS false
                     nullSafes: [true]
                     outputColumnNames: _col0, _col1, _col5, _col6, _col10, 
_col11
                     input vertices:
@@ -271,9 +394,16 @@ STAGE PLANS:
                     Select Operator
                       expressions: _col0 (type: int), _col1 (type: int), _col5 
(type: int), _col6 (type: int), _col10 (type: int), _col11 (type: int)
                       outputColumnNames: _col0, _col1, _col2, _col3, _col4, 
_col5
+                      Select Vectorization:
+                          className: VectorSelectOperator
+                          native: true
+                          projectedOutputColumns: [0, 1, 2, 3, 4, 5]
                       Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                       File Output Operator
                         compressed: false
+                        File Sink Vectorization:
+                            className: VectorFileSinkOperator
+                            native: false
                         Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                         table:
                             input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -281,32 +411,70 @@ STAGE PLANS:
                             serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: value (type: int)
                     sort order: +
                     Map-reduce partition columns: value (type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkLongOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     value expressions: key (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 3 
             Map Operator Tree:
                 TableScan
                   alias: c
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: key (type: int)
                     sort order: +
                     Map-reduce partition columns: key (type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkLongOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     value expressions: value (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator
@@ -351,10 +519,14 @@ NULL      NULL    48      NULL    NULL    NULL
 NULL   NULL    NULL    NULL    NULL    10
 NULL   NULL    NULL    NULL    NULL    35
 NULL   NULL    NULL    NULL    NULL    NULL
-PREHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value AND a.value=b.key join myinput1 c on a.key<=>c.key AND 
a.value=c.value
+PREHOOK: query: explain vectorization expression select * from myinput1 a join 
myinput1 b on a.key<=>b.value AND a.value=b.key join myinput1 c on 
a.key<=>c.key AND a.value=c.value
 PREHOOK: type: QUERY
-POSTHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value AND a.value=b.key join myinput1 c on a.key<=>c.key AND 
a.value=c.value
+POSTHOOK: query: explain vectorization expression select * from myinput1 a 
join myinput1 b on a.key<=>b.value AND a.value=b.key join myinput1 c on 
a.key<=>c.key AND a.value=c.value
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -372,7 +544,14 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 1) -> 
boolean
                     predicate: value is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Map Join Operator
@@ -383,6 +562,11 @@ STAGE PLANS:
                         0 key (type: int), value (type: int)
                         1 value (type: int), key (type: int)
                         2 key (type: int), value (type: int)
+                      Map Join Vectorization:
+                          className: VectorMapJoinOperator
+                          native: false
+                          nativeConditionsMet: hive.execution.engine tez IN 
[tez, spark] IS true, Supports Key Types IS true, Not empty key IS true, When 
Fast Hash Table, then requires no Hybrid Hash Join IS true, Small table 
vectorizes IS true
+                          nativeConditionsNotMet: 
hive.vectorized.execution.mapjoin.native.enabled IS false, One MapJoin 
Condition IS false, No nullsafe IS false
                       nullSafes: [true, false]
                       outputColumnNames: _col0, _col1, _col5, _col6, _col10, 
_col11
                       input vertices:
@@ -392,9 +576,16 @@ STAGE PLANS:
                       Select Operator
                         expressions: _col0 (type: int), _col1 (type: int), 
_col5 (type: int), _col6 (type: int), _col10 (type: int), _col11 (type: int)
                         outputColumnNames: _col0, _col1, _col2, _col3, _col4, 
_col5
+                        Select Vectorization:
+                            className: VectorSelectOperator
+                            native: true
+                            projectedOutputColumns: [0, 1, 2, 3, 4, 5]
                         Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                         File Output Operator
                           compressed: false
+                          File Sink Vectorization:
+                              className: VectorFileSinkOperator
+                              native: false
                           Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                           table:
                               input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -402,36 +593,82 @@ STAGE PLANS:
                               serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 0) -> 
boolean
                     predicate: key is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: value (type: int), key (type: int)
                       sort order: ++
                       Map-reduce partition columns: value (type: int), key 
(type: int)
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkMultiKeyOperator
+                          native: true
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                       Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 3 
             Map Operator Tree:
                 TableScan
                   alias: c
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 1) -> 
boolean
                     predicate: value is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: key (type: int), value (type: int)
                       sort order: ++
                       Map-reduce partition columns: key (type: int), value 
(type: int)
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkMultiKeyOperator
+                          native: true
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                       Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator
@@ -449,10 +686,14 @@ POSTHOOK: Input: default@myinput1
 #### A masked pattern was here ####
 100    100     100     100     100     100
 NULL   10      10      NULL    NULL    10
-PREHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value AND a.value<=>b.key join myinput1 c on a.key<=>c.key AND 
a.value<=>c.value
+PREHOOK: query: explain vectorization expression select * from myinput1 a join 
myinput1 b on a.key<=>b.value AND a.value<=>b.key join myinput1 c on 
a.key<=>c.key AND a.value<=>c.value
 PREHOOK: type: QUERY
-POSTHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value AND a.value<=>b.key join myinput1 c on a.key<=>c.key AND 
a.value<=>c.value
+POSTHOOK: query: explain vectorization expression select * from myinput1 a 
join myinput1 b on a.key<=>b.value AND a.value<=>b.key join myinput1 c on 
a.key<=>c.key AND a.value<=>c.value
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -470,6 +711,9 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Map Join Operator
                     condition map:
                          Inner Join 0 to 1
@@ -478,6 +722,11 @@ STAGE PLANS:
                       0 key (type: int), value (type: int)
                       1 value (type: int), key (type: int)
                       2 key (type: int), value (type: int)
+                    Map Join Vectorization:
+                        className: VectorMapJoinOperator
+                        native: false
+                        nativeConditionsMet: hive.execution.engine tez IN 
[tez, spark] IS true, Supports Key Types IS true, Not empty key IS true, When 
Fast Hash Table, then requires no Hybrid Hash Join IS true, Small table 
vectorizes IS true
+                        nativeConditionsNotMet: 
hive.vectorized.execution.mapjoin.native.enabled IS false, One MapJoin 
Condition IS false, No nullsafe IS false
                     nullSafes: [true, true]
                     outputColumnNames: _col0, _col1, _col5, _col6, _col10, 
_col11
                     input vertices:
@@ -487,9 +736,16 @@ STAGE PLANS:
                     Select Operator
                       expressions: _col0 (type: int), _col1 (type: int), _col5 
(type: int), _col6 (type: int), _col10 (type: int), _col11 (type: int)
                       outputColumnNames: _col0, _col1, _col2, _col3, _col4, 
_col5
+                      Select Vectorization:
+                          className: VectorSelectOperator
+                          native: true
+                          projectedOutputColumns: [0, 1, 2, 3, 4, 5]
                       Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                       File Output Operator
                         compressed: false
+                        File Sink Vectorization:
+                            className: VectorFileSinkOperator
+                            native: false
                         Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                         table:
                             input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -497,30 +753,68 @@ STAGE PLANS:
                             serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: value (type: int), key (type: int)
                     sort order: ++
                     Map-reduce partition columns: value (type: int), key 
(type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkMultiKeyOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 3 
             Map Operator Tree:
                 TableScan
                   alias: c
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: key (type: int), value (type: int)
                     sort order: ++
                     Map-reduce partition columns: key (type: int), value 
(type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkMultiKeyOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator
@@ -644,11 +938,15 @@ NULL      NULL    10      NULL
 NULL   NULL    48      NULL
 NULL   NULL    NULL    NULL
 PREHOOK: query: -- merging
-explain select * from myinput1 a join myinput1 b on a.key<=>b.value
+explain vectorization expression select * from myinput1 a join myinput1 b on 
a.key<=>b.value
 PREHOOK: type: QUERY
 POSTHOOK: query: -- merging
-explain select * from myinput1 a join myinput1 b on a.key<=>b.value
+explain vectorization expression select * from myinput1 a join myinput1 b on 
a.key<=>b.value
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -666,12 +964,20 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Map Join Operator
                     condition map:
                          Inner Join 0 to 1
                     keys:
                       0 key (type: int)
                       1 value (type: int)
+                    Map Join Vectorization:
+                        className: VectorMapJoinOperator
+                        native: false
+                        nativeConditionsMet: 
hive.vectorized.execution.mapjoin.native.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, One MapJoin Condition IS true, Supports Key Types 
IS true, Not empty key IS true, When Fast Hash Table, then requires no Hybrid 
Hash Join IS true, Small table vectorizes IS true
+                        nativeConditionsNotMet: No nullsafe IS false
                     nullSafes: [true]
                     outputColumnNames: _col0, _col1, _col5, _col6
                     input vertices:
@@ -680,9 +986,16 @@ STAGE PLANS:
                     Select Operator
                       expressions: _col0 (type: int), _col1 (type: int), _col5 
(type: int), _col6 (type: int)
                       outputColumnNames: _col0, _col1, _col2, _col3
+                      Select Vectorization:
+                          className: VectorSelectOperator
+                          native: true
+                          projectedOutputColumns: [0, 1, 2, 3]
                       Statistics: Num rows: 6 Data size: 26 Basic stats: 
COMPLETE Column stats: NONE
                       File Output Operator
                         compressed: false
+                        File Sink Vectorization:
+                            className: VectorFileSinkOperator
+                            native: false
                         Statistics: Num rows: 6 Data size: 26 Basic stats: 
COMPLETE Column stats: NONE
                         table:
                             input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -690,19 +1003,42 @@ STAGE PLANS:
                             serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: value (type: int)
                     sort order: +
                     Map-reduce partition columns: value (type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkLongOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     value expressions: key (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator
@@ -729,10 +1065,14 @@ NULL     35      NULL    NULL
 NULL   NULL    10      NULL
 NULL   NULL    48      NULL
 NULL   NULL    NULL    NULL
-PREHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value join myinput1 c on a.key=c.key
+PREHOOK: query: explain vectorization expression select * from myinput1 a join 
myinput1 b on a.key<=>b.value join myinput1 c on a.key=c.key
 PREHOOK: type: QUERY
-POSTHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value join myinput1 c on a.key=c.key
+POSTHOOK: query: explain vectorization expression select * from myinput1 a 
join myinput1 b on a.key<=>b.value join myinput1 c on a.key=c.key
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -750,7 +1090,14 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 0) -> 
boolean
                     predicate: key is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Map Join Operator
@@ -761,6 +1108,11 @@ STAGE PLANS:
                         0 key (type: int)
                         1 value (type: int)
                         2 key (type: int)
+                      Map Join Vectorization:
+                          className: VectorMapJoinOperator
+                          native: false
+                          nativeConditionsMet: 
hive.vectorized.execution.mapjoin.native.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, No nullsafe IS true, Supports Key Types IS true, 
Not empty key IS true, When Fast Hash Table, then requires no Hybrid Hash Join 
IS true, Small table vectorizes IS true
+                          nativeConditionsNotMet: One MapJoin Condition IS 
false
                       outputColumnNames: _col0, _col1, _col5, _col6, _col10, 
_col11
                       input vertices:
                         1 Map 2
@@ -769,9 +1121,16 @@ STAGE PLANS:
                       Select Operator
                         expressions: _col0 (type: int), _col1 (type: int), 
_col5 (type: int), _col6 (type: int), _col10 (type: int), _col11 (type: int)
                         outputColumnNames: _col0, _col1, _col2, _col3, _col4, 
_col5
+                        Select Vectorization:
+                            className: VectorSelectOperator
+                            native: true
+                            projectedOutputColumns: [0, 1, 2, 3, 4, 5]
                         Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                         File Output Operator
                           compressed: false
+                          File Sink Vectorization:
+                              className: VectorFileSinkOperator
+                              native: false
                           Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                           table:
                               input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -779,38 +1138,84 @@ STAGE PLANS:
                               serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 1) -> 
boolean
                     predicate: value is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: value (type: int)
                       sort order: +
                       Map-reduce partition columns: value (type: int)
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkLongOperator
+                          native: true
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                       Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                       value expressions: key (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 3 
             Map Operator Tree:
                 TableScan
                   alias: c
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 0) -> 
boolean
                     predicate: key is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: key (type: int)
                       sort order: +
                       Map-reduce partition columns: key (type: int)
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkLongOperator
+                          native: true
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                       Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                       value expressions: value (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator
@@ -828,10 +1233,14 @@ POSTHOOK: Input: default@myinput1
 #### A masked pattern was here ####
 10     NULL    NULL    10      10      NULL
 100    100     100     100     100     100
-PREHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value join myinput1 c on a.key<=>c.key
+PREHOOK: query: explain vectorization expression select * from myinput1 a join 
myinput1 b on a.key<=>b.value join myinput1 c on a.key<=>c.key
 PREHOOK: type: QUERY
-POSTHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value join myinput1 c on a.key<=>c.key
+POSTHOOK: query: explain vectorization expression select * from myinput1 a 
join myinput1 b on a.key<=>b.value join myinput1 c on a.key<=>c.key
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -849,6 +1258,9 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Map Join Operator
                     condition map:
                          Inner Join 0 to 1
@@ -857,6 +1269,11 @@ STAGE PLANS:
                       0 key (type: int)
                       1 value (type: int)
                       2 key (type: int)
+                    Map Join Vectorization:
+                        className: VectorMapJoinOperator
+                        native: false
+                        nativeConditionsMet: 
hive.vectorized.execution.mapjoin.native.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Supports Key Types IS true, Not empty key IS true, 
When Fast Hash Table, then requires no Hybrid Hash Join IS true, Small table 
vectorizes IS true
+                        nativeConditionsNotMet: One MapJoin Condition IS 
false, No nullsafe IS false
                     nullSafes: [true]
                     outputColumnNames: _col0, _col1, _col5, _col6, _col10, 
_col11
                     input vertices:
@@ -866,9 +1283,16 @@ STAGE PLANS:
                     Select Operator
                       expressions: _col0 (type: int), _col1 (type: int), _col5 
(type: int), _col6 (type: int), _col10 (type: int), _col11 (type: int)
                       outputColumnNames: _col0, _col1, _col2, _col3, _col4, 
_col5
+                      Select Vectorization:
+                          className: VectorSelectOperator
+                          native: true
+                          projectedOutputColumns: [0, 1, 2, 3, 4, 5]
                       Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                       File Output Operator
                         compressed: false
+                        File Sink Vectorization:
+                            className: VectorFileSinkOperator
+                            native: false
                         Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                         table:
                             input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -876,32 +1300,70 @@ STAGE PLANS:
                             serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: value (type: int)
                     sort order: +
                     Map-reduce partition columns: value (type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkLongOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     value expressions: key (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 3 
             Map Operator Tree:
                 TableScan
                   alias: c
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: key (type: int)
                     sort order: +
                     Map-reduce partition columns: key (type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkLongOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     value expressions: value (type: int)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator
@@ -946,10 +1408,14 @@ NULL     NULL    48      NULL    NULL    NULL
 NULL   NULL    NULL    NULL    NULL    10
 NULL   NULL    NULL    NULL    NULL    35
 NULL   NULL    NULL    NULL    NULL    NULL
-PREHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value AND a.value=b.key join myinput1 c on a.key<=>c.key AND 
a.value=c.value
+PREHOOK: query: explain vectorization expression select * from myinput1 a join 
myinput1 b on a.key<=>b.value AND a.value=b.key join myinput1 c on 
a.key<=>c.key AND a.value=c.value
 PREHOOK: type: QUERY
-POSTHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value AND a.value=b.key join myinput1 c on a.key<=>c.key AND 
a.value=c.value
+POSTHOOK: query: explain vectorization expression select * from myinput1 a 
join myinput1 b on a.key<=>b.value AND a.value=b.key join myinput1 c on 
a.key<=>c.key AND a.value=c.value
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -967,7 +1433,14 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 1) -> 
boolean
                     predicate: value is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Map Join Operator
@@ -978,6 +1451,11 @@ STAGE PLANS:
                         0 key (type: int), value (type: int)
                         1 value (type: int), key (type: int)
                         2 key (type: int), value (type: int)
+                      Map Join Vectorization:
+                          className: VectorMapJoinOperator
+                          native: false
+                          nativeConditionsMet: 
hive.vectorized.execution.mapjoin.native.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Supports Key Types IS true, Not empty key IS true, 
When Fast Hash Table, then requires no Hybrid Hash Join IS true, Small table 
vectorizes IS true
+                          nativeConditionsNotMet: One MapJoin Condition IS 
false, No nullsafe IS false
                       nullSafes: [true, false]
                       outputColumnNames: _col0, _col1, _col5, _col6, _col10, 
_col11
                       input vertices:
@@ -987,9 +1465,16 @@ STAGE PLANS:
                       Select Operator
                         expressions: _col0 (type: int), _col1 (type: int), 
_col5 (type: int), _col6 (type: int), _col10 (type: int), _col11 (type: int)
                         outputColumnNames: _col0, _col1, _col2, _col3, _col4, 
_col5
+                        Select Vectorization:
+                            className: VectorSelectOperator
+                            native: true
+                            projectedOutputColumns: [0, 1, 2, 3, 4, 5]
                         Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                         File Output Operator
                           compressed: false
+                          File Sink Vectorization:
+                              className: VectorFileSinkOperator
+                              native: false
                           Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                           table:
                               input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -997,36 +1482,82 @@ STAGE PLANS:
                               serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 0) -> 
boolean
                     predicate: key is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: value (type: int), key (type: int)
                       sort order: ++
                       Map-reduce partition columns: value (type: int), key 
(type: int)
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkMultiKeyOperator
+                          native: true
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                       Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 3 
             Map Operator Tree:
                 TableScan
                   alias: c
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Filter Operator
+                    Filter Vectorization:
+                        className: VectorFilterOperator
+                        native: true
+                        predicateExpression: SelectColumnIsNotNull(col 1) -> 
boolean
                     predicate: value is not null (type: boolean)
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: key (type: int), value (type: int)
                       sort order: ++
                       Map-reduce partition columns: key (type: int), value 
(type: int)
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkMultiKeyOperator
+                          native: true
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                       Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator
@@ -1044,10 +1575,14 @@ POSTHOOK: Input: default@myinput1
 #### A masked pattern was here ####
 100    100     100     100     100     100
 NULL   10      10      NULL    NULL    10
-PREHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value AND a.value<=>b.key join myinput1 c on a.key<=>c.key AND 
a.value<=>c.value
+PREHOOK: query: explain vectorization expression select * from myinput1 a join 
myinput1 b on a.key<=>b.value AND a.value<=>b.key join myinput1 c on 
a.key<=>c.key AND a.value<=>c.value
 PREHOOK: type: QUERY
-POSTHOOK: query: explain select * from myinput1 a join myinput1 b on 
a.key<=>b.value AND a.value<=>b.key join myinput1 c on a.key<=>c.key AND 
a.value<=>c.value
+POSTHOOK: query: explain vectorization expression select * from myinput1 a 
join myinput1 b on a.key<=>b.value AND a.value<=>b.key join myinput1 c on 
a.key<=>c.key AND a.value<=>c.value
 POSTHOOK: type: QUERY
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -1065,6 +1600,9 @@ STAGE PLANS:
                 TableScan
                   alias: a
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Map Join Operator
                     condition map:
                          Inner Join 0 to 1
@@ -1073,6 +1611,11 @@ STAGE PLANS:
                       0 key (type: int), value (type: int)
                       1 value (type: int), key (type: int)
                       2 key (type: int), value (type: int)
+                    Map Join Vectorization:
+                        className: VectorMapJoinOperator
+                        native: false
+                        nativeConditionsMet: 
hive.vectorized.execution.mapjoin.native.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Supports Key Types IS true, Not empty key IS true, 
When Fast Hash Table, then requires no Hybrid Hash Join IS true, Small table 
vectorizes IS true
+                        nativeConditionsNotMet: One MapJoin Condition IS 
false, No nullsafe IS false
                     nullSafes: [true, true]
                     outputColumnNames: _col0, _col1, _col5, _col6, _col10, 
_col11
                     input vertices:
@@ -1082,9 +1625,16 @@ STAGE PLANS:
                     Select Operator
                       expressions: _col0 (type: int), _col1 (type: int), _col5 
(type: int), _col6 (type: int), _col10 (type: int), _col11 (type: int)
                       outputColumnNames: _col0, _col1, _col2, _col3, _col4, 
_col5
+                      Select Vectorization:
+                          className: VectorSelectOperator
+                          native: true
+                          projectedOutputColumns: [0, 1, 2, 3, 4, 5]
                       Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                       File Output Operator
                         compressed: false
+                        File Sink Vectorization:
+                            className: VectorFileSinkOperator
+                            native: false
                         Statistics: Num rows: 13 Data size: 52 Basic stats: 
COMPLETE Column stats: NONE
                         table:
                             input format: 
org.apache.hadoop.mapred.SequenceFileInputFormat
@@ -1092,30 +1642,68 @@ STAGE PLANS:
                             serde: 
org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 2 
             Map Operator Tree:
                 TableScan
                   alias: b
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: value (type: int), key (type: int)
                     sort order: ++
                     Map-reduce partition columns: value (type: int), key 
(type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkMultiKeyOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Map 3 
             Map Operator Tree:
                 TableScan
                   alias: c
                   Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE 
Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1]
                   Reduce Output Operator
                     key expressions: key (type: int), value (type: int)
                     sort order: ++
                     Map-reduce partition columns: key (type: int), value 
(type: int)
+                    Reduce Sink Vectorization:
+                        className: VectorReduceSinkMultiKeyOperator
+                        native: true
+                        nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, Uniform Hash IS true, No DISTINCT columns IS true, 
BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                     Statistics: Num rows: 6 Data size: 24 Basic stats: 
COMPLETE Column stats: NONE
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: true
+                usesVectorUDFAdaptor: false
+                vectorized: true
 
   Stage: Stage-0
     Fetch Operator

http://git-wip-us.apache.org/repos/asf/hive/blob/16d28b34/ql/src/test/results/clientpositive/llap/vector_number_compare_projection.q.out
----------------------------------------------------------------------
diff --git 
a/ql/src/test/results/clientpositive/llap/vector_number_compare_projection.q.out
 
b/ql/src/test/results/clientpositive/llap/vector_number_compare_projection.q.out
index 6479ec5..c4bbeff 100644
--- 
a/ql/src/test/results/clientpositive/llap/vector_number_compare_projection.q.out
+++ 
b/ql/src/test/results/clientpositive/llap/vector_number_compare_projection.q.out
@@ -103,7 +103,7 @@ scratch.t   scratch.si      scratch.i       scratch.b       
scratch.f       scratch.d       scratch.dc
 PREHOOK: query: --
 -- Projection LongCol<Compare>LongScalar
 --
-EXPLAIN
+EXPLAIN VECTORIZATION EXPRESSION
 SELECT sum(hash(*)) FROM
     (SELECT t, si, i, (t < 0) as compare1, (si <= 0) as compare2, (i = 0) as 
compare3 from vectortab2k_orc
         order by t, si, i) as q
@@ -111,12 +111,16 @@ PREHOOK: type: QUERY
 POSTHOOK: query: --
 -- Projection LongCol<Compare>LongScalar
 --
-EXPLAIN
+EXPLAIN VECTORIZATION EXPRESSION
 SELECT sum(hash(*)) FROM
     (SELECT t, si, i, (t < 0) as compare1, (si <= 0) as compare2, (i = 0) as 
compare3 from vectortab2k_orc
         order by t, si, i) as q
 POSTHOOK: type: QUERY
 Explain
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -134,19 +138,45 @@ STAGE PLANS:
                 TableScan
                   alias: vectortab2k_orc
                   Statistics: Num rows: 2001 Data size: 273608 Basic stats: 
COMPLETE Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6]
                   Select Operator
                     expressions: t (type: tinyint), si (type: smallint), i 
(type: int), (t < 0) (type: boolean), (si <= 0) (type: boolean), (i = 0) (type: 
boolean)
                     outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                    Select Vectorization:
+                        className: VectorSelectOperator
+                        native: true
+                        projectedOutputColumns: [0, 1, 2, 7, 8, 9]
+                        selectExpressions: LongColLessLongScalar(col 0, val 0) 
-> 7:long, LongColLessEqualLongScalar(col 1, val 0) -> 8:long, 
LongColEqualLongScalar(col 2, val 0) -> 9:long
                     Statistics: Num rows: 2001 Data size: 273608 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: _col0 (type: tinyint), _col1 (type: 
smallint), _col2 (type: int)
                       sort order: +++
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkOperator
+                          native: false
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for 
keys IS true, LazyBinarySerDe for values IS true
+                          nativeConditionsNotMet: Uniform Hash IS false
                       Statistics: Num rows: 2001 Data size: 273608 Basic 
stats: COMPLETE Column stats: NONE
                       value expressions: _col3 (type: boolean), _col4 (type: 
boolean), _col5 (type: boolean)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Reducer 2 
             Execution mode: llap
+            Reduce Vectorization:
+                enabled: true
+                enableConditionsMet: hive.vectorized.execution.reduce.enabled 
IS true, hive.execution.engine tez IN [tez, spark] IS true
+                notVectorizedReason: Select expression for SELECT operator: 
UDF GenericUDFHash(Column[KEY.reducesinkkey0], Column[KEY.reducesinkkey1], 
Column[KEY.reducesinkkey2], Column[VALUE._col0], Column[VALUE._col1], 
Column[VALUE._col2]) not supported
+                vectorized: false
             Reduce Operator Tree:
               Select Operator
                 expressions: 
hash(KEY.reducesinkkey0,KEY.reducesinkkey1,KEY.reducesinkkey2,VALUE._col0,VALUE._col1,VALUE._col2)
 (type: int)
@@ -185,17 +215,21 @@ POSTHOOK: Input: default@vectortab2k_orc
 #### A masked pattern was here ####
 c0
 -3601806268
-PREHOOK: query: EXPLAIN
+PREHOOK: query: EXPLAIN VECTORIZATION EXPRESSION
 SELECT sum(hash(*)) FROM
     (SELECT t, si, i, b, (t > 0) as compare1, (si >= 0) as compare2, (i != 0) 
as compare3, (b > 0) as compare4 from vectortab2k_orc
         order by t, si, i, b) as q
 PREHOOK: type: QUERY
-POSTHOOK: query: EXPLAIN
+POSTHOOK: query: EXPLAIN VECTORIZATION EXPRESSION
 SELECT sum(hash(*)) FROM
     (SELECT t, si, i, b, (t > 0) as compare1, (si >= 0) as compare2, (i != 0) 
as compare3, (b > 0) as compare4 from vectortab2k_orc
         order by t, si, i, b) as q
 POSTHOOK: type: QUERY
 Explain
+PLAN VECTORIZATION:
+  enabled: true
+  enabledConditionsMet: [hive.vectorized.execution.enabled IS true]
+
 STAGE DEPENDENCIES:
   Stage-1 is a root stage
   Stage-0 depends on stages: Stage-1
@@ -213,19 +247,45 @@ STAGE PLANS:
                 TableScan
                   alias: vectortab2k_orc
                   Statistics: Num rows: 2001 Data size: 273608 Basic stats: 
COMPLETE Column stats: NONE
+                  TableScan Vectorization:
+                      native: true
+                      projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6]
                   Select Operator
                     expressions: t (type: tinyint), si (type: smallint), i 
(type: int), b (type: bigint), (t > 0) (type: boolean), (si >= 0) (type: 
boolean), (i <> 0) (type: boolean), (b > 0) (type: boolean)
                     outputColumnNames: _col0, _col1, _col2, _col3, _col4, 
_col5, _col6, _col7
+                    Select Vectorization:
+                        className: VectorSelectOperator
+                        native: true
+                        projectedOutputColumns: [0, 1, 2, 3, 7, 8, 9, 10]
+                        selectExpressions: LongColGreaterLongScalar(col 0, val 
0) -> 7:long, LongColGreaterEqualLongScalar(col 1, val 0) -> 8:long, 
LongColNotEqualLongScalar(col 2, val 0) -> 9:long, LongColGreaterLongScalar(col 
3, val 0) -> 10:long
                     Statistics: Num rows: 2001 Data size: 273608 Basic stats: 
COMPLETE Column stats: NONE
                     Reduce Output Operator
                       key expressions: _col0 (type: tinyint), _col1 (type: 
smallint), _col2 (type: int), _col3 (type: bigint)
                       sort order: ++++
+                      Reduce Sink Vectorization:
+                          className: VectorReduceSinkOperator
+                          native: false
+                          nativeConditionsMet: 
hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine 
tez IN [tez, spark] IS true, Not ACID UPDATE or DELETE IS true, No buckets IS 
true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for 
keys IS true, LazyBinarySerDe for values IS true
+                          nativeConditionsNotMet: Uniform Hash IS false
                       Statistics: Num rows: 2001 Data size: 273608 Basic 
stats: COMPLETE Column stats: NONE
                       value expressions: _col4 (type: boolean), _col5 (type: 
boolean), _col6 (type: boolean), _col7 (type: boolean)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
+            Map Vectorization:
+                enabled: true
+                enabledConditionsMet: 
hive.vectorized.use.vectorized.input.format IS true
+                groupByVectorOutput: true
+                inputFileFormats: 
org.apache.hadoop.hive.ql.io.orc.OrcInputFormat
+                allNative: false
+                usesVectorUDFAdaptor: false
+                vectorized: true
         Reducer 2 
             Execution mode: llap
+            Reduce Vectorization:
+                enabled: true
+                enableConditionsMet: hive.vectorized.execution.reduce.enabled 
IS true, hive.execution.engine tez IN [tez, spark] IS true
+                notVectorizedReason: Select expression for SELECT operator: 
UDF GenericUDFHash(Column[KEY.reducesinkkey0], Column[KEY.reducesinkkey1], 
Column[KEY.reducesinkkey2], Column[KEY.reducesinkkey3], Column[VALUE._col0], 
Column[VALUE._col1], Column[VALUE._col2], Column[VALUE._col3]) not supported
+                vectorized: false
             Reduce Operator Tree:
               Select Operator
                 expressions: 
hash(KEY.reducesinkkey0,KEY.reducesinkkey1,KEY.reducesinkkey2,KEY.reducesinkkey3,VALUE._col0,VALUE._col1,VALUE._col2,VALUE._col3)
 (type: int)

Reply via email to