You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by jv...@apache.org on 2011/07/13 18:49:42 UTC

svn commit: r1146129 [4/41] - in /hive/trunk: common/src/java/org/apache/hadoop/hive/conf/ contrib/src/test/results/clientpositive/ hbase-handler/src/test/results/ ql/src/java/org/apache/hadoop/hive/ql/exec/ ql/src/java/org/apache/hadoop/hive/ql/ppd/ q...

Modified: hive/trunk/ql/src/test/results/clientpositive/auto_join29.q.out
URL: http://svn.apache.org/viewvc/hive/trunk/ql/src/test/results/clientpositive/auto_join29.q.out?rev=1146129&r1=1146128&r2=1146129&view=diff
==============================================================================
--- hive/trunk/ql/src/test/results/clientpositive/auto_join29.q.out (original)
+++ hive/trunk/ql/src/test/results/clientpositive/auto_join29.q.out Wed Jul 13 16:49:22 2011
@@ -54,25 +54,21 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 {(key < 10)}
-                    1 
-                    2 {(key < 10)}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 2
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 {(key < 10)}
+                  1 
+                  2 {(key < 10)}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 2
 
   Stage: Stage-5
     Map Reduce
@@ -192,24 +188,20 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 1
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 1
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src3 
           TableScan
             alias: src3
@@ -2921,25 +2913,21 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 {(key < 10)}
-                    1 
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 0
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 {(key < 10)}
+                  1 
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 0
         src3 
           TableScan
             alias: src3
@@ -2947,25 +2935,21 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 {(key < 10)}
-                    1 
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 0
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 {(key < 10)}
+                  1 
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 0
 
   Stage: Stage-5
     Map Reduce
@@ -3085,24 +3069,20 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 1
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 1
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src3 
           TableScan
             alias: src3
@@ -3110,24 +3090,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 2
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 2
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
       Reduce Operator Tree:
         Join Operator
           condition map:
@@ -4244,25 +4220,21 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 
-                    1 {(key > 10)}
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 1
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 
+                  1 {(key > 10)}
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 1
         src3 
           TableScan
             alias: src3
@@ -4270,25 +4242,21 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 
-                    1 {(key > 10)}
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 1
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 
+                  1 {(key > 10)}
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 1
 
   Stage: Stage-5
     Map Reduce
@@ -4391,24 +4359,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 0
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 0
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src2 
           TableScan
             alias: src2
@@ -4433,24 +4397,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 2
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 2
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
       Reduce Operator Tree:
         Join Operator
           condition map:
@@ -5087,25 +5047,21 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 
-                    1 {(key > 10)}
-                    2 {(key < 10)}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 2
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 
+                  1 {(key > 10)}
+                  2 {(key < 10)}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 2
         src2 
           TableScan
             alias: src2
@@ -5226,24 +5182,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 0
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 0
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src2 
           TableScan
             alias: src2
@@ -6432,21 +6384,17 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 0
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 0
         src3 
           TableScan
             alias: src3
@@ -6454,21 +6402,17 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 0
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 0
 
   Stage: Stage-5
     Map Reduce
@@ -6480,46 +6424,42 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Map Join Operator
-                  condition map:
-                       Inner Join 0 to 1
-                       Left Outer Join1 to 2
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
-                  Position of Big Table: 0
-                  Select Operator
-                    expressions:
-                          expr: _col0
-                          type: string
-                          expr: _col1
-                          type: string
-                          expr: _col4
-                          type: string
-                          expr: _col5
-                          type: string
-                          expr: _col8
-                          type: string
-                          expr: _col9
-                          type: string
-                    outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
-                    File Output Operator
-                      compressed: false
-                      GlobalTableId: 0
-                      table:
-                          input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                          output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+              Map Join Operator
+                condition map:
+                     Inner Join 0 to 1
+                     Left Outer Join1 to 2
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
+                Position of Big Table: 0
+                Select Operator
+                  expressions:
+                        expr: _col0
+                        type: string
+                        expr: _col1
+                        type: string
+                        expr: _col4
+                        type: string
+                        expr: _col5
+                        type: string
+                        expr: _col8
+                        type: string
+                        expr: _col9
+                        type: string
+                  outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                  File Output Operator
+                    compressed: false
+                    GlobalTableId: 0
+                    table:
+                        input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                        output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
       Local Work:
         Map Reduce Local Work
 
@@ -6582,21 +6522,17 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 1
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 1
         src3 
           TableScan
             alias: src3
@@ -6604,21 +6540,17 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 1
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 1
 
   Stage: Stage-6
     Map Reduce
