quickstep-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sp...@apache.org
Subject [35/51] [abbrv] [partial] incubator-quickstep git commit: remove c++ files
Date Sun, 11 Dec 2016 17:45:58 GMT
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/expressions/scalar/CMakeLists.txt b/expressions/scalar/CMakeLists.txt
deleted file mode 100644
index 8f509da..0000000
--- a/expressions/scalar/CMakeLists.txt
+++ /dev/null
@@ -1,181 +0,0 @@
-# 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.
-
-# Declare micro-libs:
-add_library(quickstep_expressions_scalar_Scalar Scalar.cpp Scalar.hpp)
-add_library(quickstep_expressions_scalar_ScalarAttribute
-            ScalarAttribute.cpp
-            ScalarAttribute.hpp)
-add_library(quickstep_expressions_scalar_ScalarBinaryExpression
-            ScalarBinaryExpression.cpp
-            ScalarBinaryExpression.hpp)
-add_library(quickstep_expressions_scalar_ScalarCaseExpression
-            ScalarCaseExpression.cpp
-            ScalarCaseExpression.hpp)
-add_library(quickstep_expressions_scalar_ScalarLiteral
-            ScalarLiteral.cpp
-            ScalarLiteral.hpp)
-add_library(quickstep_expressions_scalar_ScalarUnaryExpression
-            ScalarUnaryExpression.cpp
-            ScalarUnaryExpression.hpp)
-
-# Link dependencies:
-target_link_libraries(quickstep_expressions_scalar_Scalar
-                      quickstep_catalog_CatalogTypedefs
-                      quickstep_expressions_Expressions_proto
-                      quickstep_storage_StorageBlockInfo
-                      quickstep_types_TypedValue
-                      quickstep_utility_Macros)
-target_link_libraries(quickstep_expressions_scalar_ScalarAttribute
-                      quickstep_catalog_CatalogAttribute
-                      quickstep_catalog_CatalogRelationSchema
-                      quickstep_catalog_CatalogTypedefs
-                      quickstep_expressions_Expressions_proto
-                      quickstep_expressions_scalar_Scalar
-                      quickstep_storage_StorageBlockInfo
-                      quickstep_storage_ValueAccessor
-                      quickstep_storage_ValueAccessorUtil
-                      quickstep_types_Type
-                      quickstep_types_TypedValue
-                      quickstep_types_containers_ColumnVector
-                      quickstep_utility_Macros)
-target_link_libraries(quickstep_expressions_scalar_ScalarBinaryExpression
-                      quickstep_catalog_CatalogTypedefs
-                      quickstep_expressions_Expressions_proto
-                      quickstep_expressions_scalar_Scalar
-                      quickstep_storage_StorageBlockInfo
-                      quickstep_storage_ValueAccessor
-                      quickstep_types_Type
-                      quickstep_types_TypeErrors
-                      quickstep_types_TypedValue
-                      quickstep_types_containers_ColumnVector
-                      quickstep_types_operations_Operation_proto
-                      quickstep_types_operations_binaryoperations_BinaryOperation
-                      quickstep_utility_Macros)
-target_link_libraries(quickstep_expressions_scalar_ScalarCaseExpression
-                      quickstep_catalog_CatalogTypedefs
-                      quickstep_expressions_Expressions_proto
-                      quickstep_expressions_predicate_Predicate
-                      quickstep_expressions_scalar_Scalar
-                      quickstep_storage_StorageBlockInfo
-                      quickstep_storage_TupleIdSequence
-                      quickstep_storage_ValueAccessor
-                      quickstep_storage_ValueAccessorUtil
-                      quickstep_types_Type
-                      quickstep_types_Type_proto
-                      quickstep_types_TypedValue
-                      quickstep_types_containers_ColumnVector
-                      quickstep_utility_Macros)
-target_link_libraries(quickstep_expressions_scalar_ScalarLiteral
-                      quickstep_catalog_CatalogTypedefs
-                      quickstep_expressions_Expressions_proto
-                      quickstep_expressions_scalar_Scalar
-                      quickstep_storage_StorageBlockInfo
-                      quickstep_storage_ValueAccessor
-                      quickstep_types_Type
-                      quickstep_types_Type_proto
-                      quickstep_types_TypedValue
-                      quickstep_types_TypedValue_proto
-                      quickstep_types_containers_ColumnVector
-                      quickstep_utility_Macros)
-target_link_libraries(quickstep_expressions_scalar_ScalarUnaryExpression
-                      quickstep_catalog_CatalogTypedefs
-                      quickstep_expressions_Expressions_proto
-                      quickstep_expressions_scalar_Scalar
-                      quickstep_storage_StorageBlockInfo
-                      quickstep_storage_ValueAccessor
-                      quickstep_types_Type
-                      quickstep_types_TypeErrors
-                      quickstep_types_TypedValue
-                      quickstep_types_containers_ColumnVector
-                      quickstep_types_operations_Operation_proto
-                      quickstep_types_operations_unaryoperations_UnaryOperation
-                      quickstep_utility_Macros)
-
-# Submodule all-in-one library:
-add_library(quickstep_expressions_scalar ../../empty_src.cpp)
-target_link_libraries(quickstep_expressions_scalar
-                      quickstep_expressions_scalar_Scalar
-                      quickstep_expressions_scalar_ScalarAttribute
-                      quickstep_expressions_scalar_ScalarBinaryExpression
-                      quickstep_expressions_scalar_ScalarCaseExpression
-                      quickstep_expressions_scalar_ScalarLiteral
-                      quickstep_expressions_scalar_ScalarUnaryExpression)
-
-# Tests:
-add_executable(ScalarCaseExpression_unittest
-               "${CMAKE_CURRENT_SOURCE_DIR}/tests/ScalarCaseExpression_unittest.cpp")
-target_link_libraries(ScalarCaseExpression_unittest
-                      gtest
-                      gtest_main
-                      quickstep_catalog_CatalogAttribute
-                      quickstep_catalog_CatalogRelation
-                      quickstep_catalog_CatalogRelationSchema
-                      quickstep_expressions_predicate_ComparisonPredicate
-                      quickstep_expressions_predicate_ConjunctionPredicate
-                      quickstep_expressions_predicate_DisjunctionPredicate
-                      quickstep_expressions_predicate_Predicate
-                      quickstep_expressions_scalar_Scalar
-                      quickstep_expressions_scalar_ScalarAttribute
-                      quickstep_expressions_scalar_ScalarBinaryExpression
-                      quickstep_expressions_scalar_ScalarCaseExpression
-                      quickstep_expressions_scalar_ScalarLiteral
-                      quickstep_expressions_scalar_ScalarUnaryExpression
-                      quickstep_storage_StorageBlockInfo
-                      quickstep_storage_TupleIdSequence
-                      quickstep_storage_ValueAccessor
-                      quickstep_types_TypeFactory
-                      quickstep_types_TypeID
-                      quickstep_types_TypedValue
-                      quickstep_types_containers_ColumnVector
-                      quickstep_types_containers_ColumnVectorsValueAccessor
-                      quickstep_types_operations_binaryoperations_BinaryOperationFactory
-                      quickstep_types_operations_binaryoperations_BinaryOperationID
-                      quickstep_types_operations_comparisons_ComparisonFactory
-                      quickstep_types_operations_comparisons_ComparisonID
-                      quickstep_types_operations_unaryoperations_UnaryOperationFactory
-                      quickstep_types_operations_unaryoperations_UnaryOperationID)
-add_test(ScalarCaseExpression_unittest ScalarCaseExpression_unittest)
-
-add_executable(Scalar_unittest "${CMAKE_CURRENT_SOURCE_DIR}/tests/Scalar_unittest.cpp")
-target_link_libraries(Scalar_unittest
-                      gtest
-                      gtest_main
-                      quickstep_catalog_CatalogAttribute
-                      quickstep_catalog_CatalogDatabase
-                      quickstep_catalog_CatalogRelation
-                      quickstep_expressions_ExpressionFactories
-                      quickstep_expressions_scalar_Scalar
-                      quickstep_expressions_scalar_ScalarAttribute
-                      quickstep_expressions_scalar_ScalarBinaryExpression
-                      quickstep_expressions_scalar_ScalarLiteral
-                      quickstep_expressions_scalar_ScalarUnaryExpression
-                      quickstep_types_DatetimeLit
-                      quickstep_types_IntervalLit
-                      quickstep_types_Type
-                      quickstep_types_TypeFactory
-                      quickstep_types_TypeID
-                      quickstep_types_TypedValue
-                      quickstep_types_operations_binaryoperations_BinaryOperation
-                      quickstep_types_operations_binaryoperations_BinaryOperationFactory
-                      quickstep_types_operations_binaryoperations_BinaryOperationID
-                      quickstep_types_operations_unaryoperations_NumericCastOperation
-                      quickstep_types_operations_unaryoperations_UnaryOperation
-                      quickstep_types_operations_unaryoperations_UnaryOperationFactory
-                      quickstep_types_operations_unaryoperations_UnaryOperationID
-                      quickstep_utility_Macros)
-add_test(Scalar_unittest Scalar_unittest)

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/Scalar.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/Scalar.cpp b/expressions/scalar/Scalar.cpp
deleted file mode 100644
index a1c436c..0000000
--- a/expressions/scalar/Scalar.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * 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.
- **/
-
-#include "expressions/scalar/Scalar.hpp"
-
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-const char *Scalar::kScalarDataSourceNames[] = {
-  "Literal",
-  "Attribute",
-  "UnaryExpression",
-  "BinaryExpression",
-  "SimpleCase"
-};
-
-const TypedValue& Scalar::getStaticValue() const {
-  FATAL_ERROR("Called getStaticValue() on a Scalar which does not have a static value");
-}
-
-}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/Scalar.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/Scalar.hpp b/expressions/scalar/Scalar.hpp
deleted file mode 100644
index 2db850a..0000000
--- a/expressions/scalar/Scalar.hpp
+++ /dev/null
@@ -1,242 +0,0 @@
-/**
- * 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.
- **/
-
-#ifndef QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_HPP_
-#define QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_HPP_
-
-#include <utility>
-#include <vector>
-
-#include "catalog/CatalogTypedefs.hpp"
-#include "expressions/Expressions.pb.h"
-#include "storage/StorageBlockInfo.hpp"
-#include "types/TypedValue.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class ColumnVector;
-class Type;
-class ValueAccessor;
-
-struct SubBlocksReference;
-
-/** \addtogroup Expressions
- *  @{
- */
-
-/**
- * @brief Base class for anything which evaluates to a Scalar value.
- **/
-class Scalar {
- public:
-  /**
-   * @brief The possible provenance of Scalar values.
-   **/
-  enum ScalarDataSource {
-    kLiteral = 0,
-    kAttribute,
-    kUnaryExpression,
-    kBinaryExpression,
-    kCaseExpression,
-    kNumScalarDataSources  // Not a real ScalarDataSource, exists for counting purposes.
-  };
-
-  /**
-   * @brief Strings naming the elements in ScalarDataSource.
-   * @note String literals are defined out-of-line in Scalar.cpp
-   **/
-  static const char *kScalarDataSourceNames[kNumScalarDataSources];
-
-  /**
-   * @brief Virtual destructor.
-   **/
-  virtual ~Scalar() {
-  }
-
-  /**
-   * @brief Serialize this scalar in Protocol Buffer form.
-   *
-   * @return The Protocol Buffer representation of this scalar object.
-   **/
-  virtual serialization::Scalar getProto() const = 0;
-
-  /**
-   * @brief Make a deep copy of this Scalar.
-   *
-   * @return A cloned copy of this Scalar.
-   **/
-  virtual Scalar* clone() const = 0;
-
-  /**
-   * @brief Get the type of scalar value represented.
-   *
-   * @return The Type of the Scalar.
-   **/
-  inline const Type& getType() const {
-    return type_;
-  }
-
-  /**
-   * @brief Get the provenance of this scalar value.
-   *
-   * @return The source of this Scalar's data.
-   **/
-  virtual ScalarDataSource getDataSource() const = 0;
-
-  /**
-   * @brief Get this Scalar's value for the given tuple from a ValueAccessor.
-   * @note This only works for Scalars which can be evaluated for a single
-   *       table. Use getValueForJoinedTuples() where necessary.
-   *
-   * @param accessor The ValueAccessor that will be used to access the tuple to
-   *        evaluate this Scalar for.
-   * @param tuple The ID of the tuple in accessor (the absolute position) to
-   *        evaluate this Scalar for.
-   * @return The value of this scalar for the given tuple in the given
-   *         TupleStorageSubBlock.
-   **/
-  virtual TypedValue getValueForSingleTuple(const ValueAccessor &accessor,
-                                            const tuple_id tuple) const = 0;
-
-  /**
-   * @brief Get this Scalar's value for the given pair of joined tuples.
-   *
-   * @param left_accessor The ValueAccessor that the first of the joined
-   *        tuples can be read from (this does NOT necessarily correspond to
-   *        the left operand of a binary operation).
-   * @param left_relation_id The ID of the relation that left_tuple_store
-   *        belongs to.
-   * @param left_tuple_id The ID of the tuple in left_tuple_store to evaluate
-   *        this Scalar for.
-   * @param right_accessor The ValueAccessor that the second of the joined
-   *        tuples can be read from (this does NOT necessarily correspond to
-   *        the right operand of a binary operation).
-   * @param right_relation_id The ID of the relation that right_tuple_store
-   *        belongs to.
-   * @param right_tuple_id The ID of the tuple in right_tuple_store to evaluate
-   *        this Scalar for.
-   * @return The value of this scalar for the given tuples.
-   **/
-  virtual TypedValue getValueForJoinedTuples(
-      const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
-      const tuple_id left_tuple_id,
-      const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
-      const tuple_id right_tuple_id) const = 0;
-
-  /**
-   * @brief Determine whether this Scalar's value is static (i.e. whether it is
-   *        the same regardless of tuple).
-   *
-   * @return Whether this Scalar's value is static.
-   **/
-  virtual bool hasStaticValue() const {
-    return false;
-  }
-
-  /**
-   * @brief Get this Scalar's static value.
-   * @warning hasStaticValue() should be called first to check whether a static
-   *          value actually exists.
-   *
-   * @return This Scalar's static value.
-   **/
-  virtual const TypedValue& getStaticValue() const;
-
-  /**
-   * @brief If it is possible to get this Scalar's values directly from a
-   *        ValueAccessor, return the attribute_id that should be used to get
-   *        values.
-   *
-   * @return The attribute_id of this Scalar's values using a ValueAccessor,
-   *         or -1 if values can not be obtained directly from a ValueAccessor.
-   **/
-  virtual attribute_id getAttributeIdForValueAccessor() const {
-    return -1;
-  }
-
-  /**
-   * @brief If it is possible to get this Scalar's values directly from a
-   *        ValueAccessor, return the ID of the relation that such a
-   *        ValueAccessor should belong to.
-   *
-   * @return The relation_id for ValueAccessors that can directly produce this
-   *         Scalar's values, or -1 if values can not be obtained directly from
-   *         a ValueAccessor.
-   **/
-  virtual relation_id getRelationIdForValueAccessor() const {
-    return -1;
-  }
-
-  /**
-   * @brief Get this Scalar's values for all tuples accesible via a
-   *        ValueAccessor.
-   *
-   * @param accessor A ValueAccessor which this Scalar will be evaluated over.
-   * @param sub_blocks_ref If non-NULL, contains references to the
-   *        TupleStorageSubBlock that produced accessor and any IndexSubBlocks
-   *        in the same StorageBlock. These sub-blocks may be used for
-   *        fast-path (non-scan) evaluation of Predicates embedded in this
-   *        scalar (e.g. WHEN predicates in ScalarCaseExpression). May be NULL,
-   *        in which case scan-based evaluation is always used.
-   * @return A ColumnVector of this Scalar's values for each tuple accesible
-   *         via accessor.
-   **/
-  virtual ColumnVector* getAllValues(ValueAccessor *accessor,
-                                     const SubBlocksReference *sub_blocks_ref) const = 0;
-
-  /**
-   * @brief Get this Scalar's value for all specified joined tuples from two
-   *        ValueAccessors.
-   *
-   * @param left_relation_id The ID of the left relation in the join.
-   * @param left_accessor A ValueAccessor which will be used to access tuples
-   *        from the left relation.
-   * @param right_relation_id The ID of the right relation in the join.
-   * @param right_accessor A ValueAccessor which will be used to access tuples
-   *        from the right relation.
-   * @param joined_tuple_ids A series of pairs of tuple ids from the left and
-   *        right relations that will be joined.
-   * @return A ColumnVector of this Scalar's values for all the joined tuples
-   *         specified by joined_tuple_ids.
-   **/
-  virtual ColumnVector* getAllValuesForJoin(
-      const relation_id left_relation_id,
-      ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
-      ValueAccessor *right_accessor,
-      const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const = 0;
-
- protected:
-  explicit Scalar(const Type &type) : type_(type) {
-  }
-
-  const Type &type_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Scalar);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif  // QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/ScalarAttribute.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarAttribute.cpp b/expressions/scalar/ScalarAttribute.cpp
deleted file mode 100644
index cc42084..0000000
--- a/expressions/scalar/ScalarAttribute.cpp
+++ /dev/null
@@ -1,214 +0,0 @@
-/**
- * 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.
- **/
-
-#include "expressions/scalar/ScalarAttribute.hpp"
-
-#include <utility>
-#include <vector>
-
-#include "catalog/CatalogAttribute.hpp"
-#include "catalog/CatalogRelationSchema.hpp"
-#include "catalog/CatalogTypedefs.hpp"
-#include "expressions/Expressions.pb.h"
-#include "storage/StorageBlockInfo.hpp"
-#include "storage/ValueAccessor.hpp"
-#include "storage/ValueAccessorUtil.hpp"
-#include "types/Type.hpp"
-#include "types/TypedValue.hpp"
-#include "types/containers/ColumnVector.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-ScalarAttribute::ScalarAttribute(const CatalogAttribute &attribute)
-    : Scalar(attribute.getType()),
-      attribute_(attribute) {
-}
-
-serialization::Scalar ScalarAttribute::getProto() const {
-  serialization::Scalar proto;
-  proto.set_data_source(serialization::Scalar::ATTRIBUTE);
-  proto.SetExtension(serialization::ScalarAttribute::relation_id, attribute_.getParent().getID());
-  proto.SetExtension(serialization::ScalarAttribute::attribute_id, attribute_.getID());
-
-  return proto;
-}
-
-Scalar* ScalarAttribute::clone() const {
-  return new ScalarAttribute(attribute_);
-}
-
-TypedValue ScalarAttribute::getValueForSingleTuple(const ValueAccessor &accessor,
-                                                   const tuple_id tuple) const {
-  return accessor.getTypedValueAtAbsolutePositionVirtual(attribute_.getID(), tuple);
-}
-
-TypedValue ScalarAttribute::getValueForJoinedTuples(
-    const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
-    const tuple_id left_tuple_id,
-    const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
-    const tuple_id right_tuple_id) const {
-  // FIXME(chasseur): This can get confused and break for self-joins.
-  DCHECK((attribute_.getParent().getID() == left_relation_id)
-         || (attribute_.getParent().getID() == right_relation_id));
-  if (attribute_.getParent().getID() == left_relation_id) {
-    return left_accessor.getTypedValueAtAbsolutePositionVirtual(attribute_.getID(),
-                                                                left_tuple_id);
-  } else {
-    return right_accessor.getTypedValueAtAbsolutePositionVirtual(attribute_.getID(),
-                                                                 right_tuple_id);
-  }
-}
-
-attribute_id ScalarAttribute::getAttributeIdForValueAccessor() const {
-  return attribute_.getID();
-}
-
-relation_id ScalarAttribute::getRelationIdForValueAccessor() const {
-  return attribute_.getParent().getID();
-}
-
-ColumnVector* ScalarAttribute::getAllValues(ValueAccessor *accessor,
-                                            const SubBlocksReference *sub_blocks_ref) const {
-  const attribute_id attr_id = attribute_.getID();
-  const Type &result_type = attribute_.getType();
-  return InvokeOnValueAccessorMaybeTupleIdSequenceAdapter(
-      accessor,
-      [&attr_id, &result_type](auto *accessor) -> ColumnVector* {  // NOLINT(build/c++11)
-    if (NativeColumnVector::UsableForType(result_type)) {
-      NativeColumnVector *result = new NativeColumnVector(result_type,
-                                                          accessor->getNumTuples());
-      accessor->beginIteration();
-      if (result_type.isNullable()) {
-        if (accessor->isColumnAccessorSupported()) {
-          // If ColumnAccessor is supported on the underlying accessor, we have a fast strided
-          // column accessor available for the iteration on the underlying block.
-          // Since the attributes can be null, ColumnAccessor template takes a 'true' argument.
-          std::unique_ptr<const ColumnAccessor<true>>
-              column_accessor(accessor->template getColumnAccessor<true>(attr_id));
-          while (accessor->next()) {
-            const void *value = column_accessor->getUntypedValue();  // Fast strided access.
-            if (value == nullptr) {
-              result->appendNullValue();
-            } else {
-              result->appendUntypedValue(value);
-            }
-          }
-        } else {
-          while (accessor->next()) {
-            const void *value = accessor->template getUntypedValue<true>(attr_id);
-            if (value == nullptr) {
-              result->appendNullValue();
-            } else {
-              result->appendUntypedValue(value);
-            }
-          }
-        }
-      } else {
-        if (accessor->isColumnAccessorSupported()) {
-          // Since the attributes cannot be null, ColumnAccessor template takes a 'false' argument.
-          std::unique_ptr<const ColumnAccessor<false>>
-              column_accessor(accessor->template getColumnAccessor<false>(attr_id));
-          while (accessor->next()) {
-            result->appendUntypedValue(column_accessor->getUntypedValue());  // Fast strided access.
-          }
-        } else {
-          while (accessor->next()) {
-            result->appendUntypedValue(
-                accessor->template getUntypedValue<false>(attr_id));
-          }
-        }
-      }
-      return result;
-    } else {
-      IndirectColumnVector *result = new IndirectColumnVector(result_type,
-                                                              accessor->getNumTuples());
-      accessor->beginIteration();
-      while (accessor->next()) {
-        result->appendTypedValue(accessor->getTypedValue(attr_id));
-      }
-      return result;
-    }
-  });
-}
-
-ColumnVector* ScalarAttribute::getAllValuesForJoin(
-    const relation_id left_relation_id,
-    ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
-    ValueAccessor *right_accessor,
-    const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const {
-  DCHECK((attribute_.getParent().getID() == left_relation_id)
-         || (attribute_.getParent().getID() == right_relation_id));
-
-  const attribute_id attr_id = attribute_.getID();
-  const Type &result_type = attribute_.getType();
-
-  const bool using_left_relation = (attribute_.getParent().getID() == left_relation_id);
-  ValueAccessor *accessor = using_left_relation ? left_accessor
-                                                : right_accessor;
-
-  return InvokeOnAnyValueAccessor(
-      accessor,
-      [&joined_tuple_ids,
-       &attr_id,
-       &result_type,
-       &using_left_relation](auto *accessor) -> ColumnVector* {  // NOLINT(build/c++11)
-    if (NativeColumnVector::UsableForType(result_type)) {
-      NativeColumnVector *result = new NativeColumnVector(result_type,
-                                                          joined_tuple_ids.size());
-      if (result_type.isNullable()) {
-        for (const std::pair<tuple_id, tuple_id> &joined_pair : joined_tuple_ids) {
-          const void *value = accessor->template getUntypedValueAtAbsolutePosition<true>(
-              attr_id,
-              using_left_relation ? joined_pair.first : joined_pair.second);
-          if (value == nullptr) {
-            result->appendNullValue();
-          } else {
-            result->appendUntypedValue(value);
-          }
-        }
-      } else {
-        for (const std::pair<tuple_id, tuple_id> &joined_pair : joined_tuple_ids) {
-          result->appendUntypedValue(
-              accessor->template getUntypedValueAtAbsolutePosition<false>(
-                  attr_id,
-                  using_left_relation ? joined_pair.first : joined_pair.second));
-        }
-      }
-      return result;
-    } else {
-      IndirectColumnVector *result = new IndirectColumnVector(result_type,
-                                                              joined_tuple_ids.size());
-      for (const std::pair<tuple_id, tuple_id> &joined_pair : joined_tuple_ids) {
-        result->appendTypedValue(
-              accessor->getTypedValueAtAbsolutePosition(
-                  attr_id,
-                  using_left_relation ? joined_pair.first : joined_pair.second));
-      }
-      return result;
-    }
-  });
-}
-
-}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/ScalarAttribute.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarAttribute.hpp b/expressions/scalar/ScalarAttribute.hpp
deleted file mode 100644
index c6a41df..0000000
--- a/expressions/scalar/ScalarAttribute.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/**
- * 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.
- **/
-
-#ifndef QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_ATTRIBUTE_HPP_
-#define QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_ATTRIBUTE_HPP_
-
-#include <utility>
-#include <vector>
-
-#include "catalog/CatalogTypedefs.hpp"
-#include "expressions/Expressions.pb.h"
-#include "expressions/scalar/Scalar.hpp"
-#include "storage/StorageBlockInfo.hpp"
-#include "types/TypedValue.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class ColumnVector;
-class ValueAccessor;
-
-struct SubBlocksReference;
-
-/** \addtogroup Expressions
- *  @{
- */
-
-/**
- * @brief Scalars which are attribute values from tuples.
- **/
-class ScalarAttribute : public Scalar {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param attribute The attribute to use.
-   **/
-  explicit ScalarAttribute(const CatalogAttribute &attribute);
-
-  serialization::Scalar getProto() const override;
-
-  Scalar* clone() const override;
-
-  ScalarDataSource getDataSource() const override {
-    return kAttribute;
-  }
-
-  TypedValue getValueForSingleTuple(const ValueAccessor &accessor,
-                                    const tuple_id tuple) const override;
-
-  TypedValue getValueForJoinedTuples(
-      const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
-      const tuple_id left_tuple_id,
-      const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
-      const tuple_id right_tuple_id) const override;
-
-  attribute_id getAttributeIdForValueAccessor() const override;
-
-  relation_id getRelationIdForValueAccessor() const override;
-
-  ColumnVector* getAllValues(ValueAccessor *accessor,
-                             const SubBlocksReference *sub_blocks_ref) const override;
-
-  ColumnVector* getAllValuesForJoin(
-      const relation_id left_relation_id,
-      ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
-      ValueAccessor *right_accessor,
-      const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const override;
-
-  const CatalogAttribute& getAttribute() const {
-    return attribute_;
-  }
-
- protected:
-  const CatalogAttribute &attribute_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScalarAttribute);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif  // QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_ATTRIBUTE_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/ScalarBinaryExpression.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarBinaryExpression.cpp b/expressions/scalar/ScalarBinaryExpression.cpp
deleted file mode 100644
index 5fe6cde..0000000
--- a/expressions/scalar/ScalarBinaryExpression.cpp
+++ /dev/null
@@ -1,377 +0,0 @@
-/**
- * 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.
- **/
-
-#include "expressions/scalar/ScalarBinaryExpression.hpp"
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "catalog/CatalogTypedefs.hpp"
-#include "expressions/Expressions.pb.h"
-#include "storage/ValueAccessor.hpp"
-#include "types/Type.hpp"
-#include "types/TypeErrors.hpp"
-#include "types/TypedValue.hpp"
-#include "types/containers/ColumnVector.hpp"
-#include "types/operations/Operation.pb.h"
-#include "types/operations/binary_operations/BinaryOperation.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-ScalarBinaryExpression::ScalarBinaryExpression(const BinaryOperation &operation,
-                                               Scalar *left_operand,
-                                               Scalar *right_operand)
-    : Scalar(*operation.resultTypeForArgumentTypes(left_operand->getType(),
-                                                   right_operand->getType())),
-      operation_(operation),
-      left_operand_(left_operand),
-      right_operand_(right_operand) {
-  initHelper(false);
-}
-
-serialization::Scalar ScalarBinaryExpression::getProto() const {
-  serialization::Scalar proto;
-  proto.set_data_source(serialization::Scalar::BINARY_EXPRESSION);
-  proto.MutableExtension(serialization::ScalarBinaryExpression::operation)->CopyFrom(operation_.getProto());
-  proto.MutableExtension(serialization::ScalarBinaryExpression::left_operand)->CopyFrom(left_operand_->getProto());
-  proto.MutableExtension(serialization::ScalarBinaryExpression::right_operand)->CopyFrom(right_operand_->getProto());
-
-  return proto;
-}
-
-Scalar* ScalarBinaryExpression::clone() const {
-  return new ScalarBinaryExpression(operation_,
-                                    left_operand_->clone(),
-                                    right_operand_->clone());
-}
-
-TypedValue ScalarBinaryExpression::getValueForSingleTuple(const ValueAccessor &accessor,
-                                                          const tuple_id tuple) const {
-  if (fast_operator_.get() == nullptr) {
-    return static_value_.makeReferenceToThis();
-  } else {
-    return fast_operator_->applyToTypedValues(left_operand_->getValueForSingleTuple(accessor, tuple),
-                                              right_operand_->getValueForSingleTuple(accessor, tuple));
-  }
-}
-
-TypedValue ScalarBinaryExpression::getValueForJoinedTuples(
-    const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
-    const tuple_id left_tuple_id,
-    const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
-    const tuple_id right_tuple_id) const {
-  if (fast_operator_.get() == nullptr) {
-    return static_value_.makeReferenceToThis();
-  } else {
-    return fast_operator_->applyToTypedValues(
-        left_operand_->getValueForJoinedTuples(left_accessor,
-                                               left_relation_id,
-                                               left_tuple_id,
-                                               right_accessor,
-                                               right_relation_id,
-                                               right_tuple_id),
-        right_operand_->getValueForJoinedTuples(left_accessor,
-                                                left_relation_id,
-                                                left_tuple_id,
-                                                right_accessor,
-                                                right_relation_id,
-                                                right_tuple_id));
-  }
-}
-
-ColumnVector* ScalarBinaryExpression::getAllValues(
-    ValueAccessor *accessor,
-    const SubBlocksReference *sub_blocks_ref) const {
-  if (fast_operator_.get() == nullptr) {
-    return ColumnVector::MakeVectorOfValue(getType(),
-                                           static_value_,
-                                           accessor->getNumTuplesVirtual());
-  } else {
-    // NOTE(chasseur): We don't check if BOTH operands have a static value,
-    // because if they did then this expression would also have a static value
-    // handled in the case above.
-    if (left_operand_->hasStaticValue()) {
-#ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION
-      const attribute_id right_operand_attr_id
-          = right_operand_->getAttributeIdForValueAccessor();
-      if (right_operand_attr_id != -1) {
-        return fast_operator_->applyToStaticValueAndValueAccessor(
-            left_operand_->getStaticValue(),
-            accessor,
-            right_operand_attr_id);
-      }
-#endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION
-
-      std::unique_ptr<ColumnVector> right_result(
-          right_operand_->getAllValues(accessor, sub_blocks_ref));
-      return fast_operator_->applyToStaticValueAndColumnVector(
-          left_operand_->getStaticValue(),
-          *right_result);
-    } else if (right_operand_->hasStaticValue()) {
-#ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION
-      const attribute_id left_operand_attr_id
-          = left_operand_->getAttributeIdForValueAccessor();
-      if (left_operand_attr_id != -1) {
-        return fast_operator_->applyToValueAccessorAndStaticValue(
-            accessor,
-            left_operand_attr_id,
-            right_operand_->getStaticValue());
-      }
-#endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION
-
-      std::unique_ptr<ColumnVector> left_result(
-          left_operand_->getAllValues(accessor, sub_blocks_ref));
-      return fast_operator_->applyToColumnVectorAndStaticValue(
-          *left_result,
-          right_operand_->getStaticValue());
-    } else {
-#ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION
-      const attribute_id left_operand_attr_id
-          = left_operand_->getAttributeIdForValueAccessor();
-      const attribute_id right_operand_attr_id
-          = right_operand_->getAttributeIdForValueAccessor();
-
-      if (left_operand_attr_id != -1) {
-        if (right_operand_attr_id != -1) {
-          return fast_operator_->applyToSingleValueAccessor(accessor,
-                                                            left_operand_attr_id,
-                                                            right_operand_attr_id);
-        } else {
-          std::unique_ptr<ColumnVector> right_result(
-              right_operand_->getAllValues(accessor, sub_blocks_ref));
-          return fast_operator_->applyToValueAccessorAndColumnVector(accessor,
-                                                                     left_operand_attr_id,
-                                                                     *right_result);
-        }
-      } else if (right_operand_attr_id != -1) {
-        std::unique_ptr<ColumnVector> left_result(
-            left_operand_->getAllValues(accessor, sub_blocks_ref));
-        return fast_operator_->applyToColumnVectorAndValueAccessor(*left_result,
-                                                                   accessor,
-                                                                   right_operand_attr_id);
-      }
-#endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION
-
-      std::unique_ptr<ColumnVector> left_result(
-          left_operand_->getAllValues(accessor, sub_blocks_ref));
-      std::unique_ptr<ColumnVector> right_result(
-          right_operand_->getAllValues(accessor, sub_blocks_ref));
-      return fast_operator_->applyToColumnVectors(*left_result, *right_result);
-    }
-  }
-}
-
-ColumnVector* ScalarBinaryExpression::getAllValuesForJoin(
-    const relation_id left_relation_id,
-    ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
-    ValueAccessor *right_accessor,
-    const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const {
-  if (fast_operator_.get() == nullptr) {
-    return ColumnVector::MakeVectorOfValue(getType(),
-                                           static_value_,
-                                           joined_tuple_ids.size());
-  } else {
-    if (left_operand_->hasStaticValue()) {
-#ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
-      const attribute_id right_operand_attr_id
-          = right_operand_->getAttributeIdForValueAccessor();
-      if (right_operand_attr_id != -1) {
-        const relation_id right_operand_relation_id
-            = right_operand_->getRelationIdForValueAccessor();
-        DCHECK_NE(right_operand_relation_id, -1);
-        DCHECK((right_operand_relation_id == left_relation_id)
-               || (right_operand_relation_id == right_relation_id));
-        const bool using_left_relation = (right_operand_relation_id == left_relation_id);
-        ValueAccessor *right_operand_accessor = using_left_relation ? left_accessor
-                                                                    : right_accessor;
-        return fast_operator_->applyToStaticValueAndValueAccessorForJoin(
-            left_operand_->getStaticValue(),
-            right_operand_accessor,
-            using_left_relation,
-            right_operand_attr_id,
-            joined_tuple_ids);
-      }
-#endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
-
-      std::unique_ptr<ColumnVector> right_result(
-          right_operand_->getAllValuesForJoin(left_relation_id,
-                                              left_accessor,
-                                              right_relation_id,
-                                              right_accessor,
-                                              joined_tuple_ids));
-      return fast_operator_->applyToStaticValueAndColumnVector(
-          left_operand_->getStaticValue(),
-          *right_result);
-    } else if (right_operand_->hasStaticValue()) {
-#ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
-      const attribute_id left_operand_attr_id
-          = left_operand_->getAttributeIdForValueAccessor();
-      if (left_operand_attr_id != -1) {
-        const relation_id left_operand_relation_id
-            = left_operand_->getRelationIdForValueAccessor();
-        DCHECK_NE(left_operand_relation_id, -1);
-        DCHECK((left_operand_relation_id == left_relation_id)
-               || (left_operand_relation_id == right_relation_id));
-        const bool using_left_relation = (left_operand_relation_id == left_relation_id);
-        ValueAccessor *left_operand_accessor = using_left_relation ? left_accessor
-                                                                   : right_accessor;
-        return fast_operator_->applyToValueAccessorAndStaticValueForJoin(
-            left_operand_accessor,
-            using_left_relation,
-            left_operand_attr_id,
-            right_operand_->getStaticValue(),
-            joined_tuple_ids);
-      }
-#endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
-
-      std::unique_ptr<ColumnVector> left_result(
-          left_operand_->getAllValuesForJoin(left_relation_id,
-                                             left_accessor,
-                                             right_relation_id,
-                                             right_accessor,
-                                             joined_tuple_ids));
-      return fast_operator_->applyToColumnVectorAndStaticValue(
-          *left_result,
-          right_operand_->getStaticValue());
-    } else {
-#ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
-      const attribute_id left_operand_attr_id
-          = left_operand_->getAttributeIdForValueAccessor();
-      const attribute_id right_operand_attr_id
-          = right_operand_->getAttributeIdForValueAccessor();
-      if (left_operand_attr_id != -1) {
-        const relation_id left_operand_relation_id
-            = left_operand_->getRelationIdForValueAccessor();
-        DCHECK_NE(left_operand_relation_id, -1);
-        DCHECK((left_operand_relation_id == left_relation_id)
-               || (left_operand_relation_id == right_relation_id));
-        const bool using_left_relation_for_left_operand
-            = (left_operand_relation_id == left_relation_id);
-        ValueAccessor *left_operand_accessor = using_left_relation_for_left_operand ? left_accessor
-                                                                                    : right_accessor;
-
-#ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN_WITH_BINARY_EXPRESSIONS
-        if (right_operand_attr_id != -1) {
-          const relation_id right_operand_relation_id
-              = right_operand_->getRelationIdForValueAccessor();
-          DCHECK_NE(right_operand_relation_id, -1);
-          DCHECK((right_operand_relation_id == left_relation_id)
-                 || (right_operand_relation_id == right_relation_id));
-          const bool using_left_relation_for_right_operand
-              = (right_operand_relation_id == left_relation_id);
-          ValueAccessor *right_operand_accessor = using_left_relation_for_right_operand ? left_accessor
-                                                                                        : right_accessor;
-          return fast_operator_->applyToValueAccessorsForJoin(left_operand_accessor,
-                                                              using_left_relation_for_left_operand,
-                                                              left_operand_attr_id,
-                                                              right_operand_accessor,
-                                                              using_left_relation_for_right_operand,
-                                                              right_operand_attr_id,
-                                                              joined_tuple_ids);
-        }
-#endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN_WITH_BINARY_EXPRESSIONS
-        std::unique_ptr<ColumnVector> right_result(
-            right_operand_->getAllValuesForJoin(left_relation_id,
-                                                left_accessor,
-                                                right_relation_id,
-                                                right_accessor,
-                                                joined_tuple_ids));
-
-        return fast_operator_->applyToValueAccessorAndColumnVectorForJoin(
-            left_operand_accessor,
-            using_left_relation_for_left_operand,
-            left_operand_attr_id,
-            *right_result,
-            joined_tuple_ids);
-      } else if (right_operand_attr_id != -1) {
-        const relation_id right_operand_relation_id
-            = right_operand_->getRelationIdForValueAccessor();
-        DCHECK_NE(right_operand_relation_id, -1);
-        DCHECK((right_operand_relation_id == left_relation_id)
-               || (right_operand_relation_id == right_relation_id));
-        const bool using_left_relation_for_right_operand
-            = (right_operand_relation_id == left_relation_id);
-        ValueAccessor *right_operand_accessor = using_left_relation_for_right_operand ? left_accessor
-                                                                                      : right_accessor;
-
-        std::unique_ptr<ColumnVector> left_result(
-            left_operand_->getAllValuesForJoin(left_relation_id,
-                                               left_accessor,
-                                               right_relation_id,
-                                               right_accessor,
-                                               joined_tuple_ids));
-        return fast_operator_->applyToColumnVectorAndValueAccessorForJoin(
-            *left_result,
-            right_operand_accessor,
-            using_left_relation_for_right_operand,
-            right_operand_attr_id,
-            joined_tuple_ids);
-      }
-#endif  // QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN
-
-      std::unique_ptr<ColumnVector> left_result(
-          left_operand_->getAllValuesForJoin(left_relation_id,
-                                             left_accessor,
-                                             right_relation_id,
-                                             right_accessor,
-                                             joined_tuple_ids));
-      std::unique_ptr<ColumnVector> right_result(
-          right_operand_->getAllValuesForJoin(left_relation_id,
-                                              left_accessor,
-                                              right_relation_id,
-                                              right_accessor,
-                                              joined_tuple_ids));
-      return fast_operator_->applyToColumnVectors(*left_result, *right_result);
-    }
-  }
-}
-
-void ScalarBinaryExpression::initHelper(bool own_children) {
-  if (operation_.canApplyToTypes(left_operand_->getType(), right_operand_->getType())) {
-    if (left_operand_->hasStaticValue() && right_operand_->hasStaticValue()) {
-      static_value_ = operation_.applyToChecked(left_operand_->getStaticValue(),
-                                                left_operand_->getType(),
-                                                right_operand_->getStaticValue(),
-                                                right_operand_->getType());
-    } else {
-      fast_operator_.reset(operation_.makeUncheckedBinaryOperatorForTypes(left_operand_->getType(),
-                                                                           right_operand_->getType()));
-    }
-  } else {
-    const Type &left_operand_type = left_operand_->getType();
-    const Type &right_operand_type = right_operand_->getType();
-    if (!own_children) {
-      left_operand_.release();
-      right_operand_.release();
-    }
-    throw OperationInapplicableToType(operation_.getName(),
-                                      2,
-                                      left_operand_type.getName().c_str(),
-                                      right_operand_type.getName().c_str());
-  }
-}
-
-}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/ScalarBinaryExpression.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarBinaryExpression.hpp b/expressions/scalar/ScalarBinaryExpression.hpp
deleted file mode 100644
index c84792a..0000000
--- a/expressions/scalar/ScalarBinaryExpression.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-/**
- * 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.
- **/
-
-#ifndef QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_BINARY_EXPRESSION_HPP_
-#define QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_BINARY_EXPRESSION_HPP_
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "catalog/CatalogTypedefs.hpp"
-#include "expressions/Expressions.pb.h"
-#include "expressions/scalar/Scalar.hpp"
-#include "storage/StorageBlockInfo.hpp"
-#include "types/TypedValue.hpp"
-#include "types/operations/binary_operations/BinaryOperation.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-class ColumnVector;
-class ValueAccessor;
-
-struct SubBlocksReference;
-
-/** \addtogroup Expressions
- *  @{
- */
-
-/**
- * @brief Expressions which are based on a BinaryOperation.
- **/
-class ScalarBinaryExpression : public Scalar {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param operation The binary operation to be performed.
-   * @param left_operand The left argument of the operation, which this
-   *        ScalarBinaryExpression takes ownership of.
-   * @param right_operand The right argument of the operation, which this
-   *        ScalarBinaryExpression takes ownership of.
-   **/
-  ScalarBinaryExpression(const BinaryOperation &operation,
-                         Scalar *left_operand,
-                         Scalar *right_operand);
-
-  /**
-   * @brief Destructor
-   **/
-  ~ScalarBinaryExpression() override {
-  }
-
-  serialization::Scalar getProto() const override;
-
-  Scalar* clone() const override;
-
-  ScalarDataSource getDataSource() const override {
-    return kBinaryExpression;
-  }
-
-  TypedValue getValueForSingleTuple(const ValueAccessor &accessor,
-                                    const tuple_id tuple) const override;
-
-  TypedValue getValueForJoinedTuples(
-      const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
-      const tuple_id left_tuple_id,
-      const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
-      const tuple_id right_tuple_id) const override;
-
-  bool hasStaticValue() const override {
-    return fast_operator_.get() == nullptr;
-  }
-
-  const TypedValue& getStaticValue() const override {
-    DCHECK(hasStaticValue());
-    return static_value_;
-  }
-
-  ColumnVector* getAllValues(ValueAccessor *accessor,
-                             const SubBlocksReference *sub_blocks_ref) const override;
-
-  ColumnVector* getAllValuesForJoin(
-      const relation_id left_relation_id,
-      ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
-      ValueAccessor *right_accessor,
-      const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const override;
-
- private:
-  void initHelper(bool own_children);
-
-  const BinaryOperation &operation_;
-
-  std::unique_ptr<Scalar> left_operand_;
-  std::unique_ptr<Scalar> right_operand_;
-  TypedValue static_value_;
-  std::unique_ptr<UncheckedBinaryOperator> fast_operator_;
-
-  friend class PredicateTest;
-  friend class ScalarTest;
-
-  DISALLOW_COPY_AND_ASSIGN(ScalarBinaryExpression);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif  // QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_BINARY_EXPRESSION_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/ScalarCaseExpression.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarCaseExpression.cpp b/expressions/scalar/ScalarCaseExpression.cpp
deleted file mode 100644
index c81f723..0000000
--- a/expressions/scalar/ScalarCaseExpression.cpp
+++ /dev/null
@@ -1,515 +0,0 @@
-/**
- * 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.
- **/
-
-#include "expressions/scalar/ScalarCaseExpression.hpp"
-
-#include <cstddef>
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "catalog/CatalogTypedefs.hpp"
-#include "expressions/Expressions.pb.h"
-#include "expressions/predicate/Predicate.hpp"
-#include "expressions/scalar/Scalar.hpp"
-#include "storage/TupleIdSequence.hpp"
-#include "storage/ValueAccessor.hpp"
-#include "storage/ValueAccessorUtil.hpp"
-#include "types/Type.hpp"
-#include "types/Type.pb.h"
-#include "types/TypedValue.hpp"
-#include "types/containers/ColumnVector.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-ScalarCaseExpression::ScalarCaseExpression(
-    const Type &result_type,
-    std::vector<std::unique_ptr<Predicate>> &&when_predicates,
-    std::vector<std::unique_ptr<Scalar>> &&result_expressions,
-    Scalar *else_result_expression)
-    : Scalar(result_type),
-      when_predicates_(std::move(when_predicates)),
-      result_expressions_(std::move(result_expressions)),
-      else_result_expression_(else_result_expression),
-      fixed_result_expression_(nullptr),
-      has_static_value_(false) {
-  DCHECK_EQ(when_predicates_.size(), result_expressions_.size());
-  DCHECK(else_result_expression_ != nullptr);
-
-#ifdef QUICKSTEP_DEBUG
-  for (const std::unique_ptr<Scalar> &result_expr : result_expressions_) {
-    DCHECK(result_expr->getType().isSubsumedBy(type_));
-  }
-#endif  // QUICKSTEP_DEBUG
-
-  DCHECK(else_result_expression_->getType().isSubsumedBy(type_));
-
-  // Resolve case branch statically if possible.
-  bool static_case_branch = true;
-  for (std::vector<std::unique_ptr<Predicate>>::size_type case_idx = 0;
-       case_idx < when_predicates_.size();
-       ++case_idx) {
-    if (when_predicates_[case_idx]->hasStaticResult()) {
-      if (when_predicates_[case_idx]->getStaticResult()) {
-        fixed_result_expression_ = result_expressions_[case_idx].get();
-        break;
-      }
-    } else {
-      static_case_branch = false;
-    }
-  }
-
-  if (static_case_branch && (fixed_result_expression_ == nullptr)) {
-    fixed_result_expression_ = else_result_expression_.get();
-  }
-
-  if (fixed_result_expression_ != nullptr) {
-    if (fixed_result_expression_->hasStaticValue()) {
-      has_static_value_ = true;
-      static_value_ = fixed_result_expression_->getStaticValue();
-    } else {
-      // CASE always goes to the same branch, but its value is not static.
-    }
-  }
-}
-
-serialization::Scalar ScalarCaseExpression::getProto() const {
-  serialization::Scalar proto;
-  proto.set_data_source(serialization::Scalar::CASE_EXPRESSION);
-  proto.MutableExtension(serialization::ScalarCaseExpression::result_type)
-      ->CopyFrom(type_.getProto());
-  for (const std::unique_ptr<Predicate> &when_pred : when_predicates_) {
-    proto.AddExtension(serialization::ScalarCaseExpression::when_predicate)
-      ->CopyFrom(when_pred->getProto());
-  }
-  for (const std::unique_ptr<Scalar> &result_expr : result_expressions_) {
-    proto.AddExtension(serialization::ScalarCaseExpression::result_expression)
-      ->CopyFrom(result_expr->getProto());
-  }
-  proto.MutableExtension(serialization::ScalarCaseExpression::else_result_expression)
-      ->CopyFrom(else_result_expression_->getProto());
-
-  return proto;
-}
-
-Scalar* ScalarCaseExpression::clone() const {
-  std::vector<std::unique_ptr<Predicate>> when_predicate_clones;
-  when_predicate_clones.reserve(when_predicates_.size());
-  for (const std::unique_ptr<Predicate> &when_pred : when_predicates_) {
-    when_predicate_clones.emplace_back(when_pred->clone());
-  }
-
-  std::vector<std::unique_ptr<Scalar>> result_expression_clones;
-  result_expression_clones.reserve(result_expressions_.size());
-  for (const std::unique_ptr<Scalar> &result_expr : result_expressions_) {
-    result_expression_clones.emplace_back(result_expr->clone());
-  }
-
-  return new ScalarCaseExpression(type_,
-                                  std::move(when_predicate_clones),
-                                  std::move(result_expression_clones),
-                                  else_result_expression_->clone());
-}
-
-TypedValue ScalarCaseExpression::getValueForSingleTuple(
-    const ValueAccessor &accessor,
-    const tuple_id tuple) const {
-  if (has_static_value_) {
-    return static_value_.makeReferenceToThis();
-  } else if (fixed_result_expression_ != nullptr) {
-    return fixed_result_expression_->getValueForSingleTuple(accessor, tuple);
-  } else {
-    for (std::vector<std::unique_ptr<Predicate>>::size_type case_idx = 0;
-         case_idx < when_predicates_.size();
-         ++case_idx) {
-      if (when_predicates_[case_idx]->matchesForSingleTuple(accessor, tuple)) {
-        return result_expressions_[case_idx]->getValueForSingleTuple(accessor, tuple);
-      }
-    }
-    return else_result_expression_->getValueForSingleTuple(accessor, tuple);
-  }
-}
-
-TypedValue ScalarCaseExpression::getValueForJoinedTuples(
-    const ValueAccessor &left_accessor,
-    const relation_id left_relation_id,
-    const tuple_id left_tuple_id,
-    const ValueAccessor &right_accessor,
-    const relation_id right_relation_id,
-    const tuple_id right_tuple_id) const {
-  if (has_static_value_) {
-    return static_value_.makeReferenceToThis();
-  } else if (fixed_result_expression_ != nullptr) {
-    return fixed_result_expression_->getValueForJoinedTuples(left_accessor,
-                                                             left_relation_id,
-                                                             left_tuple_id,
-                                                             right_accessor,
-                                                             right_relation_id,
-                                                             right_tuple_id);
-  } else {
-    for (std::vector<std::unique_ptr<Predicate>>::size_type case_idx = 0;
-         case_idx < when_predicates_.size();
-         ++case_idx) {
-      if (when_predicates_[case_idx]->matchesForJoinedTuples(left_accessor,
-                                                             left_relation_id,
-                                                             left_tuple_id,
-                                                             right_accessor,
-                                                             right_relation_id,
-                                                             right_tuple_id)) {
-        return result_expressions_[case_idx]->getValueForJoinedTuples(
-            left_accessor,
-            left_relation_id,
-            left_tuple_id,
-            right_accessor,
-            right_relation_id,
-            right_tuple_id);
-      }
-    }
-    return else_result_expression_->getValueForJoinedTuples(
-        left_accessor,
-        left_relation_id,
-        left_tuple_id,
-        right_accessor,
-        right_relation_id,
-        right_tuple_id);
-  }
-}
-
-ColumnVector* ScalarCaseExpression::getAllValues(
-    ValueAccessor *accessor,
-    const SubBlocksReference *sub_blocks_ref) const {
-  return InvokeOnValueAccessorMaybeTupleIdSequenceAdapter(
-      accessor,
-      [&](auto *accessor) -> ColumnVector* {  // NOLINT(build/c++11)
-    if (has_static_value_) {
-      return ColumnVector::MakeVectorOfValue(type_,
-                                             static_value_,
-                                             accessor->getNumTuples());
-    } else if (fixed_result_expression_ != nullptr) {
-      return fixed_result_expression_->getAllValues(accessor, sub_blocks_ref);
-    }
-
-    const TupleIdSequence *accessor_sequence = accessor->getTupleIdSequence();
-
-    // Initially set '*else_matches' to cover all tuples from the
-    // ValueAccessor.
-    std::unique_ptr<TupleIdSequence> else_matches;
-    if (accessor_sequence != nullptr) {
-      else_matches.reset(new TupleIdSequence(accessor_sequence->length()));
-      else_matches->assignFrom(*accessor_sequence);
-    } else {
-      else_matches.reset(new TupleIdSequence(accessor->getEndPosition()));
-      else_matches->setRange(0, else_matches->length(), true);
-    }
-
-    // Generate a TupleIdSequence of matches for each branch in the CASE.
-    std::vector<std::unique_ptr<TupleIdSequence>> case_matches;
-    for (std::vector<std::unique_ptr<Predicate>>::size_type case_idx = 0;
-         case_idx < when_predicates_.size();
-         ++case_idx) {
-      if (else_matches->empty()) {
-        break;
-      }
-
-      case_matches.emplace_back(when_predicates_[case_idx]->getAllMatches(
-          accessor,
-          sub_blocks_ref,
-          else_matches.get(),
-          accessor_sequence));
-      else_matches->intersectWithComplement(*case_matches.back());
-    }
-
-    // Generate a ColumnVector of all the values for each case.
-    std::vector<std::unique_ptr<ColumnVector>> case_results;
-    for (std::vector<std::unique_ptr<TupleIdSequence>>::size_type case_idx = 0;
-         case_idx < case_matches.size();
-         ++case_idx) {
-      std::unique_ptr<ValueAccessor> case_accessor(
-          accessor->createSharedTupleIdSequenceAdapter(*case_matches[case_idx]));
-      case_results.emplace_back(
-          result_expressions_[case_idx]->getAllValues(case_accessor.get(), sub_blocks_ref));
-    }
-
-    std::unique_ptr<ColumnVector> else_results;
-    if (!else_matches->empty()) {
-      std::unique_ptr<ValueAccessor> else_accessor(
-          accessor->createSharedTupleIdSequenceAdapter(*else_matches));
-      else_results.reset(else_result_expression_->getAllValues(else_accessor.get(), sub_blocks_ref));
-    }
-
-    // Multiplex per-case results into a single ColumnVector with values in the
-    // correct positions.
-    return this->multiplexColumnVectors(
-        accessor->getNumTuples(),
-        accessor_sequence,
-        case_matches,
-        *else_matches,
-        &case_results,
-        else_results.get());
-  });
-}
-
-ColumnVector* ScalarCaseExpression::getAllValuesForJoin(
-    const relation_id left_relation_id,
-    ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
-    ValueAccessor *right_accessor,
-    const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const {
-  // Slice 'joined_tuple_ids' apart by case.
-  //
-  // NOTE(chasseur): We use TupleIdSequence to keep track of the positions in
-  // 'joined_tuple_ids' that match for a particular case. This is a bit hacky,
-  // since TupleIdSequence is intended to represent tuple IDs in one block.
-  // All we're really using it for is to multiplex results into the right
-  // place.
-  //
-  // TODO(chasseur): Currently case predicates are evaluated tuple-at-a-time
-  // here (just like in a NestedLoopsJoin). If and when we implement vectorized
-  // evaluation of nested-loops predicates (or just filtration of joined IDs),
-  // we should use that here.
-  TupleIdSequence else_positions(joined_tuple_ids.size());
-  else_positions.setRange(0, joined_tuple_ids.size(), true);
-
-  std::vector<std::unique_ptr<TupleIdSequence>> case_positions;
-  std::vector<std::vector<std::pair<tuple_id, tuple_id>>> case_matches;
-  for (std::vector<std::unique_ptr<Predicate>>::size_type case_idx = 0;
-       case_idx < when_predicates_.size();
-       ++case_idx) {
-    if (else_positions.empty()) {
-      break;
-    }
-
-    TupleIdSequence *current_case_positions = new TupleIdSequence(joined_tuple_ids.size());
-    case_positions.emplace_back(current_case_positions);
-
-    case_matches.resize(case_matches.size() + 1);
-    std::vector<std::pair<tuple_id, tuple_id>> &current_case_matches = case_matches.back();
-
-    const Predicate &case_predicate = *when_predicates_[case_idx];
-    for (tuple_id pos : else_positions) {
-      const std::pair<tuple_id, tuple_id> check_pair = joined_tuple_ids[pos];
-      if (case_predicate.matchesForJoinedTuples(*left_accessor,
-                                                left_relation_id,
-                                                check_pair.first,
-                                                *right_accessor,
-                                                right_relation_id,
-                                                check_pair.second)) {
-        current_case_positions->set(pos, true);
-        current_case_matches.emplace_back(check_pair);
-      }
-    }
-
-    else_positions.intersectWithComplement(*current_case_positions);
-  }
-
-  // Generate a ColumnVector of all the values for each case.
-  std::vector<std::unique_ptr<ColumnVector>> case_results;
-  for (std::vector<std::vector<std::pair<tuple_id, tuple_id>>>::size_type case_idx = 0;
-       case_idx < case_matches.size();
-       ++case_idx) {
-    case_results.emplace_back(result_expressions_[case_idx]->getAllValuesForJoin(
-        left_relation_id,
-        left_accessor,
-        right_relation_id,
-        right_accessor,
-        case_matches[case_idx]));
-  }
-
-  std::unique_ptr<ColumnVector> else_results;
-  if (!else_positions.empty()) {
-    std::vector<std::pair<tuple_id, tuple_id>> else_matches;
-    for (tuple_id pos : else_positions) {
-      else_matches.emplace_back(joined_tuple_ids[pos]);
-    }
-
-    else_results.reset(else_result_expression_->getAllValuesForJoin(
-        left_relation_id,
-        left_accessor,
-        right_relation_id,
-        right_accessor,
-        else_matches));
-  }
-
-  // Multiplex per-case results into a single ColumnVector with values in the
-  // correct positions.
-  return multiplexColumnVectors(
-      joined_tuple_ids.size(),
-      nullptr,
-      case_positions,
-      else_positions,
-      &case_results,
-      else_results.get());
-}
-
-void ScalarCaseExpression::MultiplexNativeColumnVector(
-    const TupleIdSequence *source_sequence,
-    const TupleIdSequence &case_matches,
-    const NativeColumnVector &case_result,
-    NativeColumnVector *output) {
-  if (source_sequence == nullptr) {
-    if (case_result.typeIsNullable()) {
-      TupleIdSequence::const_iterator output_pos_it = case_matches.begin();
-      for (std::size_t input_pos = 0;
-           input_pos < case_result.size();
-           ++input_pos, ++output_pos_it) {
-        const void *value = case_result.getUntypedValue<true>(input_pos);
-        if (value == nullptr) {
-          output->positionalWriteNullValue(*output_pos_it);
-        } else {
-          output->positionalWriteUntypedValue(*output_pos_it, value);
-        }
-      }
-    } else {
-      TupleIdSequence::const_iterator output_pos_it = case_matches.begin();
-      for (std::size_t input_pos = 0;
-           input_pos < case_result.size();
-           ++input_pos, ++output_pos_it) {
-        output->positionalWriteUntypedValue(*output_pos_it,
-                                            case_result.getUntypedValue<false>(input_pos));
-      }
-    }
-  } else {
-    if (case_result.typeIsNullable()) {
-      std::size_t input_pos = 0;
-      TupleIdSequence::const_iterator source_sequence_it = source_sequence->begin();
-      for (std::size_t output_pos = 0;
-           output_pos < output->size();
-           ++output_pos, ++source_sequence_it) {
-        if (case_matches.get(*source_sequence_it)) {
-          const void *value = case_result.getUntypedValue<true>(input_pos++);
-          if (value == nullptr) {
-            output->positionalWriteNullValue(output_pos);
-          } else {
-            output->positionalWriteUntypedValue(output_pos, value);
-          }
-        }
-      }
-    } else {
-      std::size_t input_pos = 0;
-      TupleIdSequence::const_iterator source_sequence_it = source_sequence->begin();
-      for (std::size_t output_pos = 0;
-           output_pos < output->size();
-           ++output_pos, ++source_sequence_it) {
-        if (case_matches.get(*source_sequence_it)) {
-          output->positionalWriteUntypedValue(output_pos,
-                                              case_result.getUntypedValue<false>(input_pos++));
-        }
-      }
-    }
-  }
-}
-
-void ScalarCaseExpression::MultiplexIndirectColumnVector(
-    const TupleIdSequence *source_sequence,
-    const TupleIdSequence &case_matches,
-    IndirectColumnVector *case_result,
-    IndirectColumnVector *output) {
-  if (source_sequence == nullptr) {
-    TupleIdSequence::const_iterator output_pos_it = case_matches.begin();
-    for (std::size_t input_pos = 0;
-         input_pos < case_result->size();
-         ++input_pos, ++output_pos_it) {
-      output->positionalWriteTypedValue(*output_pos_it,
-                                        case_result->moveTypedValue(input_pos));
-    }
-  } else {
-    std::size_t input_pos = 0;
-    TupleIdSequence::const_iterator source_sequence_it = source_sequence->begin();
-    for (std::size_t output_pos = 0;
-         output_pos < output->size();
-         ++output_pos, ++source_sequence_it) {
-      if (case_matches.get(*source_sequence_it)) {
-        output->positionalWriteTypedValue(output_pos,
-                                          case_result->moveTypedValue(input_pos++));
-      }
-    }
-  }
-}
-
-ColumnVector* ScalarCaseExpression::multiplexColumnVectors(
-    const std::size_t output_size,
-    const TupleIdSequence *source_sequence,
-    const std::vector<std::unique_ptr<TupleIdSequence>> &case_matches,
-    const TupleIdSequence &else_matches,
-    std::vector<std::unique_ptr<ColumnVector>> *case_results,
-    ColumnVector *else_result) const {
-  DCHECK_EQ(case_matches.size(), case_results->size());
-
-  if (NativeColumnVector::UsableForType(type_)) {
-    std::unique_ptr<NativeColumnVector> native_result(
-        new NativeColumnVector(type_, output_size));
-    native_result->prepareForPositionalWrites();
-
-    for (std::vector<std::unique_ptr<TupleIdSequence>>::size_type case_idx = 0;
-         case_idx < case_matches.size();
-         ++case_idx) {
-      DCHECK((*case_results)[case_idx]->isNative());
-      if (!case_matches[case_idx]->empty()) {
-        MultiplexNativeColumnVector(
-            source_sequence,
-            *case_matches[case_idx],
-            static_cast<const NativeColumnVector&>(*(*case_results)[case_idx]),
-            native_result.get());
-      }
-    }
-
-    if (else_result != nullptr) {
-      DCHECK(else_result->isNative());
-      DCHECK(!else_matches.empty());
-      MultiplexNativeColumnVector(source_sequence,
-                                  else_matches,
-                                  static_cast<const NativeColumnVector&>(*else_result),
-                                  native_result.get());
-    }
-
-    return native_result.release();
-  } else {
-    std::unique_ptr<IndirectColumnVector> indirect_result(
-        new IndirectColumnVector(type_, output_size));
-    indirect_result->prepareForPositionalWrites();
-
-    for (std::vector<std::unique_ptr<TupleIdSequence>>::size_type case_idx = 0;
-         case_idx < case_matches.size();
-         ++case_idx) {
-      DCHECK(!(*case_results)[case_idx]->isNative());
-      if (!case_matches[case_idx]->empty()) {
-        MultiplexIndirectColumnVector(
-            source_sequence,
-            *case_matches[case_idx],
-            static_cast<IndirectColumnVector*>((*case_results)[case_idx].get()),
-            indirect_result.get());
-      }
-    }
-
-    if (else_result != nullptr) {
-      DCHECK(!else_result->isNative());
-      DCHECK(!else_matches.empty());
-      MultiplexIndirectColumnVector(source_sequence,
-                                    else_matches,
-                                    static_cast<IndirectColumnVector*>(else_result),
-                                    indirect_result.get());
-    }
-
-    return indirect_result.release();
-  }
-}
-
-}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/ScalarCaseExpression.hpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarCaseExpression.hpp b/expressions/scalar/ScalarCaseExpression.hpp
deleted file mode 100644
index e6809fa..0000000
--- a/expressions/scalar/ScalarCaseExpression.hpp
+++ /dev/null
@@ -1,202 +0,0 @@
-/**
- * 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.
- **/
-
-#ifndef QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_CASE_EXPRESSION_HPP_
-#define QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_CASE_EXPRESSION_HPP_
-
-#include <cstddef>
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "catalog/CatalogTypedefs.hpp"
-#include "expressions/Expressions.pb.h"
-#include "expressions/predicate/Predicate.hpp"
-#include "expressions/scalar/Scalar.hpp"
-#include "storage/StorageBlockInfo.hpp"
-#include "types/TypedValue.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-class ColumnVector;
-class IndirectColumnVector;
-class NativeColumnVector;
-class TupleIdSequence;
-class Type;
-class ValueAccessor;
-
-struct SubBlocksReference;
-
-/** \addtogroup Expressions
- *  @{
- */
-
-/**
- * @brief A SQL CASE expression, which consists of one or more Predicates from
- *        WHEN clauses that map to Scalars which are evaluated conditionally
- *        for the first matching WHEN predicate. Also contains a Scalar for the
- *        ELSE case where no WHEN predicate matches.
- * @note This class implements the most general form of a SQL case expression,
- *       a "searched CASE" expression. For other forms of the CASE expression
- *       (e.g. "simple CASE") the optimizer is responsible for resolving into
- *       this general form.
- **/
-class ScalarCaseExpression : public Scalar {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param result_type The Type for values produced by this expression. Must
-   *        subsume the types of all result_expressions and
-   *        else_result_expression.
-   * @param when_predicates A vector of Predicates, one for each WHEN clause,
-   *        in descending order of priority. Will be moved-from.
-   * @param result_expressions A vector of Scalars, each of which is a THEN
-   *        expression corresponding to the WHEN clause in the same position in
-   *        when_predicates. Will be moved-from.
-   * @param else_result_expression A Scalar whose value will be used when none
-   *        of the when_predicates match. This is a required parameter. SQL
-   *        allows the ELSE clause of a CASE expression to be ommitted, in
-   *        which case it defaults to NULL. For compliance with the SQL
-   *        standard, an explicit ScalarLiteral with a NULL value should be
-   *        supplied here for such cases.
-   **/
-  ScalarCaseExpression(const Type &result_type,
-                       std::vector<std::unique_ptr<Predicate>> &&when_predicates,
-                       std::vector<std::unique_ptr<Scalar>> &&result_expressions,
-                       Scalar *else_result_expression);
-
-  ~ScalarCaseExpression() override {
-  }
-
-  serialization::Scalar getProto() const override;
-
-  Scalar* clone() const override;
-
-  ScalarDataSource getDataSource() const override {
-    return kCaseExpression;
-  }
-
-  TypedValue getValueForSingleTuple(const ValueAccessor &accessor,
-                                    const tuple_id tuple) const override;
-
-  TypedValue getValueForJoinedTuples(
-      const ValueAccessor &left_accessor,
-      const relation_id left_relation_id,
-      const tuple_id left_tuple_id,
-      const ValueAccessor &right_accessor,
-      const relation_id right_relation_id,
-      const tuple_id right_tuple_id) const override;
-
-  bool hasStaticValue() const override {
-    return has_static_value_;
-  }
-
-  const TypedValue& getStaticValue() const override {
-    DCHECK(has_static_value_);
-    return static_value_;
-  }
-
-  attribute_id getAttributeIdForValueAccessor() const override {
-    if (fixed_result_expression_ != nullptr) {
-      return fixed_result_expression_->getAttributeIdForValueAccessor();
-    } else {
-      return -1;
-    }
-  }
-
-  relation_id getRelationIdForValueAccessor() const override {
-    if (fixed_result_expression_ != nullptr) {
-      return fixed_result_expression_->getRelationIdForValueAccessor();
-    } else {
-      return -1;
-    }
-  }
-
-  ColumnVector* getAllValues(ValueAccessor *accessor,
-                             const SubBlocksReference *sub_blocks_ref) const override;
-
-  ColumnVector* getAllValuesForJoin(
-      const relation_id left_relation_id,
-      ValueAccessor *left_accessor,
-      const relation_id right_relation_id,
-      ValueAccessor *right_accessor,
-      const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const override;
-
- private:
-  // Merge the values in the NativeColumnVector 'case_result' into '*output' at
-  // the positions specified by 'case_matches'. If '*source_sequence' is
-  // non-NULL, it indicates which positions actually have tuples in the input,
-  // otherwise it is assumed that there are no holes in the input.
-  static void MultiplexNativeColumnVector(
-      const TupleIdSequence *source_sequence,
-      const TupleIdSequence &case_matches,
-      const NativeColumnVector &case_result,
-      NativeColumnVector *output);
-
-  // Same as MultiplexNativeColumnVector(), but works on IndirectColumnVectors
-  // instead of NativeColumnVectors.
-  static void MultiplexIndirectColumnVector(
-      const TupleIdSequence *source_sequence,
-      const TupleIdSequence &case_matches,
-      IndirectColumnVector *case_result,
-      IndirectColumnVector *output);
-
-  // Create and return a new ColumnVector by multiplexing the ColumnVectors
-  // containing results for individual CASE branches at the appropriate
-  // positions. 'output_size' is the total number of values in the output.
-  // '*source_sequence' indicates which positions actually have tuples in the
-  // input (if NULL, it is assumed there are no holes in the input).
-  // 'case_matches' are the sequences of tuple_ids matching each WHEN clause in
-  // order. 'else_matches' indicates the tuple_ids that did not match any of
-  // the explicit WHEN clauses. Similarly, '*case_results' are the values
-  // generated for the tuples matching each WHEN clause, and '*else_results'
-  // are the values generated for the ELSE tuples.
-  ColumnVector* multiplexColumnVectors(
-      const std::size_t output_size,
-      const TupleIdSequence *source_sequence,
-      const std::vector<std::unique_ptr<TupleIdSequence>> &case_matches,
-      const TupleIdSequence &else_matches,
-      std::vector<std::unique_ptr<ColumnVector>> *case_results,
-      ColumnVector *else_result) const;
-
-  std::vector<std::unique_ptr<Predicate>> when_predicates_;
-  std::vector<std::unique_ptr<Scalar>> result_expressions_;
-  std::unique_ptr<Scalar> else_result_expression_;
-
-  // If the CASE always evaluates to the same branch, this points to the result
-  // expression for that branch. Note that this is different from having a
-  // static value, because the result expression itself can have a
-  // tuple-dependent value.
-  const Scalar *fixed_result_expression_;
-
-  bool has_static_value_;
-  TypedValue static_value_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScalarCaseExpression);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif  // QUICKSTEP_EXPRESSIONS_SCALAR_SCALAR_CASE_EXPRESSION_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/scalar/ScalarLiteral.cpp
----------------------------------------------------------------------
diff --git a/expressions/scalar/ScalarLiteral.cpp b/expressions/scalar/ScalarLiteral.cpp
deleted file mode 100644
index 48b5574..0000000
--- a/expressions/scalar/ScalarLiteral.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * 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.
- **/
-
-#include "expressions/scalar/ScalarLiteral.hpp"
-
-#include <utility>
-#include <vector>
-
-#include "expressions/Expressions.pb.h"
-#include "storage/ValueAccessor.hpp"
-#include "types/Type.hpp"
-#include "types/Type.pb.h"
-#include "types/TypedValue.hpp"
-#include "types/TypedValue.pb.h"
-#include "types/containers/ColumnVector.hpp"
-
-namespace quickstep {
-
-serialization::Scalar ScalarLiteral::getProto() const {
-  serialization::Scalar proto;
-  proto.set_data_source(serialization::Scalar::LITERAL);
-  proto.MutableExtension(serialization::ScalarLiteral::literal)
-      ->CopyFrom(internal_literal_.getProto());
-  proto.MutableExtension(serialization::ScalarLiteral::literal_type)
-      ->CopyFrom(type_.getProto());
-
-  return proto;
-}
-
-Scalar* ScalarLiteral::clone() const {
-  return new ScalarLiteral(internal_literal_, type_);
-}
-
-ColumnVector* ScalarLiteral::getAllValues(
-    ValueAccessor *accessor,
-    const SubBlocksReference *sub_blocks_ref) const {
-  return ColumnVector::MakeVectorOfValue(
-      type_,
-      internal_literal_,
-      accessor->getNumTuplesVirtual());
-}
-
-ColumnVector* ScalarLiteral::getAllValuesForJoin(
-    const relation_id left_relation_id,
-    ValueAccessor *left_accessor,
-    const relation_id right_relation_id,
-    ValueAccessor *right_accessor,
-    const std::vector<std::pair<tuple_id, tuple_id>> &joined_tuple_ids) const {
-  return ColumnVector::MakeVectorOfValue(type_,
-                                         internal_literal_,
-                                         joined_tuple_ids.size());
-}
-
-}  // namespace quickstep



Mime
View raw message