commit 979f13cc30e9cc3308193ec66a677593bdbc0fc7 Author: Tony Murphy Date: Mon May 13 16:26:29 2013 -0700 Column Column and Column Scalar vector evaluation unit tests 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..bbf4a58 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestClass.txt @@ -0,0 +1,41 @@ +/** + * 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 org.junit.Test; + +import java.util.Random; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.*; +import org.apache.hadoop.hive.ql.exec.vector.*; +import org.apache.hadoop.hive.ql.exec.vector.util.*; + + +public class { + + private static final int BATCH_SIZE=1000; + private static final long SEED=0xfa57; + + //private final ScriptEngineManager mgr = new ScriptEngineManager(); + //private final ScriptEngine engine = mgr.getEngineByName("JavaScript"); + + + +} 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..0d976a3 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestCodeGen.java @@ -0,0 +1,187 @@ +package org.apache.hadoop.hive.ql.exec.vector.expressions.templates; + +import java.io.IOException; +import java.util.HashMap; + +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 = CodeGen.readFile(templateFile); + + for(Boolean[] testMatrix : new Boolean[][]{ + {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("", 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 = CodeGen.readFile(templateFile); + + for(Boolean[] testMatrix : new Boolean[][]{ + {true,true}, + {true,false}, + {false,false}, + {false,true} + }) + { + String testCase = templateString; + 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,1"); + } + + 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 = CodeGen.readFile(templateFile); + + for(Boolean[] testMatrix : new Boolean[][]{ + {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("", 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 = CodeGen.readFile(templateFile); + + for(Boolean[] testMatrix : new Boolean[][]{ + {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("", 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{ + + for(TestSuiteClassName testClass : testsuites.keySet()) + { + String templateFile = CodeGen.joinPath(this.templateDirectory, "TestClass.txt"); + 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); + } + + } +} 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..ba01b18 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnFilterVectorExpressionEvaluation.txt @@ -0,0 +1,50 @@ + + @Test + public void Test_Col1Nulls__Col1Repeating__Col2Nulls__Col2Repeating_() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + 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..cccad3a --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnColumnOperationVectorExpressionEvaluation.txt @@ -0,0 +1,40 @@ + + @Test + public void Test_InitOutNulls__InitOutIsRepeating__Col1Nulls__Col1Repeating__Col2Nulls__Col2Repeating_() { + + 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 column", + && , rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + || , !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + 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..de1bc67 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarFilterVectorExpressionEvaluation.txt @@ -0,0 +1,50 @@ + + @Test + public void Test_ColNulls__ColRepeating_() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + 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..0bd4e60 --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/TestColumnScalarOperationVectorExpressionEvaluation.txt @@ -0,0 +1,41 @@ + + @Test + public void Test_InitOutNulls__InitOutIsRepeating__ColNulls__ColRepeating_() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + scalarValue=0; + do{ + scalarValue = rand.next(); + }while(scalarValue==0); + + vectorExpression = new (, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + , rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + , !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + 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..1743e0a --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnFilterVectorExpressionEvaluation.java @@ -0,0 +1,6041 @@ +/** + * 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 org.junit.Test; + +import java.util.Random; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.*; +import org.apache.hadoop.hive.ql.exec.vector.*; +import org.apache.hadoop.hive.ql.exec.vector.util.*; + + +public class TestColumnColumnFilterVectorExpressionEvaluation{ + + private static final int BATCH_SIZE=1000; + private static final long SEED=0xfa57; + + //private final ScriptEngineManager mgr = new ScriptEngineManager(); + //private final ScriptEngine engine = mgr.getEngineByName("JavaScript"); + + + @Test + public void TestFilterLongColEqualDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColEqualDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColEqualDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualDoubleColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualDoubleColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualDoubleColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualDoubleColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColEqualLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColEqualLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColEqualLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColNotEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColNotEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColLessEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColLessEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterLongColGreaterEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualLongColumn_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualLongColumn_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualLongColumn_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + + } + + + @Test + public void TestFilterDoubleColGreaterEqualLongColumn_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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++) + { + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + 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..7f3a2b2 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnColumnOperationVectorExpressionEvaluation.java @@ -0,0 +1,4841 @@ +/** + * 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 org.junit.Test; + +import java.util.Random; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.*; +import org.apache.hadoop.hive.ql.exec.vector.*; +import org.apache.hadoop.hive.ql.exec.vector.util.*; + + +public class TestColumnColumnOperationVectorExpressionEvaluation{ + + private static final int BATCH_SIZE=1000; + private static final long SEED=0xfa57; + + //private final ScriptEngineManager mgr = new ScriptEngineManager(); + //private final ScriptEngine engine = mgr.getEngineByName("JavaScript"); + + + @Test + public void TestLongColAddLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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; + + LongColDivideLongColumn vectorExpression = new LongColDivideLongColumn(0,1,2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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; + + LongColDivideLongColumn vectorExpression = new LongColDivideLongColumn(0,1,2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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; + + LongColDivideLongColumn vectorExpression = new LongColDivideLongColumn(0,1,2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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; + + LongColDivideLongColumn vectorExpression = new LongColDivideLongColumn(0,1,2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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; + + LongColDivideLongColumn vectorExpression = new LongColDivideLongColumn(0,1,2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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; + + LongColDivideLongColumn vectorExpression = new LongColDivideLongColumn(0,1,2); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + true && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + false && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_Col1Nulls_true_Col1Repeating_false_Col2Nulls_true_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_Col1Nulls_true_Col1Repeating_true_Col2Nulls_false_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_Col1Nulls_false_Col1Repeating_true_Col2Nulls_true_Col2Repeating_false() { + + 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 column", + true && false, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || true, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector1.isNull[i] || inputColumnVector2.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_Col1Nulls_false_Col1Repeating_false_Col2Nulls_false_Col2Repeating_true() { + + 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 column", + false && true, rowBatch.cols[2].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false || false, !rowBatch.cols[2].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's 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..e09a0cc --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarFilterVectorExpressionEvaluation.java @@ -0,0 +1,4841 @@ +/** + * 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 org.junit.Test; + +import java.util.Random; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.*; +import org.apache.hadoop.hive.ql.exec.vector.*; +import org.apache.hadoop.hive.ql.exec.vector.util.*; + + +public class TestColumnScalarFilterVectorExpressionEvaluation{ + + private static final int BATCH_SIZE=1000; + private static final long SEED=0xfa57; + + //private final ScriptEngineManager mgr = new ScriptEngineManager(); + //private final ScriptEngine engine = mgr.getEngineByName("JavaScript"); + + + @Test + public void TestFilterLongColEqualDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColEqualDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColEqualDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColEqualDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColEqualDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColEqualDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColEqualDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColEqualDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColNotEqualDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColNotEqualDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColNotEqualDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColNotEqualDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColNotEqualDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColNotEqualDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColNotEqualDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColNotEqualDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessEqualDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessEqualDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessEqualDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessEqualDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessEqualDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessEqualDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessEqualDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessEqualDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterEqualDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterEqualDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterEqualDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterEqualDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterEqualDoubleScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterEqualDoubleScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterEqualDoubleScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterEqualDoubleScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColEqualLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColEqualLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColEqualLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColEqualLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColEqualLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColEqualLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColEqualLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColEqualLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColNotEqualLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColNotEqualLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColNotEqualLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColNotEqualLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColNotEqualLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColNotEqualLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColNotEqualLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColNotEqualLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessEqualLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessEqualLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessEqualLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColLessEqualLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessEqualLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessEqualLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessEqualLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColLessEqualLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterEqualLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterEqualLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterEqualLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterLongColGreaterEqualLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterEqualLongScalar_ColNulls_true_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterEqualLongScalar_ColNulls_true_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterEqualLongScalar_ColNulls_false_ColRepeating_false() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + false, rowBatch.selectedInUse); + } + } + + + @Test + public void TestFilterDoubleColGreaterEqualLongScalar_ColNulls_false_ColRepeating_true() { + + 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; + 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++; + } + } + } + + if(selectedIndex > 0) + { + assertEquals("Selected in use not set when some rows are selected", + true, rowBatch.selectedInUse); + + assertEquals("Row batch size not set to number of selected rows", + selectedIndex ,rowBatch.size); + }else + { + assertEquals("Selected in use set when no rows are selected", + 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..09fff31 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarOperationVectorExpressionEvaluation.java @@ -0,0 +1,10701 @@ +/** + * 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 org.junit.Test; + +import java.util.Random; + +import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.*; +import org.apache.hadoop.hive.ql.exec.vector.*; +import org.apache.hadoop.hive.ql.exec.vector.util.*; + + +public class TestColumnScalarOperationVectorExpressionEvaluation{ + + private static final int BATCH_SIZE=1000; + private static final long SEED=0xfa57; + + //private final ScriptEngineManager mgr = new ScriptEngineManager(); + //private final ScriptEngine engine = mgr.getEngineByName("JavaScript"); + + + @Test + public void TestLongColAddLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColAddLongScalar vectorExpression = new LongColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColAddLongScalar vectorExpression = new LongColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColAddLongScalar vectorExpression = new LongColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColAddLongScalar vectorExpression = new LongColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColAddLongScalar vectorExpression = new LongColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColSubtractLongScalar vectorExpression = new LongColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColSubtractLongScalar vectorExpression = new LongColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColSubtractLongScalar vectorExpression = new LongColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColSubtractLongScalar vectorExpression = new LongColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColSubtractLongScalar vectorExpression = new LongColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColMultiplyLongScalar vectorExpression = new LongColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColMultiplyLongScalar vectorExpression = new LongColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColMultiplyLongScalar vectorExpression = new LongColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColMultiplyLongScalar vectorExpression = new LongColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColMultiplyLongScalar vectorExpression = new LongColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColDivideLongScalar vectorExpression = new LongColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColDivideLongScalar vectorExpression = new LongColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColDivideLongScalar vectorExpression = new LongColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColDivideLongScalar vectorExpression = new LongColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColDivideLongScalar vectorExpression = new LongColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColModuloLongScalar vectorExpression = new LongColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColModuloLongScalar vectorExpression = new LongColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColModuloLongScalar vectorExpression = new LongColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColModuloLongScalar vectorExpression = new LongColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongColModuloLongScalar vectorExpression = new LongColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColAddDoubleScalar vectorExpression = new LongColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColAddDoubleScalar vectorExpression = new LongColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColAddDoubleScalar vectorExpression = new LongColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColAddDoubleScalar vectorExpression = new LongColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColAddDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColAddDoubleScalar vectorExpression = new LongColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColSubtractDoubleScalar vectorExpression = new LongColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColSubtractDoubleScalar vectorExpression = new LongColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColSubtractDoubleScalar vectorExpression = new LongColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColSubtractDoubleScalar vectorExpression = new LongColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColSubtractDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColSubtractDoubleScalar vectorExpression = new LongColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColMultiplyDoubleScalar vectorExpression = new LongColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColMultiplyDoubleScalar vectorExpression = new LongColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColMultiplyDoubleScalar vectorExpression = new LongColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColMultiplyDoubleScalar vectorExpression = new LongColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColMultiplyDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColMultiplyDoubleScalar vectorExpression = new LongColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColDivideDoubleScalar vectorExpression = new LongColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColDivideDoubleScalar vectorExpression = new LongColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColDivideDoubleScalar vectorExpression = new LongColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColDivideDoubleScalar vectorExpression = new LongColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColDivideDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColDivideDoubleScalar vectorExpression = new LongColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColModuloDoubleScalar vectorExpression = new LongColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColModuloDoubleScalar vectorExpression = new LongColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColModuloDoubleScalar vectorExpression = new LongColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColModuloDoubleScalar vectorExpression = new LongColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColModuloDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColModuloDoubleScalar vectorExpression = new LongColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColAddLongScalar vectorExpression = new DoubleColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColAddLongScalar vectorExpression = new DoubleColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColAddLongScalar vectorExpression = new DoubleColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColAddLongScalar vectorExpression = new DoubleColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColAddLongScalar vectorExpression = new DoubleColAddLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColSubtractLongScalar vectorExpression = new DoubleColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColSubtractLongScalar vectorExpression = new DoubleColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColSubtractLongScalar vectorExpression = new DoubleColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColSubtractLongScalar vectorExpression = new DoubleColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColSubtractLongScalar vectorExpression = new DoubleColSubtractLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColMultiplyLongScalar vectorExpression = new DoubleColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColMultiplyLongScalar vectorExpression = new DoubleColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColMultiplyLongScalar vectorExpression = new DoubleColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColMultiplyLongScalar vectorExpression = new DoubleColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColMultiplyLongScalar vectorExpression = new DoubleColMultiplyLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColDivideLongScalar vectorExpression = new DoubleColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColDivideLongScalar vectorExpression = new DoubleColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColDivideLongScalar vectorExpression = new DoubleColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColDivideLongScalar vectorExpression = new DoubleColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColDivideLongScalar vectorExpression = new DoubleColDivideLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColModuloLongScalar vectorExpression = new DoubleColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColModuloLongScalar vectorExpression = new DoubleColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColModuloLongScalar vectorExpression = new DoubleColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColModuloLongScalar vectorExpression = new DoubleColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloLongScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + DoubleColModuloLongScalar vectorExpression = new DoubleColModuloLongScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColAddDoubleScalar vectorExpression = new DoubleColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColAddDoubleScalar vectorExpression = new DoubleColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColAddDoubleScalar vectorExpression = new DoubleColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColAddDoubleScalar vectorExpression = new DoubleColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColAddDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColAddDoubleScalar vectorExpression = new DoubleColAddDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColSubtractDoubleScalar vectorExpression = new DoubleColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColSubtractDoubleScalar vectorExpression = new DoubleColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColSubtractDoubleScalar vectorExpression = new DoubleColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColSubtractDoubleScalar vectorExpression = new DoubleColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColSubtractDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColSubtractDoubleScalar vectorExpression = new DoubleColSubtractDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColMultiplyDoubleScalar vectorExpression = new DoubleColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColMultiplyDoubleScalar vectorExpression = new DoubleColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColMultiplyDoubleScalar vectorExpression = new DoubleColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColMultiplyDoubleScalar vectorExpression = new DoubleColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColMultiplyDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColMultiplyDoubleScalar vectorExpression = new DoubleColMultiplyDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColDivideDoubleScalar vectorExpression = new DoubleColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColDivideDoubleScalar vectorExpression = new DoubleColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColDivideDoubleScalar vectorExpression = new DoubleColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColDivideDoubleScalar vectorExpression = new DoubleColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColDivideDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColDivideDoubleScalar vectorExpression = new DoubleColDivideDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColModuloDoubleScalar vectorExpression = new DoubleColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColModuloDoubleScalar vectorExpression = new DoubleColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColModuloDoubleScalar vectorExpression = new DoubleColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColModuloDoubleScalar vectorExpression = new DoubleColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColModuloDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColModuloDoubleScalar vectorExpression = new DoubleColModuloDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddLongColumn vectorExpression = new LongScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddLongColumn vectorExpression = new LongScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddLongColumn vectorExpression = new LongScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddLongColumn vectorExpression = new LongScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddLongColumn vectorExpression = new LongScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractLongColumn vectorExpression = new LongScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractLongColumn vectorExpression = new LongScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractLongColumn vectorExpression = new LongScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractLongColumn vectorExpression = new LongScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractLongColumn vectorExpression = new LongScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyLongColumn vectorExpression = new LongScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyLongColumn vectorExpression = new LongScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyLongColumn vectorExpression = new LongScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyLongColumn vectorExpression = new LongScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyLongColumn vectorExpression = new LongScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideLongColumn vectorExpression = new LongScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideLongColumn vectorExpression = new LongScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideLongColumn vectorExpression = new LongScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideLongColumn vectorExpression = new LongScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideLongColumn vectorExpression = new LongScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloLongColumn vectorExpression = new LongScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloLongColumn vectorExpression = new LongScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloLongColumn vectorExpression = new LongScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloLongColumn vectorExpression = new LongScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloLongColumn vectorExpression = new LongScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddDoubleColumn vectorExpression = new LongScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddDoubleColumn vectorExpression = new LongScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddDoubleColumn vectorExpression = new LongScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddDoubleColumn vectorExpression = new LongScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarAddDoubleColumn vectorExpression = new LongScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractDoubleColumn vectorExpression = new LongScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractDoubleColumn vectorExpression = new LongScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractDoubleColumn vectorExpression = new LongScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractDoubleColumn vectorExpression = new LongScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarSubtractDoubleColumn vectorExpression = new LongScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyDoubleColumn vectorExpression = new LongScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyDoubleColumn vectorExpression = new LongScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyDoubleColumn vectorExpression = new LongScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyDoubleColumn vectorExpression = new LongScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarMultiplyDoubleColumn vectorExpression = new LongScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideDoubleColumn vectorExpression = new LongScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideDoubleColumn vectorExpression = new LongScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideDoubleColumn vectorExpression = new LongScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideDoubleColumn vectorExpression = new LongScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarDivideDoubleColumn vectorExpression = new LongScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloDoubleColumn vectorExpression = new LongScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloDoubleColumn vectorExpression = new LongScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloDoubleColumn vectorExpression = new LongScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloDoubleColumn vectorExpression = new LongScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongScalarModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + long scalarValue=0; + do{ + scalarValue = rand.nextLong(); + }while(scalarValue==0); + + LongScalarModuloDoubleColumn vectorExpression = new LongScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddLongColumn vectorExpression = new DoubleScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddLongColumn vectorExpression = new DoubleScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddLongColumn vectorExpression = new DoubleScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddLongColumn vectorExpression = new DoubleScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddLongColumn vectorExpression = new DoubleScalarAddLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractLongColumn vectorExpression = new DoubleScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractLongColumn vectorExpression = new DoubleScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractLongColumn vectorExpression = new DoubleScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractLongColumn vectorExpression = new DoubleScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractLongColumn vectorExpression = new DoubleScalarSubtractLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyLongColumn vectorExpression = new DoubleScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyLongColumn vectorExpression = new DoubleScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyLongColumn vectorExpression = new DoubleScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyLongColumn vectorExpression = new DoubleScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyLongColumn vectorExpression = new DoubleScalarMultiplyLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideLongColumn vectorExpression = new DoubleScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideLongColumn vectorExpression = new DoubleScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideLongColumn vectorExpression = new DoubleScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideLongColumn vectorExpression = new DoubleScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideLongColumn vectorExpression = new DoubleScalarDivideLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloLongColumn vectorExpression = new DoubleScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloLongColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloLongColumn vectorExpression = new DoubleScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloLongColumn vectorExpression = new DoubleScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloLongColumn vectorExpression = new DoubleScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloLongColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloLongColumn vectorExpression = new DoubleScalarModuloLongColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddDoubleColumn vectorExpression = new DoubleScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddDoubleColumn vectorExpression = new DoubleScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddDoubleColumn vectorExpression = new DoubleScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddDoubleColumn vectorExpression = new DoubleScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarAddDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarAddDoubleColumn vectorExpression = new DoubleScalarAddDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractDoubleColumn vectorExpression = new DoubleScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractDoubleColumn vectorExpression = new DoubleScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractDoubleColumn vectorExpression = new DoubleScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractDoubleColumn vectorExpression = new DoubleScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarSubtractDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarSubtractDoubleColumn vectorExpression = new DoubleScalarSubtractDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = new DoubleScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = new DoubleScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = new DoubleScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = new DoubleScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarMultiplyDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarMultiplyDoubleColumn vectorExpression = new DoubleScalarMultiplyDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideDoubleColumn vectorExpression = new DoubleScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideDoubleColumn vectorExpression = new DoubleScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideDoubleColumn vectorExpression = new DoubleScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideDoubleColumn vectorExpression = new DoubleScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarDivideDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarDivideDoubleColumn vectorExpression = new DoubleScalarDivideDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloDoubleColumn vectorExpression = new DoubleScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloDoubleColumn_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloDoubleColumn vectorExpression = new DoubleScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloDoubleColumn vectorExpression = new DoubleScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloDoubleColumn vectorExpression = new DoubleScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleScalarModuloDoubleColumn_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleScalarModuloDoubleColumn vectorExpression = new DoubleScalarModuloDoubleColumn(scalarValue,0, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColEqualDoubleScalar vectorExpression = new LongColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColEqualDoubleScalar vectorExpression = new LongColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColEqualDoubleScalar vectorExpression = new LongColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColEqualDoubleScalar vectorExpression = new LongColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColEqualDoubleScalar vectorExpression = new LongColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColEqualDoubleScalar vectorExpression = new DoubleColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColEqualDoubleScalar vectorExpression = new DoubleColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColEqualDoubleScalar vectorExpression = new DoubleColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColEqualDoubleScalar vectorExpression = new DoubleColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColEqualDoubleScalar vectorExpression = new DoubleColEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColNotEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColNotEqualDoubleScalar vectorExpression = new LongColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColNotEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColNotEqualDoubleScalar vectorExpression = new LongColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColNotEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColNotEqualDoubleScalar vectorExpression = new LongColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColNotEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColNotEqualDoubleScalar vectorExpression = new LongColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColNotEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColNotEqualDoubleScalar vectorExpression = new LongColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColNotEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColNotEqualDoubleScalar vectorExpression = new DoubleColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColNotEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColNotEqualDoubleScalar vectorExpression = new DoubleColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColNotEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColNotEqualDoubleScalar vectorExpression = new DoubleColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColNotEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColNotEqualDoubleScalar vectorExpression = new DoubleColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColNotEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColNotEqualDoubleScalar vectorExpression = new DoubleColNotEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessDoubleScalar vectorExpression = new LongColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessDoubleScalar vectorExpression = new LongColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessDoubleScalar vectorExpression = new LongColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessDoubleScalar vectorExpression = new LongColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessDoubleScalar vectorExpression = new LongColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessDoubleScalar vectorExpression = new DoubleColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessDoubleScalar vectorExpression = new DoubleColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessDoubleScalar vectorExpression = new DoubleColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessDoubleScalar vectorExpression = new DoubleColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessDoubleScalar vectorExpression = new DoubleColLessDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessEqualDoubleScalar vectorExpression = new LongColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessEqualDoubleScalar vectorExpression = new LongColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessEqualDoubleScalar vectorExpression = new LongColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessEqualDoubleScalar vectorExpression = new LongColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColLessEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColLessEqualDoubleScalar vectorExpression = new LongColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessEqualDoubleScalar vectorExpression = new DoubleColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessEqualDoubleScalar vectorExpression = new DoubleColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessEqualDoubleScalar vectorExpression = new DoubleColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessEqualDoubleScalar vectorExpression = new DoubleColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColLessEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColLessEqualDoubleScalar vectorExpression = new DoubleColLessEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterDoubleScalar vectorExpression = new LongColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterDoubleScalar vectorExpression = new LongColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterDoubleScalar vectorExpression = new LongColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterDoubleScalar vectorExpression = new LongColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterDoubleScalar vectorExpression = new LongColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterDoubleScalar vectorExpression = new DoubleColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterDoubleScalar vectorExpression = new DoubleColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterDoubleScalar vectorExpression = new DoubleColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterDoubleScalar vectorExpression = new DoubleColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterDoubleScalar vectorExpression = new DoubleColGreaterDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterEqualDoubleScalar vectorExpression = new LongColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterEqualDoubleScalar vectorExpression = new LongColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterEqualDoubleScalar vectorExpression = new LongColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterEqualDoubleScalar vectorExpression = new LongColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestLongColGreaterEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + LongColGreaterEqualDoubleScalar vectorExpression = new LongColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_true_ColNulls_true_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = new DoubleColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterEqualDoubleScalar_InitOutNulls_false_InitOutIsRepeating_false_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = new DoubleColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_true_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = new DoubleColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + true, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_true_ColNulls_false_ColRepeating_false() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = new DoubleColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + false, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's null state for index", + inputColumnVector.isNull[i], outputColumnVector.isNull[i]); + } + + } + + + @Test + public void TestDoubleColGreaterEqualDoubleScalar_InitOutNulls_true_InitOutIsRepeating_false_ColNulls_false_ColRepeating_true() { + + 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[1] = outputColumnVector; + rowBatch.cols[0] = inputColumnVector; + + double scalarValue=0; + do{ + scalarValue = rand.nextDouble(); + }while(scalarValue==0); + + DoubleColGreaterEqualDoubleScalar vectorExpression = new DoubleColGreaterEqualDoubleScalar(0,scalarValue, 1); + + vectorExpression.evaluate(rowBatch); + + assertEquals( + "Output column vector repeating state does not match operand column", + true, rowBatch.cols[1].isRepeating); + + assertEquals( + "Output column vector nulls state does not match operand column", + false, !rowBatch.cols[1].noNulls); + + for(int i = 0; i < BATCH_SIZE; i++) + { + assertEquals("Output vector doesn't match input vector's 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..ca0f664 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,77 @@ 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 = generateNullFreqency(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 = generateNullFreqency(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 generateNullFreqency(Random rand) + { + return 60 + rand.nextInt(20); + } + }