@@ -6630,46 +6562,42 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                Map Join Operator
-                  condition map:
-                       Inner Join 0 to 1
-                       Left Outer Join1 to 2
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
-                  Position of Big Table: 1
-                  Select Operator
-                    expressions:
-                          expr: _col0
-                          type: string
-                          expr: _col1
-                          type: string
-                          expr: _col4
-                          type: string
-                          expr: _col5
-                          type: string
-                          expr: _col8
-                          type: string
-                          expr: _col9
-                          type: string
-                    outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
-                    File Output Operator
-                      compressed: false
-                      GlobalTableId: 0
-                      table:
-                          input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                          output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+              Map Join Operator
+                condition map:
+                     Inner Join 0 to 1
+                     Left Outer Join1 to 2
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
+                Position of Big Table: 1
+                Select Operator
+                  expressions:
+                        expr: _col0
+                        type: string
+                        expr: _col1
+                        type: string
+                        expr: _col4
+                        type: string
+                        expr: _col5
+                        type: string
+                        expr: _col8
+                        type: string
+                        expr: _col9
+                        type: string
+                  outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                  File Output Operator
+                    compressed: false
+                    GlobalTableId: 0
+                    table:
+                        input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                        output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
       Local Work:
         Map Reduce Local Work
 
@@ -6683,24 +6611,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 0
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 0
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src2 
           TableScan
             alias: src2
@@ -6708,24 +6632,20 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 1
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 1
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src3 
           TableScan
             alias: src3
@@ -6733,24 +6653,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 2
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 2
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
       Reduce Operator Tree:
         Join Operator
           condition map:
@@ -6835,25 +6751,21 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 
-                    1 
-                    2 {(key < 10)}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 2
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 
+                  1 
+                  2 {(key < 10)}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 2
         src2 
           TableScan
             alias: src2
@@ -6861,25 +6773,21 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 
-                    1 
-                    2 {(key < 10)}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 2
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 
+                  1 
+                  2 {(key < 10)}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 2
 
   Stage: Stage-5
     Map Reduce
@@ -6982,24 +6890,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 0
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 0
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src2 
           TableScan
             alias: src2
@@ -7007,24 +6911,20 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 1
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 1
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src3 
           TableScan
             alias: src3
@@ -7630,25 +7530,21 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 {(key < 10)}
-                    1 
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 0
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 {(key < 10)}
+                  1 
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 0
         src3 
           TableScan
             alias: src3
@@ -7656,25 +7552,21 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 {(key < 10)}
-                    1 
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 0
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 {(key < 10)}
+                  1 
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 0
 
   Stage: Stage-5
     Map Reduce
@@ -7794,24 +7686,20 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 1
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 1
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src3 
           TableScan
             alias: src3
@@ -7819,24 +7707,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 2
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 2
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
       Reduce Operator Tree:
         Join Operator
           condition map:
@@ -7927,25 +7811,21 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 
-                    1 {(key > 10)}
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 1
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 
+                  1 {(key > 10)}
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 1
         src3 
           TableScan
             alias: src3
@@ -7953,25 +7833,21 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 
-                    1 {(key > 10)}
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 1
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 
+                  1 {(key > 10)}
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 1
 
   Stage: Stage-5
     Map Reduce
@@ -8081,25 +7957,21 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 
-                    1 {(key > 10)}
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 2
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 
+                  1 {(key > 10)}
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 2
         src2 
           TableScan
             alias: src2
@@ -8129,50 +8001,46 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Map Join Operator
-                  condition map:
-                       Right Outer Join0 to 1
-                       Inner Join 1 to 2
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  filter predicates:
-                    0 
-                    1 {(key > 10)}
-                    2 
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
-                  Position of Big Table: 2
-                  Select Operator
-                    expressions:
-                          expr: _col0
-                          type: string
-                          expr: _col1
-                          type: string
-                          expr: _col4
-                          type: string
-                          expr: _col5
-                          type: string
-                          expr: _col8
-                          type: string
-                          expr: _col9
-                          type: string
-                    outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
-                    File Output Operator
-                      compressed: false
-                      GlobalTableId: 0
-                      table:
-                          input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                          output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+              Map Join Operator
+                condition map:
+                     Right Outer Join0 to 1
+                     Inner Join 1 to 2
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                filter predicates:
+                  0 
+                  1 {(key > 10)}
+                  2 
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
+                Position of Big Table: 2
+                Select Operator
+                  expressions:
+                        expr: _col0
+                        type: string
+                        expr: _col1
+                        type: string
+                        expr: _col4
+                        type: string
+                        expr: _col5
+                        type: string
+                        expr: _col8
+                        type: string
+                        expr: _col9
+                        type: string
+                  outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                  File Output Operator
+                    compressed: false
+                    GlobalTableId: 0
+                    table:
+                        input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                        output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
       Local Work:
         Map Reduce Local Work
 
