From 25d7cac42418cfbf72c703e4fdf442251d4c81df Mon Sep 17 00:00:00 2001 From: Tony Murphy Date: Fri, 17 May 2013 11:03:23 -0700 Subject: [PATCH] HIVE-4553 --- .../exec/vector/expressions/templates/CodeGen.java | 116 +- .../vector/expressions/templates/TestClass.txt | 44 + .../vector/expressions/templates/TestCodeGen.java | 256 + ...olumnColumnFilterVectorExpressionEvaluation.txt | 69 + ...mnColumnOperationVectorExpressionEvaluation.txt | 61 + ...olumnScalarFilterVectorExpressionEvaluation.txt | 76 + ...mnScalarOperationVectorExpressionEvaluation.txt | 59 + ...lumnColumnFilterVectorExpressionEvaluation.java | 6524 +++++++++++ ...nColumnOperationVectorExpressionEvaluation.java | 5288 +++++++++ ...lumnScalarFilterVectorExpressionEvaluation.java | 5900 ++++++++++ ...nScalarOperationVectorExpressionEvaluation.java | 11044 +++++++++++++++++++ .../vector/util/VectorizedRowGroupGenUtil.java | 74 + 12 files changed, 29482 insertions(+), 29 deletions(-) create mode 100644 ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestClass.txt create mode 100644 ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java create mode 100644 ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnFilterVectorExpressionEvaluation.txt create mode 100644 ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnOperationVectorExpressionEvaluation.txt create mode 100644 ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt create mode 100644 ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarOperationVectorExpressionEvaluation.txt create mode 100644 ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnFilterVectorExpressionEvaluation.java create mode 100644 ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java create mode 100644 ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java create mode 100644 ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarOperationVectorExpressionEvaluation.java diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/CodeGen.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/CodeGen.java index 53d9a7a..2ce242a 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/CodeGen.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/CodeGen.java @@ -216,10 +216,12 @@ }; + private final String templateDirectory; private final String outputDirectory; + private final TestCodeGen testCodeGen; - private static String joinPath(String...parts) { + static String joinPath(String...parts) { String path = parts[0]; for (int i=1; i < parts.length; ++i) { path += File.separatorChar + parts[i]; @@ -231,11 +233,13 @@ public CodeGen() { templateDirectory = System.getProperty("user.dir"); File f = new File(templateDirectory); outputDirectory = joinPath(f.getParent(), "gen"); + testCodeGen = new TestCodeGen(joinPath(f.getParent(), "test"),templateDirectory); } - public CodeGen(String templateDirectory, String outputDirectory) { + public CodeGen(String templateDirectory, String outputDirectory, String testOutputDirectory) { this.templateDirectory = templateDirectory; this.outputDirectory = outputDirectory; + testCodeGen = new TestCodeGen(testOutputDirectory,templateDirectory); } /** @@ -244,10 +248,13 @@ public CodeGen(String templateDirectory, String outputDirectory) { */ public static void main(String[] args) throws Exception { CodeGen gen; - if (args != null && args[0] != null) { - gen = new CodeGen(args[0], args[1]); - } else { + 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: "); + return; } gen.generate(); } @@ -277,6 +284,7 @@ private void generate() throws Exception { continue; } } + testCodeGen.generateTestSuites(); } private void generateVectorUDAFMinMax(String[] tdesc) throws Exception { @@ -407,9 +415,9 @@ private void generateFilterColumnCompareColumn(String[] tdesc) throws IOExceptio String operatorName = tdesc[1]; String operandType1 = tdesc[2]; String operandType2 = tdesc[3]; - String className = "Filter" + this.getCamelCaseType(operandType1) - + "Col" + operatorName + this.getCamelCaseType(operandType2) + "Column"; - generateColumnBinaryOperatorColumn(tdesc, "doesn't matter", className); + String className = "Filter" + getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Column"; + generateColumnBinaryOperatorColumn(tdesc, null, className); } private void generateColumnUnaryMinus(String[] tdesc) throws IOException { @@ -417,7 +425,7 @@ private void generateColumnUnaryMinus(String[] tdesc) throws IOException { String inputColumnVectorType = this.getColumnVectorType(operandType); String outputColumnVectorType = inputColumnVectorType; String returnType = operandType; - String className = this.getCamelCaseType(operandType) + "ColUnaryMinus"; + String className = getCamelCaseType(operandType) + "ColUnaryMinus"; String outputFile = joinPath(this.outputDirectory, className + ".java"); String templateFile = joinPath(this.templateDirectory, tdesc[0] + ".txt"); String templateString = readFile(templateFile); @@ -434,8 +442,8 @@ private void generateColumnArithmeticColumn(String [] tdesc) throws IOException String operatorName = tdesc[1]; String operandType1 = tdesc[2]; String operandType2 = tdesc[3]; - String className = this.getCamelCaseType(operandType1) - + "Col" + operatorName + this.getCamelCaseType(operandType2) + "Column"; + String className = getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Column"; String returnType = getArithmeticReturnType(operandType1, operandType2); generateColumnBinaryOperatorColumn(tdesc, returnType, className); } @@ -446,9 +454,9 @@ private void generateFilterColumnCompareScalar(String[] tdesc) throws IOExceptio String operatorName = tdesc[1]; String operandType1 = tdesc[2]; String operandType2 = tdesc[3]; - String className = "Filter" + this.getCamelCaseType(operandType1) - + "Col" + operatorName + this.getCamelCaseType(operandType2) + "Scalar"; - generateColumnBinaryOperatorScalar(tdesc, "doesn't matter", className); + String className = "Filter" + getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Scalar"; + generateColumnBinaryOperatorScalar(tdesc, null, className); } private void generateFilterScalarCompareColumn(String[] tdesc) throws IOException { @@ -456,9 +464,9 @@ private void generateFilterScalarCompareColumn(String[] tdesc) throws IOExceptio String operatorName = tdesc[1]; String operandType1 = tdesc[2]; String operandType2 = tdesc[3]; - String className = "Filter" + this.getCamelCaseType(operandType1) - + "Scalar" + operatorName + this.getCamelCaseType(operandType2) + "Column"; - generateScalarBinaryOperatorColumn(tdesc, "doesn't matter", className); + String className = "Filter" + getCamelCaseType(operandType1) + + "Scalar" + operatorName + getCamelCaseType(operandType2) + "Column"; + generateScalarBinaryOperatorColumn(tdesc, null, className); } private void generateColumnCompareScalar(String[] tdesc) throws IOException { @@ -466,8 +474,8 @@ private void generateColumnCompareScalar(String[] tdesc) throws IOException { String operandType1 = tdesc[2]; String operandType2 = tdesc[3]; String returnType = "long"; - String className = this.getCamelCaseType(operandType1) - + "Col" + operatorName + this.getCamelCaseType(operandType2) + "Scalar"; + String className = getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Scalar"; generateColumnBinaryOperatorScalar(tdesc, returnType, className); } @@ -493,6 +501,20 @@ private void generateColumnBinaryOperatorColumn(String[] tdesc, String returnTyp templateString = templateString.replaceAll("", operandType2); templateString = templateString.replaceAll("", returnType); writeFile(outputFile, templateString); + + if(returnType==null){ + testCodeGen.addColumnColumnFilterTestCases( + className, + inputColumnVectorType1, + inputColumnVectorType2, + operatorSymbol); + }else{ + testCodeGen.addColumnColumnOperationTestCases( + className, + inputColumnVectorType1, + inputColumnVectorType2, + outputColumnVectorType); + } } private void generateColumnBinaryOperatorScalar(String[] tdesc, String returnType, @@ -515,6 +537,25 @@ private void generateColumnBinaryOperatorScalar(String[] tdesc, String returnTyp templateString = templateString.replaceAll("", operandType2); templateString = templateString.replaceAll("", returnType); writeFile(outputFile, templateString); + + if(returnType==null) + { + testCodeGen.addColumnScalarFilterTestCases( + true, + className, + inputColumnVectorType, + operandType2, + operatorSymbol); + }else + { + testCodeGen.addColumnScalarOperationTestCases( + true, + className, + inputColumnVectorType, + outputColumnVectorType, + operandType2); + } + } private void generateScalarBinaryOperatorColumn(String[] tdesc, String returnType, @@ -537,6 +578,24 @@ private void generateScalarBinaryOperatorColumn(String[] tdesc, String returnTyp templateString = templateString.replaceAll("", operandType2); templateString = templateString.replaceAll("", returnType); writeFile(outputFile, templateString); + + if(returnType==null) + { + testCodeGen.addColumnScalarFilterTestCases( + false, + className, + inputColumnVectorType, + operandType1, + operatorSymbol); + }else + { + testCodeGen.addColumnScalarOperationTestCases( + false, + className, + inputColumnVectorType, + outputColumnVectorType, + operandType1); + } } //Binary arithmetic operator @@ -544,8 +603,8 @@ private void generateColumnArithmeticScalar(String[] tdesc) throws IOException { String operatorName = tdesc[1]; String operandType1 = tdesc[2]; String operandType2 = tdesc[3]; - String className = this.getCamelCaseType(operandType1) - + "Col" + operatorName + this.getCamelCaseType(operandType2) + "Scalar"; + String className = getCamelCaseType(operandType1) + + "Col" + operatorName + getCamelCaseType(operandType2) + "Scalar"; String returnType = getArithmeticReturnType(operandType1, operandType2); generateColumnBinaryOperatorScalar(tdesc, returnType, className); } @@ -554,19 +613,20 @@ private void generateScalarArithmeticColumn(String[] tdesc) throws IOException { String operatorName = tdesc[1]; String operandType1 = tdesc[2]; String operandType2 = tdesc[3]; - String className = this.getCamelCaseType(operandType1) - + "Scalar" + operatorName + this.getCamelCaseType(operandType2) + "Column"; + String className = getCamelCaseType(operandType1) + + "Scalar" + operatorName + getCamelCaseType(operandType2) + "Column"; String returnType = getArithmeticReturnType(operandType1, operandType2); generateScalarBinaryOperatorColumn(tdesc, returnType, className); } - private void writeFile(String outputFile, String str) throws IOException { + + static void writeFile(String outputFile, String str) throws IOException { BufferedWriter w = new BufferedWriter(new FileWriter(outputFile)); w.write(str); w.close(); } - private String readFile(String templateFile) throws IOException { + static String readFile(String templateFile) throws IOException { BufferedReader r = new BufferedReader(new FileReader(templateFile)); String line = r.readLine(); StringBuilder b = new StringBuilder(); @@ -579,7 +639,7 @@ private String readFile(String templateFile) throws IOException { return b.toString(); } - private String getCamelCaseType(String type) { + static String getCamelCaseType(String type) { if (type.equals("long")) { return "Long"; } else if (type.equals("double")) { @@ -600,9 +660,7 @@ private String getArithmeticReturnType(String operandType1, } private String getColumnVectorType(String primitiveType) { - if (primitiveType.equals("long")) { - return "LongColumnVector"; - } else if (primitiveType.equals("double")) { + if(primitiveType!=null && primitiveType.equals("double")) { return "DoubleColumnVector"; } return "LongColumnVector"; diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestClass.txt ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestClass.txt new file mode 100644 index 0000000..c8de5de --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestClass.txt @@ -0,0 +1,44 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; + +import static org.junit.Assert.assertEquals; +import java.util.Random; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Test; + + +/** + * + * . + * + */ +public class { + + private static final int BATCH_SIZE = 100; + private static final long SEED = 0xfa57; + + + +} + + diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java new file mode 100644 index 0000000..34c093c --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java @@ -0,0 +1,256 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions.templates; + +import java.io.IOException; +import java.util.HashMap; + +/** + * + * TestCodeGen. + * This class is mutable and maintains a hashmap of TestSuiteClassName to test cases. + * The tests cases are added over the course of vectorized expressions class generation, + * with test classes being outputted at the end. For each column vector (inputs and/or outputs) + * a matrix of pairwise covering Booleans is used to generate test cases across nulls and + * repeating dimensions. Based on the input column vector(s) nulls and repeating states + * the states of the output column vector (if there is one) is validated, along with the null + * vector. For filter operations the selection vector is validated against the generated + * data. Each template corresponds to a class representing a test suite. + */ +public class TestCodeGen { + + public enum TestSuiteClassName{ + TestColumnScalarOperationVectorExpressionEvaluation, + TestColumnScalarFilterVectorExpressionEvaluation, + TestColumnColumnOperationVectorExpressionEvaluation, + TestColumnColumnFilterVectorExpressionEvaluation, + } + + private final String testOutputDir; + private final String templateDirectory; + private final HashMap testsuites; + + public TestCodeGen(String testOutputDir, String templateDirectory) { + this.testOutputDir = testOutputDir; + this.templateDirectory = templateDirectory; + testsuites = new HashMap(); + + for(TestSuiteClassName className : TestSuiteClassName.values()) { + testsuites.put(className,new StringBuilder()); + } + + } + + public void addColumnScalarOperationTestCases(boolean op1IsCol, String vectorExpClassName, + String inputColumnVectorType, String outputColumnVectorType, String scalarType) + throws IOException { + + TestSuiteClassName template = + TestSuiteClassName.TestColumnScalarOperationVectorExpressionEvaluation; + + //Read the template into a string; + String templateFile = CodeGen.joinPath(this.templateDirectory,template.toString()+".txt"); + String templateString = removeTemplateComments(CodeGen.readFile(templateFile)); + + for(Boolean[] testMatrix :new Boolean[][]{ + // Pairwise: InitOuputColHasNulls, InitOuputColIsRepeating, ColumnHasNulls, ColumnIsRepeating + {false, true, true, true}, + {false, false, false, false}, + {true, false, true, false}, + {true, true, false, false}, + {true, false, false, true}}) { + String testCase = templateString; + testCase = testCase.replaceAll("", + "test" + + vectorExpClassName + + createNullRepeatingNameFragment("Out", testMatrix[0], testMatrix[1]) + + createNullRepeatingNameFragment("Col", testMatrix[2], testMatrix[3])); + testCase = testCase.replaceAll("", vectorExpClassName); + testCase = testCase.replaceAll("", inputColumnVectorType); + testCase = testCase.replaceAll("", outputColumnVectorType); + testCase = testCase.replaceAll("", scalarType); + testCase = testCase.replaceAll("", CodeGen.getCamelCaseType(scalarType)); + testCase = testCase.replaceAll("", testMatrix[0].toString()); + testCase = testCase.replaceAll("", testMatrix[1].toString()); + testCase = testCase.replaceAll("", testMatrix[2].toString()); + testCase = testCase.replaceAll("", testMatrix[3].toString()); + + if(op1IsCol){ + testCase = testCase.replaceAll("","0, scalarValue"); + }else{ + testCase = testCase.replaceAll("","scalarValue, 0"); + } + + testsuites.get(template).append(testCase); + } + } + + public void addColumnScalarFilterTestCases(boolean op1IsCol, String vectorExpClassName, + String inputColumnVectorType, String scalarType, String operatorSymbol) + throws IOException { + + TestSuiteClassName template = + TestSuiteClassName.TestColumnScalarFilterVectorExpressionEvaluation; + + //Read the template into a string; + String templateFile = CodeGen.joinPath(this.templateDirectory,template.toString()+".txt"); + String templateString = removeTemplateComments(CodeGen.readFile(templateFile)); + + for(Boolean[] testMatrix : new Boolean[][]{ + // Pairwise: ColumnHasNulls, ColumnIsRepeating + {true, true}, + {true, false}, + {false, false}, + {false, true}}) { + String testCase = templateString; + testCase = testCase.replaceAll("", + "test" + + vectorExpClassName + + createNullRepeatingNameFragment("Col", testMatrix[0], testMatrix[1])); + testCase = testCase.replaceAll("", vectorExpClassName); + testCase = testCase.replaceAll("", inputColumnVectorType); + testCase = testCase.replaceAll("", scalarType); + testCase = testCase.replaceAll("", CodeGen.getCamelCaseType(scalarType)); + testCase = testCase.replaceAll("", testMatrix[0].toString()); + testCase = testCase.replaceAll("", testMatrix[1].toString()); + testCase = testCase.replaceAll("", operatorSymbol); + + if(op1IsCol){ + testCase = testCase.replaceAll("","0, scalarValue"); + }else{ + testCase = testCase.replaceAll("","scalarValue, 0"); + } + + testsuites.get(template).append(testCase); + } + } + + public void addColumnColumnOperationTestCases(String vectorExpClassName, + String inputColumnVectorType1, String inputColumnVectorType2, String outputColumnVectorType) + throws IOException { + + TestSuiteClassName template= + TestSuiteClassName.TestColumnColumnOperationVectorExpressionEvaluation; + + //Read the template into a string; + String templateFile = CodeGen.joinPath(this.templateDirectory,template.toString()+".txt"); + String templateString = removeTemplateComments(CodeGen.readFile(templateFile)); + + for(Boolean[] testMatrix : new Boolean[][]{ + // Pairwise: InitOuputColHasNulls, InitOuputColIsRepeating, Column1HasNulls, + // Column1IsRepeating, Column2HasNulls, Column2IsRepeating + {true, true, false, true, true, true}, + {false, false, true, false, false, false}, + {true, false, true, false, true, true}, + {true, true, true, true, false, false}, + {false, false, false, true, true, false}, + {false, true, false, false, false, true}}) { + String testCase = templateString; + testCase = testCase.replaceAll("", + "test" + + vectorExpClassName + + createNullRepeatingNameFragment("Out", testMatrix[0], testMatrix[1]) + + createNullRepeatingNameFragment("C1", testMatrix[2], testMatrix[3]) + + createNullRepeatingNameFragment("C2", testMatrix[4], testMatrix[5])); + testCase = testCase.replaceAll("", vectorExpClassName); + testCase = testCase.replaceAll("", inputColumnVectorType1); + testCase = testCase.replaceAll("", inputColumnVectorType2); + testCase = testCase.replaceAll("", outputColumnVectorType); + testCase = testCase.replaceAll("", testMatrix[0].toString()); + testCase = testCase.replaceAll("", testMatrix[1].toString()); + testCase = testCase.replaceAll("", testMatrix[2].toString()); + testCase = testCase.replaceAll("", testMatrix[3].toString()); + testCase = testCase.replaceAll("", testMatrix[4].toString()); + testCase = testCase.replaceAll("", testMatrix[5].toString()); + + testsuites.get(template).append(testCase); + } + } + + public void addColumnColumnFilterTestCases(String vectorExpClassName, + String inputColumnVectorType1, String inputColumnVectorType2, String operatorSymbol) + throws IOException { + + TestSuiteClassName template= + TestSuiteClassName.TestColumnColumnFilterVectorExpressionEvaluation; + + //Read the template into a string; + String templateFile = CodeGen.joinPath(this.templateDirectory,template.toString()+".txt"); + String templateString = removeTemplateComments(CodeGen.readFile(templateFile)); + + for(Boolean[] testMatrix : new Boolean[][]{ + // Pairwise: Column1HasNulls, Column1IsRepeating, Column2HasNulls, Column2IsRepeating + {false, true, true, true}, + {false, false, false, false}, + {true, false, true, false}, + {true, true, false, false}, + {true, false, false, true}}) { + String testCase = templateString; + testCase = testCase.replaceAll("", + "test" + + vectorExpClassName + + createNullRepeatingNameFragment("C1", testMatrix[0], testMatrix[1]) + + createNullRepeatingNameFragment("C2", testMatrix[2], testMatrix[3])); + testCase = testCase.replaceAll("", vectorExpClassName); + testCase = testCase.replaceAll("", inputColumnVectorType1); + testCase = testCase.replaceAll("", inputColumnVectorType2); + testCase = testCase.replaceAll("", testMatrix[0].toString()); + testCase = testCase.replaceAll("", testMatrix[1].toString()); + testCase = testCase.replaceAll("", testMatrix[2].toString()); + testCase = testCase.replaceAll("", testMatrix[3].toString()); + testCase = testCase.replaceAll("", operatorSymbol); + + testsuites.get(template).append(testCase); + } + } + + public void generateTestSuites() throws IOException { + + String templateFile = CodeGen.joinPath(this.templateDirectory, "TestClass.txt"); + for(TestSuiteClassName testClass : testsuites.keySet()) { + + String templateString = CodeGen.readFile(templateFile); + templateString = templateString.replaceAll("", testClass.toString()); + templateString = templateString.replaceAll("", testsuites.get(testClass).toString()); + + String outputFile = CodeGen.joinPath(this.testOutputDir, testClass + ".java"); + + CodeGen.writeFile(outputFile, templateString); + } + } + + private static String createNullRepeatingNameFragment(String idenitfier, boolean nulls, boolean repeating) + { + if(nulls || repeating){ + if(nulls){ + idenitfier+="Nulls"; + } + if(repeating){ + idenitfier+="Repeats"; + } + return idenitfier; + } + + return ""; + } + + private static String removeTemplateComments(String templateString){ + return templateString.replaceAll("(?s)", ""); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnFilterVectorExpressionEvaluation.txt ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnFilterVectorExpressionEvaluation.txt new file mode 100644 index 0000000..2bb1aa3 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnFilterVectorExpressionEvaluation.txt @@ -0,0 +1,69 @@ + + @Test + public void () { + + Random rand = new Random(SEED); + + inputColumnVector1 = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + inputColumnVector2 = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + vectorExpression = + new (0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "" + + inputColumnVector2.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); + } + } \ No newline at end of file diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnOperationVectorExpressionEvaluation.txt ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnOperationVectorExpressionEvaluation.txt new file mode 100644 index 0000000..c72120b --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnOperationVectorExpressionEvaluation.txt @@ -0,0 +1,61 @@ + + @Test + public void () { + + Random rand = new Random(SEED); + + outputColumnVector = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + inputColumnVector1 = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + inputColumnVector2 = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + vectorExpression = + new (0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } \ No newline at end of file diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt new file mode 100644 index 0000000..5b53d6a --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt @@ -0,0 +1,76 @@ + + @Test + public void () { + + Random rand = new Random(SEED); + + inputColumnVector = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(1, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + + scalarValue = 0; + do { + scalarValue = rand.next(); + } while(scalarValue == 0); + + vectorExpression = + new (); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "" + + scalarValue + " 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); + } + } \ No newline at end of file diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarOperationVectorExpressionEvaluation.txt ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarOperationVectorExpressionEvaluation.txt new file mode 100644 index 0000000..e5f3f18 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarOperationVectorExpressionEvaluation.txt @@ -0,0 +1,59 @@ + + @Test + public void () { + + Random rand = new Random(SEED); + + outputColumnVector = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + inputColumnVector = + VectorizedRowGroupGenUtil.generate(, + , BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + scalarValue = 0; + do { + scalarValue = rand.next(); + } while(scalarValue == 0); + + vectorExpression = + new (, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } \ No newline at end of file diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnFilterVectorExpressionEvaluation.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnFilterVectorExpressionEvaluation.java new file mode 100644 index 0000000..fb52bd0 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnFilterVectorExpressionEvaluation.java @@ -0,0 +1,6524 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; + +import static org.junit.Assert.assertEquals; +import java.util.Random; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Test; + + +/** + * + * TestColumnColumnFilterVectorExpressionEvaluation. + * + */ +public class TestColumnColumnFilterVectorExpressionEvaluation{ + + private static final int BATCH_SIZE = 100; + private static final long SEED = 0xfa57; + + + @Test + public void testFilterLongColEqualDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualDoubleColumn vectorExpression = + new FilterLongColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColEqualDoubleColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualDoubleColumn vectorExpression = + new FilterLongColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColEqualDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualDoubleColumn vectorExpression = + new FilterLongColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColEqualDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualDoubleColumn vectorExpression = + new FilterLongColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColEqualDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualDoubleColumn vectorExpression = + new FilterLongColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualDoubleColumn vectorExpression = + new FilterDoubleColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualDoubleColumn vectorExpression = + new FilterDoubleColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualDoubleColumn vectorExpression = + new FilterDoubleColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualDoubleColumn vectorExpression = + new FilterDoubleColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualDoubleColumn vectorExpression = + new FilterDoubleColEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColNotEqualDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualDoubleColumn vectorExpression = + new FilterLongColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColNotEqualDoubleColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualDoubleColumn vectorExpression = + new FilterLongColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColNotEqualDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualDoubleColumn vectorExpression = + new FilterLongColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColNotEqualDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualDoubleColumn vectorExpression = + new FilterLongColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColNotEqualDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualDoubleColumn vectorExpression = + new FilterLongColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualDoubleColumn vectorExpression = + new FilterDoubleColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualDoubleColumn vectorExpression = + new FilterDoubleColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualDoubleColumn vectorExpression = + new FilterDoubleColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualDoubleColumn vectorExpression = + new FilterDoubleColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualDoubleColumn vectorExpression = + new FilterDoubleColNotEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColLessDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessDoubleColumn vectorExpression = + new FilterLongColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessDoubleColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessDoubleColumn vectorExpression = + new FilterLongColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessDoubleColumn vectorExpression = + new FilterLongColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessDoubleColumn vectorExpression = + new FilterLongColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessDoubleColumn vectorExpression = + new FilterLongColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessDoubleColumn vectorExpression = + new FilterDoubleColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessDoubleColumn vectorExpression = + new FilterDoubleColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessDoubleColumn vectorExpression = + new FilterDoubleColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessDoubleColumn vectorExpression = + new FilterDoubleColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessDoubleColumn vectorExpression = + new FilterDoubleColLessDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessEqualDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualDoubleColumn vectorExpression = + new FilterLongColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColLessEqualDoubleColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualDoubleColumn vectorExpression = + new FilterLongColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColLessEqualDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualDoubleColumn vectorExpression = + new FilterLongColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColLessEqualDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualDoubleColumn vectorExpression = + new FilterLongColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColLessEqualDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualDoubleColumn vectorExpression = + new FilterLongColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualDoubleColumn vectorExpression = + new FilterDoubleColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualDoubleColumn vectorExpression = + new FilterDoubleColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualDoubleColumn vectorExpression = + new FilterDoubleColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualDoubleColumn vectorExpression = + new FilterDoubleColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualDoubleColumn vectorExpression = + new FilterDoubleColLessEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColGreaterDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterDoubleColumn vectorExpression = + new FilterLongColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterDoubleColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterDoubleColumn vectorExpression = + new FilterLongColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterDoubleColumn vectorExpression = + new FilterLongColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterDoubleColumn vectorExpression = + new FilterLongColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterDoubleColumn vectorExpression = + new FilterLongColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterDoubleColumn vectorExpression = + new FilterDoubleColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterDoubleColumn vectorExpression = + new FilterDoubleColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterDoubleColumn vectorExpression = + new FilterDoubleColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterDoubleColumn vectorExpression = + new FilterDoubleColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterDoubleColumn vectorExpression = + new FilterDoubleColGreaterDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterEqualDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualDoubleColumn vectorExpression = + new FilterLongColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterLongColGreaterEqualDoubleColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualDoubleColumn vectorExpression = + new FilterLongColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterLongColGreaterEqualDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualDoubleColumn vectorExpression = + new FilterLongColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterLongColGreaterEqualDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualDoubleColumn vectorExpression = + new FilterLongColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterLongColGreaterEqualDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualDoubleColumn vectorExpression = + new FilterLongColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualDoubleColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualDoubleColumn vectorExpression = + new FilterDoubleColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualDoubleColumn vectorExpression = + new FilterDoubleColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualDoubleColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualDoubleColumn vectorExpression = + new FilterDoubleColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualDoubleColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualDoubleColumn vectorExpression = + new FilterDoubleColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualDoubleColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualDoubleColumn vectorExpression = + new FilterDoubleColGreaterEqualDoubleColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterLongColEqualLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualLongColumn vectorExpression = + new FilterLongColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColEqualLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualLongColumn vectorExpression = + new FilterLongColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColEqualLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualLongColumn vectorExpression = + new FilterLongColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColEqualLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualLongColumn vectorExpression = + new FilterLongColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColEqualLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColEqualLongColumn vectorExpression = + new FilterLongColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualLongColumn vectorExpression = + new FilterDoubleColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualLongColumn vectorExpression = + new FilterDoubleColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualLongColumn vectorExpression = + new FilterDoubleColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualLongColumn vectorExpression = + new FilterDoubleColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterDoubleColEqualLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColEqualLongColumn vectorExpression = + new FilterDoubleColEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] == inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "==" + + inputColumnVector2.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 testFilterLongColNotEqualLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualLongColumn vectorExpression = + new FilterLongColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColNotEqualLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualLongColumn vectorExpression = + new FilterLongColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColNotEqualLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualLongColumn vectorExpression = + new FilterLongColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColNotEqualLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualLongColumn vectorExpression = + new FilterLongColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColNotEqualLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColNotEqualLongColumn vectorExpression = + new FilterLongColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualLongColumn vectorExpression = + new FilterDoubleColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualLongColumn vectorExpression = + new FilterDoubleColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualLongColumn vectorExpression = + new FilterDoubleColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualLongColumn vectorExpression = + new FilterDoubleColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterDoubleColNotEqualLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColNotEqualLongColumn vectorExpression = + new FilterDoubleColNotEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] != inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "!=" + + inputColumnVector2.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 testFilterLongColLessLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessLongColumn vectorExpression = + new FilterLongColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessLongColumn vectorExpression = + new FilterLongColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessLongColumn vectorExpression = + new FilterLongColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessLongColumn vectorExpression = + new FilterLongColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessLongColumn vectorExpression = + new FilterLongColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessLongColumn vectorExpression = + new FilterDoubleColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessLongColumn vectorExpression = + new FilterDoubleColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessLongColumn vectorExpression = + new FilterDoubleColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessLongColumn vectorExpression = + new FilterDoubleColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterDoubleColLessLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessLongColumn vectorExpression = + new FilterDoubleColLessLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] < inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<" + + inputColumnVector2.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 testFilterLongColLessEqualLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualLongColumn vectorExpression = + new FilterLongColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColLessEqualLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualLongColumn vectorExpression = + new FilterLongColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColLessEqualLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualLongColumn vectorExpression = + new FilterLongColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColLessEqualLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualLongColumn vectorExpression = + new FilterLongColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColLessEqualLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColLessEqualLongColumn vectorExpression = + new FilterLongColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualLongColumn vectorExpression = + new FilterDoubleColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualLongColumn vectorExpression = + new FilterDoubleColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualLongColumn vectorExpression = + new FilterDoubleColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualLongColumn vectorExpression = + new FilterDoubleColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterDoubleColLessEqualLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColLessEqualLongColumn vectorExpression = + new FilterDoubleColLessEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] <= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + "<=" + + inputColumnVector2.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 testFilterLongColGreaterLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterLongColumn vectorExpression = + new FilterLongColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterLongColumn vectorExpression = + new FilterLongColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterLongColumn vectorExpression = + new FilterLongColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterLongColumn vectorExpression = + new FilterLongColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterLongColumn vectorExpression = + new FilterLongColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterLongColumn vectorExpression = + new FilterDoubleColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterLongColumn vectorExpression = + new FilterDoubleColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterLongColumn vectorExpression = + new FilterDoubleColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterLongColumn vectorExpression = + new FilterDoubleColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterDoubleColGreaterLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterLongColumn vectorExpression = + new FilterDoubleColGreaterLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] > inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">" + + inputColumnVector2.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 testFilterLongColGreaterEqualLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualLongColumn vectorExpression = + new FilterLongColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterLongColGreaterEqualLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualLongColumn vectorExpression = + new FilterLongColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterLongColGreaterEqualLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualLongColumn vectorExpression = + new FilterLongColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterLongColGreaterEqualLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualLongColumn vectorExpression = + new FilterLongColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterLongColGreaterEqualLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterLongColGreaterEqualLongColumn vectorExpression = + new FilterLongColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualLongColumnC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualLongColumn vectorExpression = + new FilterDoubleColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualLongColumn vectorExpression = + new FilterDoubleColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualLongColumnC1NullsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualLongColumn vectorExpression = + new FilterDoubleColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualLongColumnC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualLongColumn vectorExpression = + new FilterDoubleColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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 testFilterDoubleColGreaterEqualLongColumnC1NullsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + + FilterDoubleColGreaterEqualLongColumn vectorExpression = + new FilterDoubleColGreaterEqualLongColumn(0, 1); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 0; + for(int i = 0; i < BATCH_SIZE; i++) { + //null vector is safe to check, as it is always initialized to match the data vector + if(!inputColumnVector1.isNull[i] && !inputColumnVector2.isNull[i]) { + if(inputColumnVector1.vector[i] >= inputColumnVector2.vector[i]) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector1.vector[i] + ">=" + + inputColumnVector2.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); + } + } + + +} + + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java new file mode 100644 index 0000000..12601aa --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java @@ -0,0 +1,5288 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; + +import static org.junit.Assert.assertEquals; +import java.util.Random; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Test; + + +/** + * + * TestColumnColumnOperationVectorExpressionEvaluation. + * + */ +public class TestColumnColumnOperationVectorExpressionEvaluation{ + + private static final int BATCH_SIZE = 100; + private static final long SEED = 0xfa57; + + + @Test + public void testLongColAddLongColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddLongColumn vectorExpression = + new LongColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddLongColumnC1Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddLongColumn vectorExpression = + new LongColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddLongColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddLongColumn vectorExpression = + new LongColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddLongColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddLongColumn vectorExpression = + new LongColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddLongColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddLongColumn vectorExpression = + new LongColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddLongColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddLongColumn vectorExpression = + new LongColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractLongColumn vectorExpression = + new LongColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongColumnC1Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractLongColumn vectorExpression = + new LongColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractLongColumn vectorExpression = + new LongColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractLongColumn vectorExpression = + new LongColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractLongColumn vectorExpression = + new LongColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractLongColumn vectorExpression = + new LongColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyLongColumn vectorExpression = + new LongColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongColumnC1Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyLongColumn vectorExpression = + new LongColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyLongColumn vectorExpression = + new LongColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyLongColumn vectorExpression = + new LongColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyLongColumn vectorExpression = + new LongColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyLongColumn vectorExpression = + new LongColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloLongColumn vectorExpression = + new LongColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongColumnC1Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloLongColumn vectorExpression = + new LongColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloLongColumn vectorExpression = + new LongColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloLongColumn vectorExpression = + new LongColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloLongColumn vectorExpression = + new LongColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloLongColumn vectorExpression = + new LongColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddDoubleColumn vectorExpression = + new LongColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddDoubleColumn vectorExpression = + new LongColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddDoubleColumn vectorExpression = + new LongColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddDoubleColumn vectorExpression = + new LongColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddDoubleColumn vectorExpression = + new LongColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColAddDoubleColumn vectorExpression = + new LongColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractDoubleColumn vectorExpression = + new LongColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractDoubleColumn vectorExpression = + new LongColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractDoubleColumn vectorExpression = + new LongColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractDoubleColumn vectorExpression = + new LongColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractDoubleColumn vectorExpression = + new LongColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColSubtractDoubleColumn vectorExpression = + new LongColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyDoubleColumn vectorExpression = + new LongColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyDoubleColumn vectorExpression = + new LongColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyDoubleColumn vectorExpression = + new LongColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyDoubleColumn vectorExpression = + new LongColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyDoubleColumn vectorExpression = + new LongColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColMultiplyDoubleColumn vectorExpression = + new LongColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColDivideDoubleColumn vectorExpression = + new LongColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColDivideDoubleColumn vectorExpression = + new LongColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColDivideDoubleColumn vectorExpression = + new LongColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColDivideDoubleColumn vectorExpression = + new LongColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColDivideDoubleColumn vectorExpression = + new LongColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColDivideDoubleColumn vectorExpression = + new LongColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloDoubleColumn vectorExpression = + new LongColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloDoubleColumn vectorExpression = + new LongColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloDoubleColumn vectorExpression = + new LongColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloDoubleColumn vectorExpression = + new LongColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloDoubleColumn vectorExpression = + new LongColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + LongColModuloDoubleColumn vectorExpression = + new LongColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddLongColumn vectorExpression = + new DoubleColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddLongColumn vectorExpression = + new DoubleColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddLongColumn vectorExpression = + new DoubleColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddLongColumn vectorExpression = + new DoubleColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddLongColumn vectorExpression = + new DoubleColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddLongColumn vectorExpression = + new DoubleColAddLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractLongColumn vectorExpression = + new DoubleColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractLongColumn vectorExpression = + new DoubleColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractLongColumn vectorExpression = + new DoubleColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractLongColumn vectorExpression = + new DoubleColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractLongColumn vectorExpression = + new DoubleColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractLongColumn vectorExpression = + new DoubleColSubtractLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyLongColumn vectorExpression = + new DoubleColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyLongColumn vectorExpression = + new DoubleColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyLongColumn vectorExpression = + new DoubleColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyLongColumn vectorExpression = + new DoubleColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyLongColumn vectorExpression = + new DoubleColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyLongColumn vectorExpression = + new DoubleColMultiplyLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideLongColumn vectorExpression = + new DoubleColDivideLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideLongColumn vectorExpression = + new DoubleColDivideLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideLongColumn vectorExpression = + new DoubleColDivideLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideLongColumn vectorExpression = + new DoubleColDivideLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideLongColumn vectorExpression = + new DoubleColDivideLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideLongColumn vectorExpression = + new DoubleColDivideLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloLongColumn vectorExpression = + new DoubleColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloLongColumn vectorExpression = + new DoubleColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloLongColumn vectorExpression = + new DoubleColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloLongColumn vectorExpression = + new DoubleColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloLongColumn vectorExpression = + new DoubleColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloLongColumn vectorExpression = + new DoubleColModuloLongColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddDoubleColumn vectorExpression = + new DoubleColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddDoubleColumn vectorExpression = + new DoubleColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddDoubleColumn vectorExpression = + new DoubleColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddDoubleColumn vectorExpression = + new DoubleColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddDoubleColumn vectorExpression = + new DoubleColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColAddDoubleColumn vectorExpression = + new DoubleColAddDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractDoubleColumn vectorExpression = + new DoubleColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractDoubleColumn vectorExpression = + new DoubleColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractDoubleColumn vectorExpression = + new DoubleColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractDoubleColumn vectorExpression = + new DoubleColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractDoubleColumn vectorExpression = + new DoubleColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColSubtractDoubleColumn vectorExpression = + new DoubleColSubtractDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyDoubleColumn vectorExpression = + new DoubleColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyDoubleColumn vectorExpression = + new DoubleColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyDoubleColumn vectorExpression = + new DoubleColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyDoubleColumn vectorExpression = + new DoubleColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyDoubleColumn vectorExpression = + new DoubleColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColMultiplyDoubleColumn vectorExpression = + new DoubleColMultiplyDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideDoubleColumn vectorExpression = + new DoubleColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideDoubleColumn vectorExpression = + new DoubleColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideDoubleColumn vectorExpression = + new DoubleColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideDoubleColumn vectorExpression = + new DoubleColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideDoubleColumn vectorExpression = + new DoubleColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColDivideDoubleColumn vectorExpression = + new DoubleColDivideDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleColumnOutNullsRepeatsC1RepeatsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloDoubleColumn vectorExpression = + new DoubleColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleColumnC1Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloDoubleColumn vectorExpression = + new DoubleColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleColumnOutNullsC1NullsC2NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloDoubleColumn vectorExpression = + new DoubleColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleColumnOutNullsRepeatsC1NullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloDoubleColumn vectorExpression = + new DoubleColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleColumnC1RepeatsC2Nulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloDoubleColumn vectorExpression = + new DoubleColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleColumnOutRepeatsC2Repeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector1 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector2 = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(3, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector1; + rowBatch.cols[1] = inputColumnVector2; + rowBatch.cols[2] = outputColumnVector; + + DoubleColModuloDoubleColumn vectorExpression = + new DoubleColModuloDoubleColumn(0, 1, 2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand columns", + inputColumnVector1.isRepeating && inputColumnVector2.isRepeating, + outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand columns", + inputColumnVector1.noNulls && inputColumnVector2.noNulls, outputColumnVector.noNulls); + + if(!outputColumnVector.noNulls) { + for(int i = 0; i < BATCH_SIZE; i++) { + //null vectors are safe to check, as they are always initialized to match the data vector + assertEquals("Output vector doesn't match input vectors' is null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], + outputColumnVector.isNull[i]); + } + } + } + + +} + + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java new file mode 100644 index 0000000..6baa444 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java @@ -0,0 +1,5900 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; + +import static org.junit.Assert.assertEquals; +import java.util.Random; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Test; + + +/** + * + * TestColumnScalarFilterVectorExpressionEvaluation. + * + */ +public class TestColumnScalarFilterVectorExpressionEvaluation{ + + private static final int BATCH_SIZE = 100; + private static final long SEED = 0xfa57; + + + @Test + public void testFilterLongColEqualDoubleScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColEqualDoubleScalar vectorExpression = + new FilterLongColEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterLongColEqualDoubleScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColEqualDoubleScalar vectorExpression = + new FilterLongColEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterLongColEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColEqualDoubleScalar vectorExpression = + new FilterLongColEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterLongColEqualDoubleScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + 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); + + FilterLongColEqualDoubleScalar vectorExpression = + new FilterLongColEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterDoubleColEqualDoubleScalarColNullsRepeats() { + + 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); + + FilterDoubleColEqualDoubleScalar vectorExpression = + new FilterDoubleColEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterDoubleColEqualDoubleScalarColNulls() { + + 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); + + FilterDoubleColEqualDoubleScalar vectorExpression = + new FilterDoubleColEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterDoubleColEqualDoubleScalar() { + + 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); + + FilterDoubleColEqualDoubleScalar vectorExpression = + new FilterDoubleColEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterDoubleColEqualDoubleScalarColRepeats() { + + 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; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + FilterDoubleColEqualDoubleScalar vectorExpression = + new FilterDoubleColEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterLongColNotEqualDoubleScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColNotEqualDoubleScalar vectorExpression = + new FilterLongColNotEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterLongColNotEqualDoubleScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColNotEqualDoubleScalar vectorExpression = + new FilterLongColNotEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterLongColNotEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColNotEqualDoubleScalar vectorExpression = + new FilterLongColNotEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterLongColNotEqualDoubleScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + 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); + + FilterLongColNotEqualDoubleScalar vectorExpression = + new FilterLongColNotEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterDoubleColNotEqualDoubleScalarColNullsRepeats() { + + 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); + + FilterDoubleColNotEqualDoubleScalar vectorExpression = + new FilterDoubleColNotEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterDoubleColNotEqualDoubleScalarColNulls() { + + 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); + + FilterDoubleColNotEqualDoubleScalar vectorExpression = + new FilterDoubleColNotEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterDoubleColNotEqualDoubleScalar() { + + 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); + + FilterDoubleColNotEqualDoubleScalar vectorExpression = + new FilterDoubleColNotEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterDoubleColNotEqualDoubleScalarColRepeats() { + + 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; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + FilterDoubleColNotEqualDoubleScalar vectorExpression = + new FilterDoubleColNotEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterLongColLessDoubleScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessDoubleScalar vectorExpression = + new FilterLongColLessDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterLongColLessDoubleScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessDoubleScalar vectorExpression = + new FilterLongColLessDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterLongColLessDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessDoubleScalar vectorExpression = + new FilterLongColLessDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterLongColLessDoubleScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + 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); + + FilterLongColLessDoubleScalar vectorExpression = + new FilterLongColLessDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterDoubleColLessDoubleScalarColNullsRepeats() { + + 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); + + FilterDoubleColLessDoubleScalar vectorExpression = + new FilterDoubleColLessDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterDoubleColLessDoubleScalarColNulls() { + + 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); + + FilterDoubleColLessDoubleScalar vectorExpression = + new FilterDoubleColLessDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterDoubleColLessDoubleScalar() { + + 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); + + FilterDoubleColLessDoubleScalar vectorExpression = + new FilterDoubleColLessDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterDoubleColLessDoubleScalarColRepeats() { + + 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; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + FilterDoubleColLessDoubleScalar vectorExpression = + new FilterDoubleColLessDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterLongColLessEqualDoubleScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessEqualDoubleScalar vectorExpression = + new FilterLongColLessEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterLongColLessEqualDoubleScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessEqualDoubleScalar vectorExpression = + new FilterLongColLessEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterLongColLessEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessEqualDoubleScalar vectorExpression = + new FilterLongColLessEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterLongColLessEqualDoubleScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + 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); + + FilterLongColLessEqualDoubleScalar vectorExpression = + new FilterLongColLessEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterDoubleColLessEqualDoubleScalarColNullsRepeats() { + + 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); + + FilterDoubleColLessEqualDoubleScalar vectorExpression = + new FilterDoubleColLessEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterDoubleColLessEqualDoubleScalarColNulls() { + + 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); + + FilterDoubleColLessEqualDoubleScalar vectorExpression = + new FilterDoubleColLessEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterDoubleColLessEqualDoubleScalar() { + + 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); + + FilterDoubleColLessEqualDoubleScalar vectorExpression = + new FilterDoubleColLessEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterDoubleColLessEqualDoubleScalarColRepeats() { + + 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; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + FilterDoubleColLessEqualDoubleScalar vectorExpression = + new FilterDoubleColLessEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterLongColGreaterDoubleScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterDoubleScalar vectorExpression = + new FilterLongColGreaterDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterLongColGreaterDoubleScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterDoubleScalar vectorExpression = + new FilterLongColGreaterDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterLongColGreaterDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterDoubleScalar vectorExpression = + new FilterLongColGreaterDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterLongColGreaterDoubleScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + 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); + + FilterLongColGreaterDoubleScalar vectorExpression = + new FilterLongColGreaterDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterDoubleColGreaterDoubleScalarColNullsRepeats() { + + 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); + + FilterDoubleColGreaterDoubleScalar vectorExpression = + new FilterDoubleColGreaterDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterDoubleColGreaterDoubleScalarColNulls() { + + 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); + + FilterDoubleColGreaterDoubleScalar vectorExpression = + new FilterDoubleColGreaterDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterDoubleColGreaterDoubleScalar() { + + 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); + + FilterDoubleColGreaterDoubleScalar vectorExpression = + new FilterDoubleColGreaterDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterDoubleColGreaterDoubleScalarColRepeats() { + + 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; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + FilterDoubleColGreaterDoubleScalar vectorExpression = + new FilterDoubleColGreaterDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterLongColGreaterEqualDoubleScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterEqualDoubleScalar vectorExpression = + new FilterLongColGreaterEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterLongColGreaterEqualDoubleScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterEqualDoubleScalar vectorExpression = + new FilterLongColGreaterEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterLongColGreaterEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterEqualDoubleScalar vectorExpression = + new FilterLongColGreaterEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterLongColGreaterEqualDoubleScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + 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); + + FilterLongColGreaterEqualDoubleScalar vectorExpression = + new FilterLongColGreaterEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterDoubleColGreaterEqualDoubleScalarColNullsRepeats() { + + 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); + + FilterDoubleColGreaterEqualDoubleScalar vectorExpression = + new FilterDoubleColGreaterEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterDoubleColGreaterEqualDoubleScalarColNulls() { + + 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); + + FilterDoubleColGreaterEqualDoubleScalar vectorExpression = + new FilterDoubleColGreaterEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterDoubleColGreaterEqualDoubleScalar() { + + 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); + + FilterDoubleColGreaterEqualDoubleScalar vectorExpression = + new FilterDoubleColGreaterEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterDoubleColGreaterEqualDoubleScalarColRepeats() { + + 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; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + FilterDoubleColGreaterEqualDoubleScalar vectorExpression = + new FilterDoubleColGreaterEqualDoubleScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterLongColEqualLongScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColEqualLongScalar vectorExpression = + new FilterLongColEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterLongColEqualLongScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColEqualLongScalar vectorExpression = + new FilterLongColEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterLongColEqualLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColEqualLongScalar vectorExpression = + new FilterLongColEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterLongColEqualLongScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColEqualLongScalar vectorExpression = + new FilterLongColEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterDoubleColEqualLongScalarColNullsRepeats() { + + 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); + + FilterDoubleColEqualLongScalar vectorExpression = + new FilterDoubleColEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterDoubleColEqualLongScalarColNulls() { + + 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); + + FilterDoubleColEqualLongScalar vectorExpression = + new FilterDoubleColEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterDoubleColEqualLongScalar() { + + 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); + + FilterDoubleColEqualLongScalar vectorExpression = + new FilterDoubleColEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterDoubleColEqualLongScalarColRepeats() { + + 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); + + FilterDoubleColEqualLongScalar vectorExpression = + new FilterDoubleColEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] == scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "==" + + scalarValue + " 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 testFilterLongColNotEqualLongScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColNotEqualLongScalar vectorExpression = + new FilterLongColNotEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterLongColNotEqualLongScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColNotEqualLongScalar vectorExpression = + new FilterLongColNotEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterLongColNotEqualLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColNotEqualLongScalar vectorExpression = + new FilterLongColNotEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterLongColNotEqualLongScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColNotEqualLongScalar vectorExpression = + new FilterLongColNotEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterDoubleColNotEqualLongScalarColNullsRepeats() { + + 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); + + FilterDoubleColNotEqualLongScalar vectorExpression = + new FilterDoubleColNotEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterDoubleColNotEqualLongScalarColNulls() { + + 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); + + FilterDoubleColNotEqualLongScalar vectorExpression = + new FilterDoubleColNotEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterDoubleColNotEqualLongScalar() { + + 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); + + FilterDoubleColNotEqualLongScalar vectorExpression = + new FilterDoubleColNotEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterDoubleColNotEqualLongScalarColRepeats() { + + 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); + + FilterDoubleColNotEqualLongScalar vectorExpression = + new FilterDoubleColNotEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] != scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "!=" + + scalarValue + " 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 testFilterLongColLessLongScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessLongScalar vectorExpression = + new FilterLongColLessLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterLongColLessLongScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessLongScalar vectorExpression = + new FilterLongColLessLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterLongColLessLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessLongScalar vectorExpression = + new FilterLongColLessLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterLongColLessLongScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessLongScalar vectorExpression = + new FilterLongColLessLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterDoubleColLessLongScalarColNullsRepeats() { + + 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); + + FilterDoubleColLessLongScalar vectorExpression = + new FilterDoubleColLessLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterDoubleColLessLongScalarColNulls() { + + 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); + + FilterDoubleColLessLongScalar vectorExpression = + new FilterDoubleColLessLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterDoubleColLessLongScalar() { + + 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); + + FilterDoubleColLessLongScalar vectorExpression = + new FilterDoubleColLessLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterDoubleColLessLongScalarColRepeats() { + + 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); + + FilterDoubleColLessLongScalar vectorExpression = + new FilterDoubleColLessLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] < scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<" + + scalarValue + " 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 testFilterLongColLessEqualLongScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessEqualLongScalar vectorExpression = + new FilterLongColLessEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterLongColLessEqualLongScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessEqualLongScalar vectorExpression = + new FilterLongColLessEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterLongColLessEqualLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessEqualLongScalar vectorExpression = + new FilterLongColLessEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterLongColLessEqualLongScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColLessEqualLongScalar vectorExpression = + new FilterLongColLessEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterDoubleColLessEqualLongScalarColNullsRepeats() { + + 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); + + FilterDoubleColLessEqualLongScalar vectorExpression = + new FilterDoubleColLessEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterDoubleColLessEqualLongScalarColNulls() { + + 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); + + FilterDoubleColLessEqualLongScalar vectorExpression = + new FilterDoubleColLessEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterDoubleColLessEqualLongScalar() { + + 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); + + FilterDoubleColLessEqualLongScalar vectorExpression = + new FilterDoubleColLessEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterDoubleColLessEqualLongScalarColRepeats() { + + 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); + + FilterDoubleColLessEqualLongScalar vectorExpression = + new FilterDoubleColLessEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] <= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + "<=" + + scalarValue + " 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 testFilterLongColGreaterLongScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterLongScalar vectorExpression = + new FilterLongColGreaterLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterLongColGreaterLongScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterLongScalar vectorExpression = + new FilterLongColGreaterLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterLongColGreaterLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterLongScalar vectorExpression = + new FilterLongColGreaterLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterLongColGreaterLongScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterLongScalar vectorExpression = + new FilterLongColGreaterLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterDoubleColGreaterLongScalarColNullsRepeats() { + + 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); + + FilterDoubleColGreaterLongScalar vectorExpression = + new FilterDoubleColGreaterLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterDoubleColGreaterLongScalarColNulls() { + + 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); + + FilterDoubleColGreaterLongScalar vectorExpression = + new FilterDoubleColGreaterLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterDoubleColGreaterLongScalar() { + + 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); + + FilterDoubleColGreaterLongScalar vectorExpression = + new FilterDoubleColGreaterLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterDoubleColGreaterLongScalarColRepeats() { + + 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); + + FilterDoubleColGreaterLongScalar vectorExpression = + new FilterDoubleColGreaterLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] > scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">" + + scalarValue + " 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 testFilterLongColGreaterEqualLongScalarColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterEqualLongScalar vectorExpression = + new FilterLongColGreaterEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterLongColGreaterEqualLongScalarColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterEqualLongScalar vectorExpression = + new FilterLongColGreaterEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterLongColGreaterEqualLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterEqualLongScalar vectorExpression = + new FilterLongColGreaterEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterLongColGreaterEqualLongScalarColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(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); + + FilterLongColGreaterEqualLongScalar vectorExpression = + new FilterLongColGreaterEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterDoubleColGreaterEqualLongScalarColNullsRepeats() { + + 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); + + FilterDoubleColGreaterEqualLongScalar vectorExpression = + new FilterDoubleColGreaterEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterDoubleColGreaterEqualLongScalarColNulls() { + + 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); + + FilterDoubleColGreaterEqualLongScalar vectorExpression = + new FilterDoubleColGreaterEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterDoubleColGreaterEqualLongScalar() { + + 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); + + FilterDoubleColGreaterEqualLongScalar vectorExpression = + new FilterDoubleColGreaterEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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 testFilterDoubleColGreaterEqualLongScalarColRepeats() { + + 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); + + FilterDoubleColGreaterEqualLongScalar vectorExpression = + new FilterDoubleColGreaterEqualLongScalar(0, scalarValue); + + vectorExpression.evaluate(rowBatch); + + int selectedIndex = 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 + ? BATCH_SIZE : 0; + } else { + for(int i = 0; i < BATCH_SIZE; i++) { + if(!inputColumnVector.isNull[i]) { + if(inputColumnVector.vector[i] >= scalarValue) { + assertEquals( + "Vector index that passes filter " + + inputColumnVector.vector[i] + ">=" + + scalarValue + " 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); + } + } + + +} + + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarOperationVectorExpressionEvaluation.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarOperationVectorExpressionEvaluation.java new file mode 100644 index 0000000..be0176e --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarOperationVectorExpressionEvaluation.java @@ -0,0 +1,11044 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; + +import static org.junit.Assert.assertEquals; +import java.util.Random; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil; +import org.junit.Test; + + +/** + * + * TestColumnScalarOperationVectorExpressionEvaluation. + * + */ +public class TestColumnScalarOperationVectorExpressionEvaluation{ + + private static final int BATCH_SIZE = 100; + private static final long SEED = 0xfa57; + + + @Test + public void testLongColAddLongScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColAddLongScalar vectorExpression = + new LongColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColAddLongScalar vectorExpression = + new LongColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddLongScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColAddLongScalar vectorExpression = + new LongColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddLongScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColAddLongScalar vectorExpression = + new LongColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddLongScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColAddLongScalar vectorExpression = + new LongColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColSubtractLongScalar vectorExpression = + new LongColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColSubtractLongScalar vectorExpression = + new LongColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColSubtractLongScalar vectorExpression = + new LongColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColSubtractLongScalar vectorExpression = + new LongColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractLongScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColSubtractLongScalar vectorExpression = + new LongColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColMultiplyLongScalar vectorExpression = + new LongColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColMultiplyLongScalar vectorExpression = + new LongColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColMultiplyLongScalar vectorExpression = + new LongColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColMultiplyLongScalar vectorExpression = + new LongColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyLongScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColMultiplyLongScalar vectorExpression = + new LongColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColModuloLongScalar vectorExpression = + new LongColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColModuloLongScalar vectorExpression = + new LongColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColModuloLongScalar vectorExpression = + new LongColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColModuloLongScalar vectorExpression = + new LongColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloLongScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongColModuloLongScalar vectorExpression = + new LongColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColAddDoubleScalar vectorExpression = + new LongColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColAddDoubleScalar vectorExpression = + new LongColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColAddDoubleScalar vectorExpression = + new LongColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColAddDoubleScalar vectorExpression = + new LongColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColAddDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColAddDoubleScalar vectorExpression = + new LongColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColSubtractDoubleScalar vectorExpression = + new LongColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColSubtractDoubleScalar vectorExpression = + new LongColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColSubtractDoubleScalar vectorExpression = + new LongColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColSubtractDoubleScalar vectorExpression = + new LongColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColSubtractDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColSubtractDoubleScalar vectorExpression = + new LongColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColMultiplyDoubleScalar vectorExpression = + new LongColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColMultiplyDoubleScalar vectorExpression = + new LongColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColMultiplyDoubleScalar vectorExpression = + new LongColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColMultiplyDoubleScalar vectorExpression = + new LongColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColMultiplyDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColMultiplyDoubleScalar vectorExpression = + new LongColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColDivideDoubleScalar vectorExpression = + new LongColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColDivideDoubleScalar vectorExpression = + new LongColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColDivideDoubleScalar vectorExpression = + new LongColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColDivideDoubleScalar vectorExpression = + new LongColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColDivideDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColDivideDoubleScalar vectorExpression = + new LongColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColModuloDoubleScalar vectorExpression = + new LongColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColModuloDoubleScalar vectorExpression = + new LongColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColModuloDoubleScalar vectorExpression = + new LongColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColModuloDoubleScalar vectorExpression = + new LongColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColModuloDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColModuloDoubleScalar vectorExpression = + new LongColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColAddLongScalar vectorExpression = + new DoubleColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColAddLongScalar vectorExpression = + new DoubleColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColAddLongScalar vectorExpression = + new DoubleColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColAddLongScalar vectorExpression = + new DoubleColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddLongScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColAddLongScalar vectorExpression = + new DoubleColAddLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColSubtractLongScalar vectorExpression = + new DoubleColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColSubtractLongScalar vectorExpression = + new DoubleColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColSubtractLongScalar vectorExpression = + new DoubleColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColSubtractLongScalar vectorExpression = + new DoubleColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractLongScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColSubtractLongScalar vectorExpression = + new DoubleColSubtractLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColMultiplyLongScalar vectorExpression = + new DoubleColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColMultiplyLongScalar vectorExpression = + new DoubleColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColMultiplyLongScalar vectorExpression = + new DoubleColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColMultiplyLongScalar vectorExpression = + new DoubleColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyLongScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColMultiplyLongScalar vectorExpression = + new DoubleColMultiplyLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColDivideLongScalar vectorExpression = + new DoubleColDivideLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColDivideLongScalar vectorExpression = + new DoubleColDivideLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColDivideLongScalar vectorExpression = + new DoubleColDivideLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColDivideLongScalar vectorExpression = + new DoubleColDivideLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideLongScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColDivideLongScalar vectorExpression = + new DoubleColDivideLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColModuloLongScalar vectorExpression = + new DoubleColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColModuloLongScalar vectorExpression = + new DoubleColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColModuloLongScalar vectorExpression = + new DoubleColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColModuloLongScalar vectorExpression = + new DoubleColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloLongScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + DoubleColModuloLongScalar vectorExpression = + new DoubleColModuloLongScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColAddDoubleScalar vectorExpression = + new DoubleColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColAddDoubleScalar vectorExpression = + new DoubleColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColAddDoubleScalar vectorExpression = + new DoubleColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColAddDoubleScalar vectorExpression = + new DoubleColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColAddDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColAddDoubleScalar vectorExpression = + new DoubleColAddDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColSubtractDoubleScalar vectorExpression = + new DoubleColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColSubtractDoubleScalar vectorExpression = + new DoubleColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColSubtractDoubleScalar vectorExpression = + new DoubleColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColSubtractDoubleScalar vectorExpression = + new DoubleColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColSubtractDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColSubtractDoubleScalar vectorExpression = + new DoubleColSubtractDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColMultiplyDoubleScalar vectorExpression = + new DoubleColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColMultiplyDoubleScalar vectorExpression = + new DoubleColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColMultiplyDoubleScalar vectorExpression = + new DoubleColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColMultiplyDoubleScalar vectorExpression = + new DoubleColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColMultiplyDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColMultiplyDoubleScalar vectorExpression = + new DoubleColMultiplyDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColDivideDoubleScalar vectorExpression = + new DoubleColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColDivideDoubleScalar vectorExpression = + new DoubleColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColDivideDoubleScalar vectorExpression = + new DoubleColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColDivideDoubleScalar vectorExpression = + new DoubleColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColDivideDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColDivideDoubleScalar vectorExpression = + new DoubleColDivideDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColModuloDoubleScalar vectorExpression = + new DoubleColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleScalar() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColModuloDoubleScalar vectorExpression = + new DoubleColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColModuloDoubleScalar vectorExpression = + new DoubleColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColModuloDoubleScalar vectorExpression = + new DoubleColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColModuloDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColModuloDoubleScalar vectorExpression = + new DoubleColModuloDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddLongColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddLongColumn vectorExpression = + new LongScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddLongColumn vectorExpression = + new LongScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddLongColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddLongColumn vectorExpression = + new LongScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddLongColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddLongColumn vectorExpression = + new LongScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddLongColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddLongColumn vectorExpression = + new LongScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractLongColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractLongColumn vectorExpression = + new LongScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractLongColumn vectorExpression = + new LongScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractLongColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractLongColumn vectorExpression = + new LongScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractLongColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractLongColumn vectorExpression = + new LongScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractLongColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractLongColumn vectorExpression = + new LongScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyLongColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyLongColumn vectorExpression = + new LongScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyLongColumn vectorExpression = + new LongScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyLongColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyLongColumn vectorExpression = + new LongScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyLongColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyLongColumn vectorExpression = + new LongScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyLongColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyLongColumn vectorExpression = + new LongScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloLongColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloLongColumn vectorExpression = + new LongScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloLongColumn() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloLongColumn vectorExpression = + new LongScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloLongColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloLongColumn vectorExpression = + new LongScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloLongColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloLongColumn vectorExpression = + new LongScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloLongColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloLongColumn vectorExpression = + new LongScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddDoubleColumn vectorExpression = + new LongScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddDoubleColumn vectorExpression = + new LongScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddDoubleColumn vectorExpression = + new LongScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddDoubleColumn vectorExpression = + new LongScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarAddDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarAddDoubleColumn vectorExpression = + new LongScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractDoubleColumn vectorExpression = + new LongScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractDoubleColumn vectorExpression = + new LongScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractDoubleColumn vectorExpression = + new LongScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractDoubleColumn vectorExpression = + new LongScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarSubtractDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarSubtractDoubleColumn vectorExpression = + new LongScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyDoubleColumn vectorExpression = + new LongScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyDoubleColumn vectorExpression = + new LongScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyDoubleColumn vectorExpression = + new LongScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyDoubleColumn vectorExpression = + new LongScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarMultiplyDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarMultiplyDoubleColumn vectorExpression = + new LongScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarDivideDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarDivideDoubleColumn vectorExpression = + new LongScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarDivideDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarDivideDoubleColumn vectorExpression = + new LongScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarDivideDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarDivideDoubleColumn vectorExpression = + new LongScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarDivideDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarDivideDoubleColumn vectorExpression = + new LongScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarDivideDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarDivideDoubleColumn vectorExpression = + new LongScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloDoubleColumn vectorExpression = + new LongScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloDoubleColumn vectorExpression = + new LongScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloDoubleColumn vectorExpression = + new LongScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloDoubleColumn vectorExpression = + new LongScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongScalarModuloDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + long scalarValue = 0; + do { + scalarValue = rand.nextLong(); + } while(scalarValue == 0); + + LongScalarModuloDoubleColumn vectorExpression = + new LongScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddLongColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddLongColumn vectorExpression = + new DoubleScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddLongColumn vectorExpression = + new DoubleScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddLongColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddLongColumn vectorExpression = + new DoubleScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddLongColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddLongColumn vectorExpression = + new DoubleScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddLongColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddLongColumn vectorExpression = + new DoubleScalarAddLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractLongColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractLongColumn vectorExpression = + new DoubleScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractLongColumn vectorExpression = + new DoubleScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractLongColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractLongColumn vectorExpression = + new DoubleScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractLongColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractLongColumn vectorExpression = + new DoubleScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractLongColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractLongColumn vectorExpression = + new DoubleScalarSubtractLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyLongColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyLongColumn vectorExpression = + new DoubleScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyLongColumn vectorExpression = + new DoubleScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyLongColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyLongColumn vectorExpression = + new DoubleScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyLongColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyLongColumn vectorExpression = + new DoubleScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyLongColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyLongColumn vectorExpression = + new DoubleScalarMultiplyLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideLongColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideLongColumn vectorExpression = + new DoubleScalarDivideLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideLongColumn vectorExpression = + new DoubleScalarDivideLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideLongColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideLongColumn vectorExpression = + new DoubleScalarDivideLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideLongColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideLongColumn vectorExpression = + new DoubleScalarDivideLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideLongColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideLongColumn vectorExpression = + new DoubleScalarDivideLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloLongColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloLongColumn vectorExpression = + new DoubleScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloLongColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloLongColumn vectorExpression = + new DoubleScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloLongColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloLongColumn vectorExpression = + new DoubleScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloLongColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloLongColumn vectorExpression = + new DoubleScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloLongColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloLongColumn vectorExpression = + new DoubleScalarModuloLongColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddDoubleColumn vectorExpression = + new DoubleScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddDoubleColumn vectorExpression = + new DoubleScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddDoubleColumn vectorExpression = + new DoubleScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddDoubleColumn vectorExpression = + new DoubleScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarAddDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarAddDoubleColumn vectorExpression = + new DoubleScalarAddDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractDoubleColumn vectorExpression = + new DoubleScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractDoubleColumn vectorExpression = + new DoubleScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractDoubleColumn vectorExpression = + new DoubleScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractDoubleColumn vectorExpression = + new DoubleScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarSubtractDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarSubtractDoubleColumn vectorExpression = + new DoubleScalarSubtractDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = + new DoubleScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = + new DoubleScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = + new DoubleScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = + new DoubleScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarMultiplyDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = + new DoubleScalarMultiplyDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideDoubleColumn vectorExpression = + new DoubleScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideDoubleColumn vectorExpression = + new DoubleScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideDoubleColumn vectorExpression = + new DoubleScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideDoubleColumn vectorExpression = + new DoubleScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarDivideDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarDivideDoubleColumn vectorExpression = + new DoubleScalarDivideDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloDoubleColumnOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloDoubleColumn vectorExpression = + new DoubleScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloDoubleColumn() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloDoubleColumn vectorExpression = + new DoubleScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloDoubleColumnOutNullsColNulls() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloDoubleColumn vectorExpression = + new DoubleScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloDoubleColumnOutNullsRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloDoubleColumn vectorExpression = + new DoubleScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleScalarModuloDoubleColumnOutNullsColRepeats() { + + Random rand = new Random(SEED); + + DoubleColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleScalarModuloDoubleColumn vectorExpression = + new DoubleScalarModuloDoubleColumn(scalarValue, 0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColEqualDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColEqualDoubleScalar vectorExpression = + new LongColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColEqualDoubleScalar vectorExpression = + new LongColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColEqualDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColEqualDoubleScalar vectorExpression = + new LongColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColEqualDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColEqualDoubleScalar vectorExpression = + new LongColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColEqualDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColEqualDoubleScalar vectorExpression = + new LongColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColEqualDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColEqualDoubleScalar vectorExpression = + new DoubleColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColEqualDoubleScalar vectorExpression = + new DoubleColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColEqualDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColEqualDoubleScalar vectorExpression = + new DoubleColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColEqualDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColEqualDoubleScalar vectorExpression = + new DoubleColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColEqualDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColEqualDoubleScalar vectorExpression = + new DoubleColEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColNotEqualDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColNotEqualDoubleScalar vectorExpression = + new LongColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColNotEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColNotEqualDoubleScalar vectorExpression = + new LongColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColNotEqualDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColNotEqualDoubleScalar vectorExpression = + new LongColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColNotEqualDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColNotEqualDoubleScalar vectorExpression = + new LongColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColNotEqualDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColNotEqualDoubleScalar vectorExpression = + new LongColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColNotEqualDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColNotEqualDoubleScalar vectorExpression = + new DoubleColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColNotEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColNotEqualDoubleScalar vectorExpression = + new DoubleColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColNotEqualDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColNotEqualDoubleScalar vectorExpression = + new DoubleColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColNotEqualDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColNotEqualDoubleScalar vectorExpression = + new DoubleColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColNotEqualDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColNotEqualDoubleScalar vectorExpression = + new DoubleColNotEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessDoubleScalar vectorExpression = + new LongColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessDoubleScalar vectorExpression = + new LongColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessDoubleScalar vectorExpression = + new LongColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessDoubleScalar vectorExpression = + new LongColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessDoubleScalar vectorExpression = + new LongColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessDoubleScalar vectorExpression = + new DoubleColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessDoubleScalar vectorExpression = + new DoubleColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessDoubleScalar vectorExpression = + new DoubleColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessDoubleScalar vectorExpression = + new DoubleColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessDoubleScalar vectorExpression = + new DoubleColLessDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessEqualDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessEqualDoubleScalar vectorExpression = + new LongColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessEqualDoubleScalar vectorExpression = + new LongColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessEqualDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessEqualDoubleScalar vectorExpression = + new LongColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessEqualDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessEqualDoubleScalar vectorExpression = + new LongColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColLessEqualDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColLessEqualDoubleScalar vectorExpression = + new LongColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessEqualDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessEqualDoubleScalar vectorExpression = + new DoubleColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessEqualDoubleScalar vectorExpression = + new DoubleColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessEqualDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessEqualDoubleScalar vectorExpression = + new DoubleColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessEqualDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessEqualDoubleScalar vectorExpression = + new DoubleColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColLessEqualDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColLessEqualDoubleScalar vectorExpression = + new DoubleColLessEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterDoubleScalar vectorExpression = + new LongColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterDoubleScalar vectorExpression = + new LongColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterDoubleScalar vectorExpression = + new LongColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterDoubleScalar vectorExpression = + new LongColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterDoubleScalar vectorExpression = + new LongColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterDoubleScalar vectorExpression = + new DoubleColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterDoubleScalar vectorExpression = + new DoubleColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterDoubleScalar vectorExpression = + new DoubleColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterDoubleScalar vectorExpression = + new DoubleColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterDoubleScalar vectorExpression = + new DoubleColGreaterDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterEqualDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterEqualDoubleScalar vectorExpression = + new LongColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterEqualDoubleScalar vectorExpression = + new LongColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterEqualDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterEqualDoubleScalar vectorExpression = + new LongColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterEqualDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterEqualDoubleScalar vectorExpression = + new LongColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testLongColGreaterEqualDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + LongColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + LongColGreaterEqualDoubleScalar vectorExpression = + new LongColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterEqualDoubleScalarOutRepeatsColNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = + new DoubleColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterEqualDoubleScalar() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(false, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = + new DoubleColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterEqualDoubleScalarOutNullsColNulls() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(true, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = + new DoubleColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterEqualDoubleScalarOutNullsRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + true, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + false, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = + new DoubleColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + @Test + public void testDoubleColGreaterEqualDoubleScalarOutNullsColRepeats() { + + Random rand = new Random(SEED); + + LongColumnVector outputColumnVector = + VectorizedRowGroupGenUtil.generateLongColumnVector(true, + false, BATCH_SIZE, rand); + + DoubleColumnVector inputColumnVector = + VectorizedRowGroupGenUtil.generateDoubleColumnVector(false, + true, BATCH_SIZE, rand); + + VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE); + rowBatch.cols[0] = inputColumnVector; + rowBatch.cols[1] = outputColumnVector; + + double scalarValue = 0; + do { + scalarValue = rand.nextDouble(); + } while(scalarValue == 0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = + new DoubleColGreaterEqualDoubleScalar(0, scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector is repeating state does not match operand column", + inputColumnVector.isRepeating, outputColumnVector.isRepeating); + + assertEquals( + "Output column vector no nulls state does not match operand column", + inputColumnVector.noNulls, outputColumnVector.noNulls); + + 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 + assertEquals("Output vector doesn't match input vector's is null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + } + } + + +} + + diff --git ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/VectorizedRowGroupGenUtil.java ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/VectorizedRowGroupGenUtil.java index 8a07567..9aad077 100644 --- ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/VectorizedRowGroupGenUtil.java +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/util/VectorizedRowGroupGenUtil.java @@ -18,11 +18,18 @@ package org.apache.hadoop.hive.ql.exec.vector.util; +import java.util.Random; + +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; + public class VectorizedRowGroupGenUtil { + private static final long LONG_VECTOR_NULL_VALUE = 1; + private static final double DOUBLE_VECTOR_NULL_VALUE = Double.NaN; + public static VectorizedRowBatch getVectorizedRowBatch(int size, int numCol, int seed) { VectorizedRowBatch vrg = new VectorizedRowBatch(numCol, size); for (int j = 0; j < numCol; j++) { @@ -35,4 +42,71 @@ public static VectorizedRowBatch getVectorizedRowBatch(int size, int numCol, int vrg.size = size; return vrg; } + + public static LongColumnVector generateLongColumnVector( + boolean nulls, boolean repeating, int size, Random rand) { + LongColumnVector lcv = new LongColumnVector(size); + + lcv.noNulls = !nulls; + lcv.isRepeating = repeating; + + long repeatingValue; + do{ + repeatingValue= rand.nextLong(); + }while(repeatingValue == 0); + + int nullFrequency = generateNullFrequency(rand); + + for(int i = 0; i < size; i++) { + if(nulls && (repeating || i % nullFrequency == 0)) { + lcv.isNull[i] = true; + lcv.vector[i] = LONG_VECTOR_NULL_VALUE; + + }else { + lcv.isNull[i] = false; + lcv.vector[i] = repeating ? repeatingValue : rand.nextLong(); + if(lcv.vector[i] == 0) { + i--; + } + } + } + return lcv; + } + + public static DoubleColumnVector generateDoubleColumnVector( + boolean nulls, boolean repeating, int size, Random rand) + { + DoubleColumnVector dcv = new DoubleColumnVector(size); + + dcv.noNulls = !nulls; + dcv.isRepeating = repeating; + + double repeatingValue; + do{ + repeatingValue= rand.nextDouble(); + }while(repeatingValue == 0); + + int nullFrequency = generateNullFrequency(rand); + + for(int i = 0; i < size; i++) { + if(nulls && (repeating || i % nullFrequency == 0)) { + dcv.isNull[i] = true; + dcv.vector[i] = DOUBLE_VECTOR_NULL_VALUE; + + }else { + dcv.isNull[i] = false; + dcv.vector[i] = repeating ? repeatingValue : rand.nextDouble(); + + if(dcv.vector[i] == 0) { + i--; + } + } + } + return dcv; + } + + private static int generateNullFrequency(Random rand) { + return 60 + rand.nextInt(20); + } + } -- 1.8.0.msysgit.0