hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hashut...@apache.org
Subject 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...
Date Thu, 05 Sep 2013 18:56:06 GMT
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 ...]


Mime
View raw message