@@ -8186,24 +8054,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 0
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 0
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src2 
           TableScan
             alias: src2
@@ -8228,24 +8092,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 2
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 2
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
       Reduce Operator Tree:
         Join Operator
           condition map:
@@ -8396,21 +8256,17 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 0
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 0
         src3 
           TableScan
             alias: src3
@@ -8418,21 +8274,17 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 0
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 0
 
   Stage: Stage-5
     Map Reduce
@@ -8444,46 +8296,42 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Map Join Operator
-                  condition map:
-                       Inner Join 0 to 1
-                       Inner Join 1 to 2
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
-                  Position of Big Table: 0
-                  Select Operator
-                    expressions:
-                          expr: _col0
-                          type: string
-                          expr: _col1
-                          type: string
-                          expr: _col4
-                          type: string
-                          expr: _col5
-                          type: string
-                          expr: _col8
-                          type: string
-                          expr: _col9
-                          type: string
-                    outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
-                    File Output Operator
-                      compressed: false
-                      GlobalTableId: 0
-                      table:
-                          input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                          output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+              Map Join Operator
+                condition map:
+                     Inner Join 0 to 1
+                     Inner Join 1 to 2
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
+                Position of Big Table: 0
+                Select Operator
+                  expressions:
+                        expr: _col0
+                        type: string
+                        expr: _col1
+                        type: string
+                        expr: _col4
+                        type: string
+                        expr: _col5
+                        type: string
+                        expr: _col8
+                        type: string
+                        expr: _col9
+                        type: string
+                  outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                  File Output Operator
+                    compressed: false
+                    GlobalTableId: 0
+                    table:
+                        input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                        output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
       Local Work:
         Map Reduce Local Work
 
@@ -8546,21 +8394,17 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 1
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 1
         src3 
           TableScan
             alias: src3
@@ -8568,21 +8412,17 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 1
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 1
 
   Stage: Stage-6
     Map Reduce
@@ -8594,46 +8434,42 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                Map Join Operator
-                  condition map:
-                       Inner Join 0 to 1
-                       Inner Join 1 to 2
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
-                  Position of Big Table: 1
-                  Select Operator
-                    expressions:
-                          expr: _col0
-                          type: string
-                          expr: _col1
-                          type: string
-                          expr: _col4
-                          type: string
-                          expr: _col5
-                          type: string
-                          expr: _col8
-                          type: string
-                          expr: _col9
-                          type: string
-                    outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
-                    File Output Operator
-                      compressed: false
-                      GlobalTableId: 0
-                      table:
-                          input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                          output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+              Map Join Operator
+                condition map:
+                     Inner Join 0 to 1
+                     Inner Join 1 to 2
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
+                Position of Big Table: 1
+                Select Operator
+                  expressions:
+                        expr: _col0
+                        type: string
+                        expr: _col1
+                        type: string
+                        expr: _col4
+                        type: string
+                        expr: _col5
+                        type: string
+                        expr: _col8
+                        type: string
+                        expr: _col9
+                        type: string
+                  outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                  File Output Operator
+                    compressed: false
+                    GlobalTableId: 0
+                    table:
+                        input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                        output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
       Local Work:
         Map Reduce Local Work
 
@@ -8654,21 +8490,17 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 2
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 2
         src2 
           TableScan
             alias: src2
@@ -8676,21 +8508,17 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                HashTable Sink Operator
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  Position of Big Table: 2
+              HashTable Sink Operator
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                Position of Big Table: 2
 
   Stage: Stage-7
     Map Reduce
@@ -8702,46 +8530,42 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Map Join Operator
-                  condition map:
-                       Inner Join 0 to 1
-                       Inner Join 1 to 2
-                  condition expressions:
-                    0 {key} {value}
-                    1 {key} {value}
-                    2 {key} {value}
-                  handleSkewJoin: false
-                  keys:
-                    0 [Column[key]]
-                    1 [Column[key]]
-                    2 [Column[key]]
-                  outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
-                  Position of Big Table: 2
-                  Select Operator
-                    expressions:
-                          expr: _col0
-                          type: string
-                          expr: _col1
-                          type: string
-                          expr: _col4
-                          type: string
-                          expr: _col5
-                          type: string
-                          expr: _col8
-                          type: string
-                          expr: _col9
-                          type: string
-                    outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
-                    File Output Operator
-                      compressed: false
-                      GlobalTableId: 0
-                      table:
-                          input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                          output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+              Map Join Operator
+                condition map:
+                     Inner Join 0 to 1
+                     Inner Join 1 to 2
+                condition expressions:
+                  0 {key} {value}
+                  1 {key} {value}
+                  2 {key} {value}
+                handleSkewJoin: false
+                keys:
+                  0 [Column[key]]
+                  1 [Column[key]]
+                  2 [Column[key]]
+                outputColumnNames: _col0, _col1, _col4, _col5, _col8, _col9
+                Position of Big Table: 2
+                Select Operator
+                  expressions:
+                        expr: _col0
+                        type: string
+                        expr: _col1
+                        type: string
+                        expr: _col4
+                        type: string
+                        expr: _col5
+                        type: string
+                        expr: _col8
+                        type: string
+                        expr: _col9
+                        type: string
+                  outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                  File Output Operator
+                    compressed: false
+                    GlobalTableId: 0
+                    table:
+                        input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                        output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
       Local Work:
         Map Reduce Local Work
 
