hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From omal...@apache.org
Subject svn commit: r1485421 [5/6] - in /hive/branches/vectorization/ql/src: java/org/apache/hadoop/hive/ql/exec/vector/expressions/templates/ test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/ test/org/apache/hadoop/hive/ql/exec/vector/util/
Date Wed, 22 May 2013 21:04:35 GMT
Added: hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarOperationVectorExpressionEvaluation.java
URL: http://svn.apache.org/viewvc/hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarOperationVectorExpressionEvaluation.java?rev=1485421&view=auto
==============================================================================
--- hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarOperationVectorExpressionEvaluation.java (added)
+++ hive/branches/vectorization/ql/src/test/org/apache/hadoop/hive/ql/exec/vector/expressions/gen/TestColumnScalarOperationVectorExpressionEvaluation.java Wed May 22 21:04:35 2013
@@ -0,0 +1,11044 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+
+import static org.junit.Assert.assertEquals;
+import java.util.Random;
+import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector;
+import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector;
+import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
+import org.apache.hadoop.hive.ql.exec.vector.util.VectorizedRowGroupGenUtil;
+import org.junit.Test;
+
+
+/**
+ *
+ * TestColumnScalarOperationVectorExpressionEvaluation.
+ *
+ */
+public class TestColumnScalarOperationVectorExpressionEvaluation{
+
+  private static final int BATCH_SIZE = 100;
+  private static final long SEED = 0xfa57;
+
+  
+  @Test
+  public void testLongColAddLongScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColAddLongScalar vectorExpression =
+      new LongColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColAddLongScalar() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColAddLongScalar vectorExpression =
+      new LongColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColAddLongScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColAddLongScalar vectorExpression =
+      new LongColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColAddLongScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColAddLongScalar vectorExpression =
+      new LongColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColAddLongScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColAddLongScalar vectorExpression =
+      new LongColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractLongScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColSubtractLongScalar vectorExpression =
+      new LongColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractLongScalar() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColSubtractLongScalar vectorExpression =
+      new LongColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractLongScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColSubtractLongScalar vectorExpression =
+      new LongColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractLongScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColSubtractLongScalar vectorExpression =
+      new LongColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractLongScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColSubtractLongScalar vectorExpression =
+      new LongColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyLongScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColMultiplyLongScalar vectorExpression =
+      new LongColMultiplyLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyLongScalar() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColMultiplyLongScalar vectorExpression =
+      new LongColMultiplyLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyLongScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColMultiplyLongScalar vectorExpression =
+      new LongColMultiplyLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyLongScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColMultiplyLongScalar vectorExpression =
+      new LongColMultiplyLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyLongScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColMultiplyLongScalar vectorExpression =
+      new LongColMultiplyLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloLongScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColModuloLongScalar vectorExpression =
+      new LongColModuloLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloLongScalar() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColModuloLongScalar vectorExpression =
+      new LongColModuloLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloLongScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColModuloLongScalar vectorExpression =
+      new LongColModuloLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloLongScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColModuloLongScalar vectorExpression =
+      new LongColModuloLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloLongScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    LongColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    LongColModuloLongScalar vectorExpression =
+      new LongColModuloLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColAddDoubleScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColAddDoubleScalar vectorExpression =
+      new LongColAddDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColAddDoubleScalar() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColAddDoubleScalar vectorExpression =
+      new LongColAddDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColAddDoubleScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColAddDoubleScalar vectorExpression =
+      new LongColAddDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColAddDoubleScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColAddDoubleScalar vectorExpression =
+      new LongColAddDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColAddDoubleScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColAddDoubleScalar vectorExpression =
+      new LongColAddDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractDoubleScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColSubtractDoubleScalar vectorExpression =
+      new LongColSubtractDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractDoubleScalar() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColSubtractDoubleScalar vectorExpression =
+      new LongColSubtractDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractDoubleScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColSubtractDoubleScalar vectorExpression =
+      new LongColSubtractDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractDoubleScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColSubtractDoubleScalar vectorExpression =
+      new LongColSubtractDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColSubtractDoubleScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColSubtractDoubleScalar vectorExpression =
+      new LongColSubtractDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyDoubleScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColMultiplyDoubleScalar vectorExpression =
+      new LongColMultiplyDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyDoubleScalar() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColMultiplyDoubleScalar vectorExpression =
+      new LongColMultiplyDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyDoubleScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColMultiplyDoubleScalar vectorExpression =
+      new LongColMultiplyDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyDoubleScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColMultiplyDoubleScalar vectorExpression =
+      new LongColMultiplyDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColMultiplyDoubleScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColMultiplyDoubleScalar vectorExpression =
+      new LongColMultiplyDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColDivideDoubleScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColDivideDoubleScalar vectorExpression =
+      new LongColDivideDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColDivideDoubleScalar() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColDivideDoubleScalar vectorExpression =
+      new LongColDivideDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColDivideDoubleScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColDivideDoubleScalar vectorExpression =
+      new LongColDivideDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColDivideDoubleScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColDivideDoubleScalar vectorExpression =
+      new LongColDivideDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColDivideDoubleScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColDivideDoubleScalar vectorExpression =
+      new LongColDivideDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloDoubleScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColModuloDoubleScalar vectorExpression =
+      new LongColModuloDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloDoubleScalar() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColModuloDoubleScalar vectorExpression =
+      new LongColModuloDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloDoubleScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColModuloDoubleScalar vectorExpression =
+      new LongColModuloDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloDoubleScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColModuloDoubleScalar vectorExpression =
+      new LongColModuloDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testLongColModuloDoubleScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    LongColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateLongColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    double scalarValue = 0;
+    do {
+      scalarValue = rand.nextDouble();
+    } while(scalarValue == 0);
+
+    LongColModuloDoubleScalar vectorExpression =
+      new LongColModuloDoubleScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColAddLongScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColAddLongScalar vectorExpression =
+      new DoubleColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColAddLongScalar() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColAddLongScalar vectorExpression =
+      new DoubleColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColAddLongScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColAddLongScalar vectorExpression =
+      new DoubleColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColAddLongScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColAddLongScalar vectorExpression =
+      new DoubleColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColAddLongScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColAddLongScalar vectorExpression =
+      new DoubleColAddLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColSubtractLongScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColSubtractLongScalar vectorExpression =
+      new DoubleColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColSubtractLongScalar() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColSubtractLongScalar vectorExpression =
+      new DoubleColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColSubtractLongScalarOutNullsColNulls() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColSubtractLongScalar vectorExpression =
+      new DoubleColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColSubtractLongScalarOutNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      false, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColSubtractLongScalar vectorExpression =
+      new DoubleColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColSubtractLongScalarOutNullsColRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      false, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColSubtractLongScalar vectorExpression =
+      new DoubleColSubtractLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColMultiplyLongScalarOutRepeatsColNullsRepeats() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,
+      true, BATCH_SIZE, rand);
+
+    DoubleColumnVector inputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(true,
+      true, BATCH_SIZE, rand);
+
+    VectorizedRowBatch rowBatch = new VectorizedRowBatch(2, BATCH_SIZE);
+    rowBatch.cols[0] = inputColumnVector;
+    rowBatch.cols[1] = outputColumnVector;
+
+    long scalarValue = 0;
+    do {
+      scalarValue = rand.nextLong();
+    } while(scalarValue == 0);
+
+    DoubleColMultiplyLongScalar vectorExpression =
+      new DoubleColMultiplyLongScalar(0, scalarValue, 1);
+
+    vectorExpression.evaluate(rowBatch);
+
+    assertEquals(
+      "Output column vector is repeating state does not match operand column",
+      inputColumnVector.isRepeating, outputColumnVector.isRepeating);
+
+    assertEquals(
+      "Output column vector no nulls state does not match operand column",
+      inputColumnVector.noNulls, outputColumnVector.noNulls);
+
+    if(!outputColumnVector.noNulls && !outputColumnVector.isRepeating) {
+      for(int i = 0; i < BATCH_SIZE; i++) {
+        //null vectors are safe to check, as they are always initialized to match the data vector
+        assertEquals("Output vector doesn't match input vector's is null state for index",
+          inputColumnVector.isNull[i], outputColumnVector.isNull[i]);
+      }
+    }
+  }
+
+  @Test
+  public void testDoubleColMultiplyLongScalar() {
+
+    Random rand = new Random(SEED);
+
+    DoubleColumnVector outputColumnVector =
+      VectorizedRowGroupGenUtil.generateDoubleColumnVector(false,

[... 8534 lines stripped ...]


Mime
View raw message