diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColAddDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColAddDoubleColumn.java index c584fb8..fb4b530 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColAddDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColAddDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] + vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] + vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColAddLongColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColAddLongColumn.java index d22d7cf..137cb20 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColAddLongColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColAddLongColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] + vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] + vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColDivideDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColDivideDoubleColumn.java index 0b3e1fe..e4a82d9 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColDivideDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColDivideDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] / vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] / vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColDivideLongColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColDivideLongColumn.java index 167b997..ca1d57a 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColDivideLongColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColDivideLongColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] / vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] / vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColModuloDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColModuloDoubleColumn.java index 0e0c9ce..d2d97b0 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColModuloDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColModuloDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] % vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] % vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColModuloLongColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColModuloLongColumn.java index be0bdb0..afae230 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColModuloLongColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColModuloLongColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] % vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] % vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColMultiplyDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColMultiplyDoubleColumn.java index aed0408..e249b5f 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColMultiplyDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColMultiplyDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] * vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] * vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColMultiplyLongColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColMultiplyLongColumn.java index 87f7cf5..3d28fed 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColMultiplyLongColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColMultiplyLongColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] * vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] * vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColSubtractDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColSubtractDoubleColumn.java index 15abdbd..be6ed51 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColSubtractDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColSubtractDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] - vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] - vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColSubtractLongColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColSubtractLongColumn.java index f666e19..3772769 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColSubtractLongColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/DoubleColSubtractLongColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] - vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] - vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColAddDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColAddDoubleColumn.java index cda87de..099d3c3 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColAddDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColAddDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] + vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] + vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColAddLongColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColAddLongColumn.java index b3ed12a..ccf1871 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColAddLongColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColAddLongColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] + vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] + vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColDivideDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColDivideDoubleColumn.java index 02b4120..fedc32a 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColDivideDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColDivideDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] / vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] / vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColModuloDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColModuloDoubleColumn.java index 568390c..4a2f403 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColModuloDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColModuloDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] % vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] % vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColModuloLongColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColModuloLongColumn.java index 7f7902b..c5a8190 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColModuloLongColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColModuloLongColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] % vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] % vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColMultiplyDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColMultiplyDoubleColumn.java index 3153305..60674e4 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColMultiplyDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColMultiplyDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] * vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] * vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColMultiplyLongColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColMultiplyLongColumn.java index f137271..2f40dc5 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColMultiplyLongColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColMultiplyLongColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] * vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] * vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColSubtractDoubleColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColSubtractDoubleColumn.java index 0287e3c..62f2b04 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColSubtractDoubleColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColSubtractDoubleColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] - vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] - vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColSubtractLongColumn.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColSubtractLongColumn.java index c806c67..732446d 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColSubtractLongColumn.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/LongColSubtractLongColumn.java @@ -55,20 +55,13 @@ public void evaluate(VectorizedRowBatch batch) { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public void evaluate(VectorizedRowBatch batch) { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public void evaluate(VectorizedRowBatch batch) { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] - vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public void evaluate(VectorizedRowBatch batch) { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] - vector2[i]; } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/ColumnArithmeticColumn.txt b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/ColumnArithmeticColumn.txt index 0e56721..db39852 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/ColumnArithmeticColumn.txt +++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/ColumnArithmeticColumn.txt @@ -55,20 +55,13 @@ public class extends VectorExpression { return; } - /* Set repeating property to false (the default). - * It will be set to true later if needed later. - */ - outputColVector.isRepeating = false; + outputColVector.isRepeating = inputColVector1.isRepeating && inputColVector2.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls && inputColVector2.noNulls; - //Handle nulls first + // Handle nulls first if (inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isNull[0] = true; - outputColVector.isRepeating = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector2.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -76,19 +69,12 @@ public class extends VectorExpression { outputColVector.isNull[i] = inputColVector2.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector2.isNull[i]; - } + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && inputColVector2.noNulls) { - outputColVector.noNulls = false; if (inputColVector1.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; + outputColVector.isNull[0] = inputColVector1.isNull[0]; } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -96,20 +82,51 @@ public class extends VectorExpression { outputColVector.isNull[i] = inputColVector1.isNull[i]; } } else { - for(int i = 0; i != n; i++) { - outputColVector.isNull[i] = inputColVector1.isNull[i]; - } + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); } } } else if (!inputColVector1.noNulls && !inputColVector2.noNulls) { - outputColVector.noNulls = false; - if (inputColVector1.isRepeating || inputColVector2.isRepeating) { - //Output will also be repeating and null - outputColVector.isRepeating = true; - outputColVector.isNull[0] = true; - //return as no further processing is needed - return; - } else { + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + outputColVector.isNull[0] = inputColVector1.isNull[0] || inputColVector2.isNull[0]; + if (outputColVector.isNull[0]) { + outputColVector.isRepeating = true; + return; + } + } else if (inputColVector1.isRepeating && !inputColVector2.isRepeating) { + if (inputColVector1.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector2.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector2.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else if (!inputColVector1.isRepeating && inputColVector2.isRepeating) { + if (inputColVector2.isNull[0]) { + outputColVector.isNull[0] = true; + outputColVector.isRepeating = true; // because every value will be NULL + return; + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + outputColVector.isNull[i] = inputColVector1.isNull[i]; + } + } else { + + // copy nulls from the non-repeating side + System.arraycopy(inputColVector1.isNull, 0, outputColVector.isNull, 0, n); + } + } + } else { // neither side is repeating if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; @@ -122,14 +139,14 @@ public class extends VectorExpression { } } } - - - //Disregard nulls for processing + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. outputVector[0] = vector1[0] vector2[0]; - outputColVector.isRepeating = true; } else if (inputColVector1.isRepeating) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { @@ -154,7 +171,7 @@ public class extends VectorExpression { } } else { if (batch.selectedInUse) { - for(int j=0; j != n; j++) { + for(int j = 0; j != n; j++) { int i = sel[j]; outputVector[i] = vector1[i] vector2[i]; } diff --git a/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorArithmeticExpressions.java b/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorArithmeticExpressions.java index 42872b2..c38f11e 100644 --- a/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorArithmeticExpressions.java +++ b/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/TestVectorArithmeticExpressions.java @@ -138,7 +138,7 @@ public void testLongColAddLongColumn() { } assertTrue(lcv2.noNulls); - //Now set one column nullable + // Now set one column nullable lcv1.noNulls = false; lcv1.isNull[1] = true; lcv2.isRepeating = true; // set output isRepeating to true to make sure it gets over-written @@ -148,7 +148,7 @@ public void testLongColAddLongColumn() { assertFalse(lcv2.noNulls); assertFalse(lcv2.isRepeating); - //Now set other column nullable too + // Now set other column nullable too lcv0.noNulls = false; lcv0.isNull[1] = true; lcv0.isNull[3] = true; @@ -157,7 +157,7 @@ public void testLongColAddLongColumn() { assertTrue(lcv2.isNull[3]); assertFalse(lcv2.noNulls); - //Now test with repeating flag + // Now test with repeating flag lcv3.isRepeating = true; LongColAddLongColumn expr2 = new LongColAddLongColumn(3, 4, 5); expr2.evaluate(vrg); @@ -165,14 +165,14 @@ public void testLongColAddLongColumn() { assertEquals(seed * ( 4 + 5*(i+1)), lcv5.vector[i]); } - //Repeating with other as nullable + // Repeating with other as nullable lcv4.noNulls = false; lcv4.isNull[0] = true; expr2.evaluate(vrg); assertTrue(lcv5.isNull[0]); assertFalse(lcv5.noNulls); - //Repeating null value + // Repeating null value lcv3.isRepeating = true; lcv3.noNulls = false; lcv3.isNull[0] = true; @@ -180,5 +180,17 @@ public void testLongColAddLongColumn() { assertFalse(lcv5.noNulls); assertTrue(lcv5.isRepeating); assertTrue(lcv5.isNull[0]); + + // Neither input has nulls. Verify that this propagates to output. + vrg.selectedInUse = false; + lcv0.noNulls = true; + lcv1.noNulls = true; + lcv0.isRepeating = false; + lcv1.isRepeating = false; + lcv2.noNulls = false; // set output noNulls to true to make sure it gets over-written + lcv2.isRepeating = true; // similarly with isRepeating + expr.evaluate(vrg); + assertTrue(lcv2.noNulls); + assertFalse(lcv2.isRepeating); } }