@@ -8755,24 +8579,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 0
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 0
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src2 
           TableScan
             alias: src2
@@ -8780,24 +8600,20 @@ STAGE PLANS:
               predicate:
                   expr: (key > 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key > 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 1
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 1
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
         src3 
           TableScan
             alias: src3
@@ -8805,24 +8621,20 @@ STAGE PLANS:
               predicate:
                   expr: (key < 10)
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: (key < 10)
-                    type: boolean
-                Reduce Output Operator
-                  key expressions:
-                        expr: key
-                        type: string
-                  sort order: +
-                  Map-reduce partition columns:
-                        expr: key
-                        type: string
-                  tag: 2
-                  value expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
+              Reduce Output Operator
+                key expressions:
+                      expr: key
+                      type: string
+                sort order: +
+                Map-reduce partition columns:
+                      expr: key
+                      type: string
+                tag: 2
+                value expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
       Reduce Operator Tree:
         Join Operator
           condition map:
@@ -8860,6 +8672,7 @@ STAGE PLANS:
     Fetch Operator
       limit: -1
 
+
 PREHOOK: query: SELECT * FROM src src1 JOIN src src2 ON (src1.key = src2.key AND src1.key < 10 AND src2.key > 10) JOIN src src3 ON (src2.key = src3.key AND src3.key < 10) SORT BY src1.key, src1.value, src2.key, src2.value, src3.key, src3.value
 PREHOOK: type: QUERY
 PREHOOK: Input: default@src

Modified: hive/trunk/ql/src/test/results/clientpositive/auto_join4.q.out
URL: http://svn.apache.org/viewvc/hive/trunk/ql/src/test/results/clientpositive/auto_join4.q.out?rev=1146129&r1=1146128&r2=1146129&view=diff
==============================================================================
--- hive/trunk/ql/src/test/results/clientpositive/auto_join4.q.out (original)
+++ hive/trunk/ql/src/test/results/clientpositive/auto_join4.q.out Wed Jul 13 16:49:22 2011
@@ -62,26 +62,22 @@ STAGE PLANS:
               predicate:
                   expr: ((key > 15) and (key < 25))
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: ((key > 15) and (key < 25))
-                    type: boolean
-                Select Operator
-                  expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
-                  outputColumnNames: _col0, _col1
-                  HashTable Sink Operator
-                    condition expressions:
-                      0 {_col0} {_col1}
-                      1 {_col0} {_col1}
-                    handleSkewJoin: false
-                    keys:
-                      0 [Column[_col0]]
-                      1 [Column[_col0]]
-                    Position of Big Table: 0
+              Select Operator
+                expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
+                outputColumnNames: _col0, _col1
+                HashTable Sink Operator
+                  condition expressions:
+                    0 {_col0} {_col1}
+                    1 {_col0} {_col1}
+                  handleSkewJoin: false
+                  keys:
+                    0 [Column[_col0]]
+                    1 [Column[_col0]]
+                  Position of Big Table: 0
 
   Stage: Stage-4
     Map Reduce
@@ -93,29 +89,36 @@ STAGE PLANS:
               predicate:
                   expr: ((key > 10) and (key < 20))
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: ((key > 10) and (key < 20))
-                    type: boolean
-                Select Operator
-                  expressions:
-                        expr: key
-                        type: string
-                        expr: value
-                        type: string
-                  outputColumnNames: _col0, _col1
-                  Map Join Operator
-                    condition map:
-                         Left Outer Join0 to 1
-                    condition expressions:
-                      0 {_col0} {_col1}
-                      1 {_col0} {_col1}
-                    handleSkewJoin: false
-                    keys:
-                      0 [Column[_col0]]
-                      1 [Column[_col0]]
+              Select Operator
+                expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
+                outputColumnNames: _col0, _col1
+                Map Join Operator
+                  condition map:
+                       Left Outer Join0 to 1
+                  condition expressions:
+                    0 {_col0} {_col1}
+                    1 {_col0} {_col1}
+                  handleSkewJoin: false
+                  keys:
+                    0 [Column[_col0]]
+                    1 [Column[_col0]]
+                  outputColumnNames: _col0, _col1, _col2, _col3
+                  Position of Big Table: 0
+                  Select Operator
+                    expressions:
+                          expr: _col0
+                          type: string
+                          expr: _col1
+                          type: string
+                          expr: _col2
+                          type: string
+                          expr: _col3
+                          type: string
                     outputColumnNames: _col0, _col1, _col2, _col3
-                    Position of Big Table: 0
                     Select Operator
                       expressions:
                             expr: _col0
@@ -129,34 +132,23 @@ STAGE PLANS:
                       outputColumnNames: _col0, _col1, _col2, _col3
                       Select Operator
                         expressions:
-                              expr: _col0
-                              type: string
+                              expr: UDFToInteger(_col0)
+                              type: int
                               expr: _col1
                               type: string
-                              expr: _col2
-                              type: string
+                              expr: UDFToInteger(_col2)
+                              type: int
                               expr: _col3
                               type: string
                         outputColumnNames: _col0, _col1, _col2, _col3
-                        Select Operator
-                          expressions:
-                                expr: UDFToInteger(_col0)
-                                type: int
-                                expr: _col1
-                                type: string
-                                expr: UDFToInteger(_col2)
-                                type: int
-                                expr: _col3
-                                type: string
-                          outputColumnNames: _col0, _col1, _col2, _col3
-                          File Output Operator
-                            compressed: false
-                            GlobalTableId: 1
-                            table:
-                                input format: org.apache.hadoop.mapred.TextInputFormat
-                                output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
-                                serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
-                                name: default.dest1
+                        File Output Operator
+                          compressed: false
+                          GlobalTableId: 1
+                          table:
+                              input format: org.apache.hadoop.mapred.TextInputFormat
+                              output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
+                              serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+                              name: default.dest1
       Local Work:
         Map Reduce Local Work
 
@@ -183,31 +175,27 @@ STAGE PLANS:
               predicate:
                   expr: ((key > 10) and (key < 20))
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: ((key > 10) and (key < 20))
-                    type: boolean
-                Select Operator
-                  expressions:
-                        expr: key
+              Select Operator
+                expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
+                outputColumnNames: _col0, _col1
+                Reduce Output Operator
+                  key expressions:
+                        expr: _col0
                         type: string
-                        expr: value
+                  sort order: +
+                  Map-reduce partition columns:
+                        expr: _col0
+                        type: string
+                  tag: 0
+                  value expressions:
+                        expr: _col0
+                        type: string
+                        expr: _col1
                         type: string
-                  outputColumnNames: _col0, _col1
-                  Reduce Output Operator
-                    key expressions:
-                          expr: _col0
-                          type: string
-                    sort order: +
-                    Map-reduce partition columns:
-                          expr: _col0
-                          type: string
-                    tag: 0
-                    value expressions:
-                          expr: _col0
-                          type: string
-                          expr: _col1
-                          type: string
         c:b:src2 
           TableScan
             alias: src2
@@ -215,31 +203,27 @@ STAGE PLANS:
               predicate:
                   expr: ((key > 15) and (key < 25))
                   type: boolean
-              Filter Operator
-                predicate:
-                    expr: ((key > 15) and (key < 25))
-                    type: boolean
-                Select Operator
-                  expressions:
-                        expr: key
+              Select Operator
+                expressions:
+                      expr: key
+                      type: string
+                      expr: value
+                      type: string
+                outputColumnNames: _col0, _col1
+                Reduce Output Operator
+                  key expressions:
+                        expr: _col0
                         type: string
-                        expr: value
+                  sort order: +
+                  Map-reduce partition columns:
+                        expr: _col0
+                        type: string
+                  tag: 1
+                  value expressions:
+                        expr: _col0
+                        type: string
+                        expr: _col1
                         type: string
-                  outputColumnNames: _col0, _col1
-                  Reduce Output Operator
-                    key expressions:
-                          expr: _col0
-                          type: string
-                    sort order: +
-                    Map-reduce partition columns:
-                          expr: _col0
-                          type: string
-                    tag: 1
-                    value expressions:
-                          expr: _col0
-                          type: string
-                          expr: _col1
-                          type: string
       Reduce Operator Tree:
         Join Operator
           condition map: