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/08/16 23:02:57 UTC
svn commit: r1514894 [1/2] - in /hive/branches/vectorization/ql/src:
java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/
test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/
Author: hashutosh
Date: Fri Aug 16 21:02:57 2013
New Revision: 1514894
URL: http://svn.apache.org/r1514894
Log:
Revert HIVE-4989 : Consolidate and simplify vectorization code and test generation (Jitendra Nath Pandey via Ashutosh Chauhan)
Modified:
hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/CodeGen.java
hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java
hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt
hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java
hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java
Modified: hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/CodeGen.java
URL: http://svn.apache.org/viewvc/hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/CodeGen.java?rev=1514894&r1=1514893&r2=1514894&view=diff
==============================================================================
--- hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/CodeGen.java (original)
+++ hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/CodeGen.java Fri Aug 16 21:02:57 2013
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-package org.apache.hadoop.hive.ql.exec.vector.gen;
+package org.apache.hadoop.hive.ql.exec.vector.expressions.templates;
import java.io.BufferedReader;
import java.io.BufferedWriter;
@@ -267,10 +267,8 @@ public class CodeGen {
};
- private final String expressionOutputDirectory;
- private final String expressionTemplateDirectory;
- private final String udafOutputDirectory;
- private final String udafTemplateDirectory;
+ private final String templateDirectory;
+ private final String outputDirectory;
private final TestCodeGen testCodeGen;
static String joinPath(String...parts) {
@@ -282,35 +280,16 @@ public class CodeGen {
}
public CodeGen() {
- File generationDirectory = new File(System.getProperty("user.dir"));
+ templateDirectory = System.getProperty("user.dir");
+ File f = new File(templateDirectory);
+ outputDirectory = joinPath(f.getParent(), "gen");
+ testCodeGen = new TestCodeGen(joinPath(f.getParent(), "test"), templateDirectory);
+ }
- expressionOutputDirectory =
- new File(
- joinPath(
- generationDirectory.getAbsolutePath(),"..", "..", "java", "org",
- "apache", "hadoop", "hive", "ql", "exec", "vector",
- "expressions", "gen")).getAbsolutePath();
-
- expressionTemplateDirectory =
- joinPath(generationDirectory.getAbsolutePath(), "ExpressionTemplates");
-
- udafOutputDirectory =
- new File(
- joinPath(
- generationDirectory.getAbsolutePath(),"..", "..", "java", "org",
- "apache", "hadoop", "hive", "ql", "exec", "vector",
- "expressions", "aggregates", "gen")).getAbsolutePath();
-
- udafTemplateDirectory =
- joinPath(generationDirectory.getAbsolutePath(), "udafTemplates");
-
- testCodeGen = new TestCodeGen(
- new File(
- joinPath(
- generationDirectory.getAbsolutePath(), "..", "..","test", "org",
- "apache", "hadoop", "hive", "ql", "exec", "vector",
- "expressions", "gen")).getAbsolutePath(),
- joinPath(generationDirectory.getAbsolutePath(), "TestTemplates"));
+ public CodeGen(String templateDirectory, String outputDirectory, String testOutputDirectory) {
+ this.templateDirectory = templateDirectory;
+ this.outputDirectory = outputDirectory;
+ testCodeGen = new TestCodeGen(testOutputDirectory, templateDirectory);
}
/**
@@ -318,7 +297,15 @@ public class CodeGen {
* @throws Exception
*/
public static void main(String[] args) throws Exception {
- CodeGen gen = new CodeGen();
+ CodeGen gen;
+ if (args == null || args.length==0) {
+ gen = new CodeGen();
+ } else if (args.length==3) {
+ gen = new CodeGen(args[0], args[1], args[2]);
+ }else{
+ System.out.println("args: <templateDir> <outputDir> <testOutputDir>");
+ return;
+ }
gen.generate();
}
@@ -374,8 +361,8 @@ public class CodeGen {
String writableType = getOutputWritableType(valueType);
String inspectorType = getOutputObjectInspector(valueType);
- String outputFile = joinPath(this.udafOutputDirectory, className + ".java");
- String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
templateString = templateString.replaceAll("<ClassName>", className);
@@ -396,8 +383,8 @@ public class CodeGen {
String descName = tdesc[3];
String descValue = tdesc[4];
- String outputFile = joinPath(this.udafOutputDirectory, className + ".java");
- String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
templateString = templateString.replaceAll("<ClassName>", className);
@@ -416,8 +403,8 @@ public class CodeGen {
String writableType = getOutputWritableType(valueType);
String inspectorType = getOutputObjectInspector(valueType);
- String outputFile = joinPath(this.udafOutputDirectory, className + ".java");
- String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
templateString = templateString.replaceAll("<ClassName>", className);
@@ -433,8 +420,8 @@ public class CodeGen {
String valueType = tdesc[2];
String columnType = getColumnVectorType(valueType);
- String outputFile = joinPath(this.udafOutputDirectory, className + ".java");
- String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
templateString = templateString.replaceAll("<ClassName>", className);
@@ -451,8 +438,8 @@ public class CodeGen {
String descriptionValue = tdesc[5];
String columnType = getColumnVectorType(valueType);
- String outputFile = joinPath(this.udafOutputDirectory, className + ".java");
- String templateFile = joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
templateString = templateString.replaceAll("<ClassName>", className);
@@ -487,9 +474,9 @@ public class CodeGen {
private void generateFilterStringColumnCompareScalar(String[] tdesc, String className)
throws IOException {
String operatorSymbol = tdesc[2];
- String outputFile = joinPath(this.expressionOutputDirectory, className + ".java");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
// Read the template into a string;
- String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
// Expand, and write result
templateString = templateString.replaceAll("<ClassName>", className);
@@ -514,8 +501,8 @@ public class CodeGen {
String outputColumnVectorType = inputColumnVectorType;
String returnType = operandType;
String className = getCamelCaseType(operandType) + "ColUnaryMinus";
- String outputFile = joinPath(this.expressionOutputDirectory, className + ".java");
- String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
// Expand, and write result
templateString = templateString.replaceAll("<ClassName>", className);
@@ -575,10 +562,10 @@ public class CodeGen {
String inputColumnVectorType1 = this.getColumnVectorType(operandType1);
String inputColumnVectorType2 = this.getColumnVectorType(operandType2);
String operatorSymbol = tdesc[4];
- String outputFile = joinPath(this.expressionOutputDirectory, className + ".java");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
//Read the template into a string;
- String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
templateString = templateString.replaceAll("<ClassName>", className);
templateString = templateString.replaceAll("<InputColumnVectorType1>", inputColumnVectorType1);
@@ -613,10 +600,10 @@ public class CodeGen {
String outputColumnVectorType = this.getColumnVectorType(returnType);
String inputColumnVectorType = this.getColumnVectorType(operandType1);
String operatorSymbol = tdesc[4];
- String outputFile = joinPath(this.expressionOutputDirectory, className + ".java");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
//Read the template into a string;
- String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
templateString = templateString.replaceAll("<ClassName>", className);
templateString = templateString.replaceAll("<InputColumnVectorType>", inputColumnVectorType);
@@ -651,10 +638,10 @@ public class CodeGen {
String outputColumnVectorType = this.getColumnVectorType(returnType);
String inputColumnVectorType = this.getColumnVectorType(operandType2);
String operatorSymbol = tdesc[4];
- String outputFile = joinPath(this.expressionOutputDirectory, className + ".java");
+ String outputFile = joinPath(this.outputDirectory, className + ".java");
//Read the template into a string;
- String templateFile = joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt");
+ String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt");
String templateString = readFile(templateFile);
templateString = templateString.replaceAll("<ClassName>", className);
templateString = templateString.replaceAll("<InputColumnVectorType>", inputColumnVectorType);
Modified: hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java
URL: http://svn.apache.org/viewvc/hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java?rev=1514894&r1=1514893&r2=1514894&view=diff
==============================================================================
--- hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java (original)
+++ hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java Fri Aug 16 21:02:57 2013
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-package org.apache.hadoop.hive.ql.exec.vector.gen;
+package org.apache.hadoop.hive.ql.exec.vector.expressions.templates;
import java.io.IOException;
import java.util.HashMap;
@@ -43,12 +43,12 @@ public class TestCodeGen {
}
private final String testOutputDir;
- private final String testTemplateDirectory;
+ private final String templateDirectory;
private final HashMap<TestSuiteClassName,StringBuilder> testsuites;
- public TestCodeGen(String testOutputDir, String testTemplateDirectory) {
+ public TestCodeGen(String testOutputDir, String templateDirectory) {
this.testOutputDir = testOutputDir;
- this.testTemplateDirectory = testTemplateDirectory;
+ this.templateDirectory = templateDirectory;
testsuites = new HashMap<TestSuiteClassName, StringBuilder>();
for(TestSuiteClassName className : TestSuiteClassName.values()) {
@@ -65,7 +65,7 @@ public class TestCodeGen {
TestSuiteClassName.TestColumnScalarOperationVectorExpressionEvaluation;
//Read the template into a string;
- String templateFile = CodeGen.joinPath(this.testTemplateDirectory,template.toString()+".txt");
+ String templateFile = CodeGen.joinPath(this.templateDirectory,template.toString()+".txt");
String templateString = removeTemplateComments(CodeGen.readFile(templateFile));
for(Boolean[] testMatrix :new Boolean[][]{
@@ -109,7 +109,7 @@ public class TestCodeGen {
TestSuiteClassName.TestColumnScalarFilterVectorExpressionEvaluation;
//Read the template into a string;
- String templateFile = CodeGen.joinPath(this.testTemplateDirectory,template.toString()+".txt");
+ String templateFile = CodeGen.joinPath(this.templateDirectory,template.toString()+".txt");
String templateString = removeTemplateComments(CodeGen.readFile(templateFile));
for(Boolean[] testMatrix : new Boolean[][]{
@@ -132,11 +132,9 @@ public class TestCodeGen {
testCase = testCase.replaceAll("<Operator>", operatorSymbol);
if(op1IsCol){
- testCase = testCase.replaceAll("<Operand1>","inputColumnVector.vector[i]");
- testCase = testCase.replaceAll("<Operand2>","scalarValue");
+ testCase = testCase.replaceAll("<ConstructorParams>","0, scalarValue");
}else{
- testCase = testCase.replaceAll("<Operand1>","scalarValue");
- testCase = testCase.replaceAll("<Operand2>","inputColumnVector.vector[i]");
+ testCase = testCase.replaceAll("<ConstructorParams>","scalarValue, 0");
}
testsuites.get(template).append(testCase);
@@ -151,7 +149,7 @@ public class TestCodeGen {
TestSuiteClassName.TestColumnColumnOperationVectorExpressionEvaluation;
//Read the template into a string;
- String templateFile = CodeGen.joinPath(this.testTemplateDirectory,template.toString()+".txt");
+ String templateFile = CodeGen.joinPath(this.templateDirectory,template.toString()+".txt");
String templateString = removeTemplateComments(CodeGen.readFile(templateFile));
for(Boolean[] testMatrix : new Boolean[][]{
@@ -193,7 +191,7 @@ public class TestCodeGen {
TestSuiteClassName.TestColumnColumnFilterVectorExpressionEvaluation;
//Read the template into a string;
- String templateFile = CodeGen.joinPath(this.testTemplateDirectory,template.toString()+".txt");
+ String templateFile = CodeGen.joinPath(this.templateDirectory,template.toString()+".txt");
String templateString = removeTemplateComments(CodeGen.readFile(templateFile));
for(Boolean[] testMatrix : new Boolean[][]{
@@ -224,7 +222,7 @@ public class TestCodeGen {
public void generateTestSuites() throws IOException {
- String templateFile = CodeGen.joinPath(this.testTemplateDirectory, "TestClass.txt");
+ String templateFile = CodeGen.joinPath(this.templateDirectory, "TestClass.txt");
for(TestSuiteClassName testClass : testsuites.keySet()) {
String templateString = CodeGen.readFile(templateFile);
Modified: hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt
URL: http://svn.apache.org/viewvc/hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt?rev=1514894&r1=1514893&r2=1514894&view=diff
==============================================================================
--- hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt (original)
+++ hive/branches/vectorization/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt Fri Aug 16 21:02:57 2013
@@ -32,27 +32,25 @@
} while(scalarValue == 0);
<VectorExpClassName> vectorExpression =
- new <VectorExpClassName>(0, scalarValue);
+ new <VectorExpClassName>(<ConstructorParams>);
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] && <Operand1> <Operator> <Operand2>
+ !inputColumnVector.isNull[0] && inputColumnVector.vector[0] <Operator> scalarValue
? BATCH_SIZE : 0;
} else {
- for(i = 0; i < BATCH_SIZE; i++) {
+ for(int i = 0; i < BATCH_SIZE; i++) {
if(!inputColumnVector.isNull[i]) {
- if(<Operand1> <Operator> <Operand2>) {
+ if(inputColumnVector.vector[i] <Operator> scalarValue) {
assertEquals(
"Vector index that passes filter "
- + <Operand1> + "<Operator>"
- + <Operand2> + " is not in rowBatch selected index",
+ + inputColumnVector.vector[i] + "<Operator>"
+ + scalarValue + " is not in rowBatch selected index",
i,
rowBatch.selected[selectedIndex]);
selectedIndex++;
Modified: hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java
URL: http://svn.apache.org/viewvc/hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java?rev=1514894&r1=1514893&r2=1514894&view=diff
==============================================================================
--- hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java (original)
+++ hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java Fri Aug 16 21:02:57 2013
@@ -76,7 +76,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -125,7 +124,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -174,7 +172,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -223,7 +220,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -272,7 +268,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -321,7 +316,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -370,7 +364,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -419,7 +412,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -468,7 +460,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -517,7 +508,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -566,7 +556,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -615,7 +604,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -664,7 +652,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -713,7 +700,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -762,7 +748,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -811,7 +796,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -860,7 +844,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -909,7 +892,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -958,7 +940,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1007,7 +988,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1056,7 +1036,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1105,7 +1084,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1154,7 +1132,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1203,7 +1180,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1252,7 +1228,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1301,7 +1276,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1350,7 +1324,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1399,7 +1372,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1448,7 +1420,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1497,7 +1468,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1546,7 +1516,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1595,7 +1564,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1644,7 +1612,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1693,7 +1660,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1742,7 +1708,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1791,7 +1756,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1840,7 +1804,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1889,7 +1852,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1938,7 +1900,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -1987,7 +1948,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2036,7 +1996,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2085,7 +2044,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2134,7 +2092,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2183,7 +2140,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2232,7 +2188,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2281,7 +2236,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2330,7 +2284,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2379,7 +2332,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2428,7 +2380,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2477,7 +2428,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2526,7 +2476,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2575,7 +2524,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2624,7 +2572,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2673,7 +2620,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2722,7 +2668,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2771,7 +2716,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2820,7 +2764,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2869,7 +2812,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2918,7 +2860,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -2967,7 +2908,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3016,7 +2956,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3065,7 +3004,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3114,7 +3052,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3163,7 +3100,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3212,7 +3148,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3261,7 +3196,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3310,7 +3244,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3359,7 +3292,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3408,7 +3340,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3457,7 +3388,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3506,7 +3436,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3555,7 +3484,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3604,7 +3532,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3653,7 +3580,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3702,7 +3628,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3751,7 +3676,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3800,7 +3724,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3849,7 +3772,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3898,7 +3820,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3947,7 +3868,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -3996,7 +3916,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4045,7 +3964,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4094,7 +4012,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4143,7 +4060,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4192,7 +4108,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4241,7 +4156,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4290,7 +4204,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4339,7 +4252,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4388,7 +4300,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4437,7 +4348,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4486,7 +4396,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4535,7 +4444,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4584,7 +4492,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4633,7 +4540,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4682,7 +4588,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4731,7 +4636,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4780,7 +4684,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4829,7 +4732,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4878,7 +4780,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4927,7 +4828,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -4976,7 +4876,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5025,7 +4924,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5074,7 +4972,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5123,7 +5020,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5172,7 +5068,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5221,7 +5116,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5270,7 +5164,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5319,7 +5212,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5368,7 +5260,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5417,7 +5308,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5466,7 +5356,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5515,7 +5404,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5564,7 +5452,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector
@@ -5613,7 +5500,6 @@ public class TestColumnColumnOperationVe
"Output column vector no nulls state does not match operand columns",
inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls);
- //if repeating, only the first value matters
if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
for(int i = 0; i < BATCH_SIZE; i++) {
//null vectors are safe to check, as they are always initialized to match the data vector