You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by ha...@apache.org on 2013/09/05 20:56:06 UTC
svn commit: r1520385 [5/5] - in /hive/branches/vectorization/ql/src:
gen/vectorization/ gen/vectorization/ExpressionTemplates/
gen/vectorization/TestTemplates/ gen/vectorization/UDAFTemplates/
gen/vectorization/org/ gen/vectorization/org/apache/ gen/ve...
Modified: hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java
URL: http://svn.apache.org/viewvc/hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java?rev=1520385&r1=1520384&r2=1520385&view=diff
==============================================================================
--- hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java (original)
+++ hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java Thu Sep 5 18:56:04 2013
@@ -60,15 +60,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -121,15 +123,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -182,15 +186,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -243,15 +249,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -304,15 +312,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -365,15 +375,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -426,15 +438,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -487,15 +501,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -548,15 +564,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -609,15 +627,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -670,15 +690,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -731,15 +753,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -792,15 +816,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -853,15 +879,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -914,15 +942,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -975,15 +1005,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -1036,15 +1068,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -1097,15 +1131,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -1158,15 +1194,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -1219,15 +1257,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -1280,15 +1320,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -1341,15 +1383,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -1402,15 +1446,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -1463,15 +1509,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -1524,15 +1572,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -1585,15 +1635,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -1646,15 +1698,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -1707,15 +1761,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -1768,15 +1824,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -1829,15 +1887,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -1890,15 +1950,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -1951,15 +2013,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -2012,15 +2076,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -2073,15 +2139,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -2134,15 +2202,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -2195,15 +2265,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -2256,15 +2328,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -2317,15 +2391,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -2378,15 +2454,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -2439,15 +2517,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -2500,15 +2580,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -2561,15 +2643,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -2622,15 +2706,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -2683,15 +2769,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -2744,15 +2832,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -2805,15 +2895,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -2866,15 +2958,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -2927,15 +3021,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -2988,15 +3084,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -3049,15 +3147,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -3110,15 +3210,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -3171,15 +3273,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -3232,15 +3336,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -3293,15 +3399,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -3354,15 +3462,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -3415,15 +3525,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] == scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] == scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] == scalarValue) {
assertEquals(
@@ -3476,15 +3588,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -3537,15 +3651,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -3598,15 +3714,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -3659,15 +3777,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -3720,15 +3840,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -3781,15 +3903,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -3842,15 +3966,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -3903,15 +4029,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] != scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] != scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] != scalarValue) {
assertEquals(
@@ -3964,15 +4092,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -4025,15 +4155,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -4086,15 +4218,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -4147,15 +4281,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -4208,15 +4344,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -4269,15 +4407,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -4330,15 +4470,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -4391,15 +4533,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] < scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] < scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] < scalarValue) {
assertEquals(
@@ -4452,15 +4596,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -4513,15 +4659,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -4574,15 +4722,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -4635,15 +4785,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -4696,15 +4848,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -4757,15 +4911,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -4818,15 +4974,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -4879,15 +5037,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] <= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] <= scalarValue) {
assertEquals(
@@ -4940,15 +5100,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -5001,15 +5163,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -5062,15 +5226,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -5123,15 +5289,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -5184,15 +5352,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -5245,15 +5415,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -5306,15 +5478,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -5367,15 +5541,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] > scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] > scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] > scalarValue) {
assertEquals(
@@ -5428,15 +5604,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -5489,15 +5667,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -5550,15 +5730,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -5611,15 +5793,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -5672,15 +5856,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -5733,15 +5919,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -5794,15 +5982,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -5855,15 +6045,17 @@ public class TestColumnScalarFilterVecto
vectorExpression.evaluate(rowBatch);
+
int selectedIndex = 0;
+ int i=0;
//check for isRepeating optimization
if(inputColumnVector.isRepeating) {
//null vector is safe to check, as it is always initialized to match the data vector
selectedIndex =
- !inputColumnVector.isNull[0] && inputColumnVector.vector[0] >= scalarValue
+ !inputColumnVector.isNull[i] && inputColumnVector.vector[i] >= scalarValue
? BATCH_SIZE : 0;
} else {
- for(int i = 0; i < BATCH_SIZE; i++) {
+ for(i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
if(inputColumnVector.vector[i] >= scalarValue) {
assertEquals(
@@ -5894,6 +6086,6054 @@ public class TestColumnScalarFilterVecto
}
}
+ @Test
+ public void testFilterLongScalarEqualDoubleColumnColNullsRepeats() {
+
+ Random rand = new Random(SEED);
+
+ DoubleColumnVector inputColumnVector =
+ VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+ true, BATCH_SIZE, rand);
+
+ VectorizedRowBatch rowBatch = new VectorizedRowBatch(1, BATCH_SIZE);
+ rowBatch.cols[0] = inputColumnVector;
+
+ long scalarValue = 0;
+ do {
+ scalarValue = rand.nextLong();
+ } while(scalarValue == 0);
+
+ FilterLongScalarEqualDoubleColumn vectorExpression =
+ new FilterLongScalarEqualDoubleColumn(0, scalarValue);
+
+ vectorExpression.evaluate(rowBatch);
+
+
+ int selectedIndex = 0;
+ int i=0;
+ //check for isRepeating optimization
+ if(inputColumnVector.isRepeating) {
+ //null vector is safe to check, as it is always initialized to match the data vector
+ selectedIndex =
+ !inputColumnVector.isNull[i] && scalarValue == inputColumnVector.vector[i]
+ ? BATCH_SIZE : 0;
+ } else {
+ for(i = 0; i < BATCH_SIZE; i++) {
+ if(!inputColumnVector.isNull[i]) {
+ if(scalarValue == inputColumnVector.vector[i]) {
+ assertEquals(
+ "Vector index that passes filter "
+ + scalarValue + "=="
+ + inputColumnVector.vector[i] + " is not in rowBatch selected index",
+ i,
+ rowBatch.selected[selectedIndex]);
+ selectedIndex++;
+ }
+ }
+ }
+ }
+
+ assertEquals("Row batch size not set to number of selected rows: " + selectedIndex,
+ selectedIndex, rowBatch.size);
+
+ if(selectedIndex > 0 && selectedIndex < BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should be set when > 0 and < entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ true, rowBatch.selectedInUse);
+ } else if(selectedIndex == BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should not be set when entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ false, rowBatch.selectedInUse);
+ }
+ }
+
+ @Test
+ public void testFilterLongScalarEqualDoubleColumnColNulls() {
+
+ Random rand = new Random(SEED);
+
+ DoubleColumnVector inputColumnVector =
+ VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+ false, BATCH_SIZE, rand);
+
+ VectorizedRowBatch rowBatch = new VectorizedRowBatch(1, BATCH_SIZE);
+ rowBatch.cols[0] = inputColumnVector;
+
+ long scalarValue = 0;
+ do {
+ scalarValue = rand.nextLong();
+ } while(scalarValue == 0);
+
+ FilterLongScalarEqualDoubleColumn vectorExpression =
+ new FilterLongScalarEqualDoubleColumn(0, scalarValue);
+
+ vectorExpression.evaluate(rowBatch);
+
+
+ int selectedIndex = 0;
+ int i=0;
+ //check for isRepeating optimization
+ if(inputColumnVector.isRepeating) {
+ //null vector is safe to check, as it is always initialized to match the data vector
+ selectedIndex =
+ !inputColumnVector.isNull[i] && scalarValue == inputColumnVector.vector[i]
+ ? BATCH_SIZE : 0;
+ } else {
+ for(i = 0; i < BATCH_SIZE; i++) {
+ if(!inputColumnVector.isNull[i]) {
+ if(scalarValue == inputColumnVector.vector[i]) {
+ assertEquals(
+ "Vector index that passes filter "
+ + scalarValue + "=="
+ + inputColumnVector.vector[i] + " is not in rowBatch selected index",
+ i,
+ rowBatch.selected[selectedIndex]);
+ selectedIndex++;
+ }
+ }
+ }
+ }
+
+ assertEquals("Row batch size not set to number of selected rows: " + selectedIndex,
+ selectedIndex, rowBatch.size);
+
+ if(selectedIndex > 0 && selectedIndex < BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should be set when > 0 and < entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ true, rowBatch.selectedInUse);
+ } else if(selectedIndex == BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should not be set when entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ false, rowBatch.selectedInUse);
+ }
+ }
+
+ @Test
+ public void testFilterLongScalarEqualDoubleColumn() {
+
+ Random rand = new Random(SEED);
+
+ DoubleColumnVector inputColumnVector =
+ VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+ false, BATCH_SIZE, rand);
+
+ VectorizedRowBatch rowBatch = new VectorizedRowBatch(1, BATCH_SIZE);
+ rowBatch.cols[0] = inputColumnVector;
+
+ long scalarValue = 0;
+ do {
+ scalarValue = rand.nextLong();
+ } while(scalarValue == 0);
+
+ FilterLongScalarEqualDoubleColumn vectorExpression =
+ new FilterLongScalarEqualDoubleColumn(0, scalarValue);
+
+ vectorExpression.evaluate(rowBatch);
+
+
+ int selectedIndex = 0;
+ int i=0;
+ //check for isRepeating optimization
+ if(inputColumnVector.isRepeating) {
+ //null vector is safe to check, as it is always initialized to match the data vector
+ selectedIndex =
+ !inputColumnVector.isNull[i] && scalarValue == inputColumnVector.vector[i]
+ ? BATCH_SIZE : 0;
+ } else {
+ for(i = 0; i < BATCH_SIZE; i++) {
+ if(!inputColumnVector.isNull[i]) {
+ if(scalarValue == inputColumnVector.vector[i]) {
+ assertEquals(
+ "Vector index that passes filter "
+ + scalarValue + "=="
+ + inputColumnVector.vector[i] + " is not in rowBatch selected index",
+ i,
+ rowBatch.selected[selectedIndex]);
+ selectedIndex++;
+ }
+ }
+ }
+ }
+
+ assertEquals("Row batch size not set to number of selected rows: " + selectedIndex,
+ selectedIndex, rowBatch.size);
+
+ if(selectedIndex > 0 && selectedIndex < BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should be set when > 0 and < entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ true, rowBatch.selectedInUse);
+ } else if(selectedIndex == BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should not be set when entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ false, rowBatch.selectedInUse);
+ }
+ }
+
+ @Test
+ public void testFilterLongScalarEqualDoubleColumnColRepeats() {
+
+ Random rand = new Random(SEED);
+
+ DoubleColumnVector inputColumnVector =
+ VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+ true, BATCH_SIZE, rand);
+
+ VectorizedRowBatch rowBatch = new VectorizedRowBatch(1, BATCH_SIZE);
+ rowBatch.cols[0] = inputColumnVector;
+
+ long scalarValue = 0;
+ do {
+ scalarValue = rand.nextLong();
+ } while(scalarValue == 0);
+
+ FilterLongScalarEqualDoubleColumn vectorExpression =
+ new FilterLongScalarEqualDoubleColumn(0, scalarValue);
+
+ vectorExpression.evaluate(rowBatch);
+
+
+ int selectedIndex = 0;
+ int i=0;
+ //check for isRepeating optimization
+ if(inputColumnVector.isRepeating) {
+ //null vector is safe to check, as it is always initialized to match the data vector
+ selectedIndex =
+ !inputColumnVector.isNull[i] && scalarValue == inputColumnVector.vector[i]
+ ? BATCH_SIZE : 0;
+ } else {
+ for(i = 0; i < BATCH_SIZE; i++) {
+ if(!inputColumnVector.isNull[i]) {
+ if(scalarValue == inputColumnVector.vector[i]) {
+ assertEquals(
+ "Vector index that passes filter "
+ + scalarValue + "=="
+ + inputColumnVector.vector[i] + " is not in rowBatch selected index",
+ i,
+ rowBatch.selected[selectedIndex]);
+ selectedIndex++;
+ }
+ }
+ }
+ }
+
+ assertEquals("Row batch size not set to number of selected rows: " + selectedIndex,
+ selectedIndex, rowBatch.size);
+
+ if(selectedIndex > 0 && selectedIndex < BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should be set when > 0 and < entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ true, rowBatch.selectedInUse);
+ } else if(selectedIndex == BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should not be set when entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ false, rowBatch.selectedInUse);
+ }
+ }
+
+ @Test
+ public void testFilterDoubleScalarEqualDoubleColumnColNullsRepeats() {
+
+ Random rand = new Random(SEED);
+
+ DoubleColumnVector inputColumnVector =
+ VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+ true, BATCH_SIZE, rand);
+
+ VectorizedRowBatch rowBatch = new VectorizedRowBatch(1, BATCH_SIZE);
+ rowBatch.cols[0] = inputColumnVector;
+
+ double scalarValue = 0;
+ do {
+ scalarValue = rand.nextDouble();
+ } while(scalarValue == 0);
+
+ FilterDoubleScalarEqualDoubleColumn vectorExpression =
+ new FilterDoubleScalarEqualDoubleColumn(0, scalarValue);
+
+ vectorExpression.evaluate(rowBatch);
+
+
+ int selectedIndex = 0;
+ int i=0;
+ //check for isRepeating optimization
+ if(inputColumnVector.isRepeating) {
+ //null vector is safe to check, as it is always initialized to match the data vector
+ selectedIndex =
+ !inputColumnVector.isNull[i] && scalarValue == inputColumnVector.vector[i]
+ ? BATCH_SIZE : 0;
+ } else {
+ for(i = 0; i < BATCH_SIZE; i++) {
+ if(!inputColumnVector.isNull[i]) {
+ if(scalarValue == inputColumnVector.vector[i]) {
+ assertEquals(
+ "Vector index that passes filter "
+ + scalarValue + "=="
+ + inputColumnVector.vector[i] + " is not in rowBatch selected index",
+ i,
+ rowBatch.selected[selectedIndex]);
+ selectedIndex++;
+ }
+ }
+ }
+ }
+
+ assertEquals("Row batch size not set to number of selected rows: " + selectedIndex,
+ selectedIndex, rowBatch.size);
+
+ if(selectedIndex > 0 && selectedIndex < BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should be set when > 0 and < entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ true, rowBatch.selectedInUse);
+ } else if(selectedIndex == BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should not be set when entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ false, rowBatch.selectedInUse);
+ }
+ }
+
+ @Test
+ public void testFilterDoubleScalarEqualDoubleColumnColNulls() {
+
+ Random rand = new Random(SEED);
+
+ DoubleColumnVector inputColumnVector =
+ VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+ false, BATCH_SIZE, rand);
+
+ VectorizedRowBatch rowBatch = new VectorizedRowBatch(1, BATCH_SIZE);
+ rowBatch.cols[0] = inputColumnVector;
+
+ double scalarValue = 0;
+ do {
+ scalarValue = rand.nextDouble();
+ } while(scalarValue == 0);
+
+ FilterDoubleScalarEqualDoubleColumn vectorExpression =
+ new FilterDoubleScalarEqualDoubleColumn(0, scalarValue);
+
+ vectorExpression.evaluate(rowBatch);
+
+
+ int selectedIndex = 0;
+ int i=0;
+ //check for isRepeating optimization
+ if(inputColumnVector.isRepeating) {
+ //null vector is safe to check, as it is always initialized to match the data vector
+ selectedIndex =
+ !inputColumnVector.isNull[i] && scalarValue == inputColumnVector.vector[i]
+ ? BATCH_SIZE : 0;
+ } else {
+ for(i = 0; i < BATCH_SIZE; i++) {
+ if(!inputColumnVector.isNull[i]) {
+ if(scalarValue == inputColumnVector.vector[i]) {
+ assertEquals(
+ "Vector index that passes filter "
+ + scalarValue + "=="
+ + inputColumnVector.vector[i] + " is not in rowBatch selected index",
+ i,
+ rowBatch.selected[selectedIndex]);
+ selectedIndex++;
+ }
+ }
+ }
+ }
+
+ assertEquals("Row batch size not set to number of selected rows: " + selectedIndex,
+ selectedIndex, rowBatch.size);
+
+ if(selectedIndex > 0 && selectedIndex < BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should be set when > 0 and < entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ true, rowBatch.selectedInUse);
+ } else if(selectedIndex == BATCH_SIZE) {
+ assertEquals(
+ "selectedInUse should not be set when entire batch(" + BATCH_SIZE + ") is selected: "
+ + selectedIndex,
+ false, rowBatch.selectedInUse);
+ }
+ }
+
+ @Test
+ public void testFilterDoubleScalarEqualDoubleColumn() {
+
+ Random rand = new Random(SEED);
+
+ DoubleColumnVector inputColumnVector =
+ VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+ false, BATCH_SIZE, rand);
+
+ VectorizedRowBatch rowBatch = new VectorizedRowBatch(1, BATCH_SIZE);
+ rowBatch.cols[0] = inputColumnVector;
+
+ double scalarValue = 0;
+ do {
+ scalarValue = rand.nextDouble();
+ } while(scalarValue == 0);
+
+ FilterDoubleScalarEqualDoubleColumn vectorExpression =
+ new FilterDoubleScalarEqualDoubleColumn(0, scalarValue);
+
+ vectorExpression.evaluate(rowBatch);
+
+
+ int selectedIndex = 0;
+ int i=0;
+ //check for isRepeating optimization
+ if(inputColumnVector.isRepeating) {
+ //null vector is safe to check, as it is always initialized to match the data vector
+ selectedIndex =
+ !inputColumnVector.isNull[i] && scalarValue == inputColumnVector.vector[i]
+ ? BATCH_SIZE : 0;
+ } else {
+ for(i = 0; i < BATCH_SIZE; i++) {
[... 5641 lines stripped ...]