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>> ¤t_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
