http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/table_generator/GenerateSeries.hpp ---------------------------------------------------------------------- diff --git a/expressions/table_generator/GenerateSeries.hpp b/expressions/table_generator/GenerateSeries.hpp deleted file mode 100644 index d749810..0000000 --- a/expressions/table_generator/GenerateSeries.hpp +++ /dev/null @@ -1,149 +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_TABLE_GENERATOR_GENERATE_SERIES_HPP_ -#define QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATE_SERIES_HPP_ - -#include <string> -#include <vector> - -#include "expressions/table_generator/GenerateSeriesHandle.hpp" -#include "expressions/table_generator/GeneratorFunction.hpp" -#include "types/Type.hpp" -#include "types/TypeFactory.hpp" -#include "types/TypeID.hpp" -#include "types/TypedValue.hpp" -#include "types/operations/comparisons/GreaterComparison.hpp" -#include "utility/Macros.hpp" - -#include "glog/logging.h" - -namespace quickstep { - -class GeneratorFunctionHandle; - -/** \addtogroup Expressions - * @{ - */ - -/** - * @brief GeneratorFunction that generates a series of values, from a start - * value to a stop value with a step size. - */ -class GenerateSeries : public GeneratorFunction { - public: - /** - * @brief Singleton instance of the GenerateSeries class. - * @return A const reference to the singleton instance of the GenerateSeries - * class. - */ - static const GenerateSeries& Instance() { - static GenerateSeries instance; - return instance; - } - - const std::string getName() const override { - return "generate_series"; - } - - const std::string getSyntax() const override { - return getName() + "(<start>, <end>[, <step>])"; - } - - GeneratorFunctionHandle* createHandle( - const std::vector<TypedValue> &arguments) const override { - // Checks arguments and create the function handle for generate_series. - - // Arguments should have the pattern (start, end) or (start, end, step). - int arg_size = arguments.size(); - if (arg_size != 2 && arg_size != 3) { - throw GeneratorFunctionInvalidArguments("Invalid number of arguments"); - } - - std::vector<const Type*> arg_types; - for (const TypedValue &arg : arguments) { - if (TypeFactory::TypeRequiresLengthParameter(arg.getTypeID())) { - throw GeneratorFunctionInvalidArguments("Invalid argument types"); - } - arg_types.emplace_back(&TypeFactory::GetType(arg.getTypeID())); - } - - // Get the unified type of all arguments. - const Type *unified_type = arg_types[0]; - for (int i = 1; i < arg_size && unified_type != nullptr; ++i) { - unified_type = - TypeFactory::GetUnifyingType(*arg_types[i], - *unified_type); - } - - // Check if the unified type if applicable, then create the handle. - if (unified_type != nullptr) { - TypeID tid = unified_type->getTypeID(); - if (tid == TypeID::kInt - || tid == TypeID::kLong - || tid == TypeID::kFloat - || tid == TypeID::kDouble) { - return concretizeWithType(arg_types, arguments, *unified_type); - } - } - throw GeneratorFunctionInvalidArguments("Invalid argument types"); - return nullptr; - } - - protected: - GenerateSeries() : GeneratorFunction() { - } - - private: - GeneratorFunctionHandle* concretizeWithType( - const std::vector<const Type*> &arg_types, - const std::vector<TypedValue> &args, - const Type &type) const { - DCHECK(args.size() == 2 || args.size() == 3); - - // Coerce all arguments to the unified type. - TypedValue start = type.coerceValue(args[0], *arg_types[0]); - TypedValue end = type.coerceValue(args[1], *arg_types[1]); - TypedValue step = - args.size() > 2 ? type.coerceValue(args[2], *arg_types[2]) - : type.coerceValue(TypedValue(1), TypeFactory::GetType(TypeID::kInt)); - - // Check that step is not 0, and (end - start) / step is positive - const GreaterComparison >_comparator = GreaterComparison::Instance(); - bool start_gt_end = gt_comparator.compareTypedValuesChecked(start, type, end, type); - bool step_gt_0 = gt_comparator.compareTypedValuesChecked( - step, type, TypedValue(0), TypeFactory::GetType(TypeID::kInt)); - bool step_lt_0 = gt_comparator.compareTypedValuesChecked( - TypedValue(0), TypeFactory::GetType(TypeID::kInt), step, type); - if ((!start_gt_end && step_lt_0) || (start_gt_end && step_gt_0)) { - throw GeneratorFunctionInvalidArguments("Invalid step width"); - } - - return new GenerateSeriesHandle(getName(), args, type, start, end, step); - } - - DISALLOW_COPY_AND_ASSIGN(GenerateSeries); -}; - - -/** @} */ - -} // namespace quickstep - -#endif /* QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATE_SERIES_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/table_generator/GenerateSeriesHandle.hpp ---------------------------------------------------------------------- diff --git a/expressions/table_generator/GenerateSeriesHandle.hpp b/expressions/table_generator/GenerateSeriesHandle.hpp deleted file mode 100644 index 594f12b..0000000 --- a/expressions/table_generator/GenerateSeriesHandle.hpp +++ /dev/null @@ -1,187 +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_TABLE_GENERATOR_GENERATE_SERIES_HANDLE_HPP_ -#define QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATE_SERIES_HANDLE_HPP_ - -#include <cstddef> -#include <cstdint> -#include <string> -#include <vector> - -#include "expressions/table_generator/GeneratorFunctionHandle.hpp" -#include "types/Type.hpp" -#include "types/TypeID.hpp" -#include "types/TypedValue.hpp" -#include "types/containers/ColumnVector.hpp" -#include "types/containers/ColumnVectorsValueAccessor.hpp" -#include "utility/Macros.hpp" - -#include "glog/logging.h" - -namespace quickstep { - -/** \addtogroup Expressions - * @{ - */ - -/** - * @brief Handle for the instantiated GenerateSeries function. - */ -class GenerateSeriesHandle : public GeneratorFunctionHandle { - public: - int getNumberOfOutputColumns() const override { - return 1; - } - - const std::string getOutputColumnName(int index) const override { - if (index > 0) { - LOG(FATAL) << "generate_series function has only 1 output column"; - } - // Use the function name as the column name. - return getName(); - } - - const Type& getOutputColumnType(int index) const override { - if (index > 0) { - LOG(FATAL) << "generate_series function has only 1 output column"; - } - return type_; - } - - std::size_t getEstimatedCardinality() const override { - switch (type_.getTypeID()) { - case TypeID::kInt: { - return estimateCardinality<int>(); - } - case TypeID::kLong: { - return estimateCardinality<std::int64_t>(); - } - case TypeID::kFloat: { - return estimateCardinality<float>(); - } - case TypeID::kDouble: { - return estimateCardinality<double>(); - } - default: - LOG(FATAL) << "GenerateSeries cannot handle arguments with type " - << type_.getName(); - } - return 0; - } - - void populateColumns(ColumnVectorsValueAccessor *results) const override { - DCHECK(results != nullptr); - - // Generate the output column. - NativeColumnVector *result_vec; - switch (type_.getTypeID()) { - case TypeID::kInt: { - result_vec = generateColumn<int>(); - break; - } - case TypeID::kLong: { - result_vec = generateColumn<std::int64_t>(); - break; - } - case TypeID::kFloat: { - result_vec = generateColumn<float>(); - break; - } - case TypeID::kDouble: { - result_vec = generateColumn<double>(); - break; - } - default: - // Should not reach here -- type checking should be done inside - // GenerateSeries::createHandle() at query compile time. - LOG(FATAL) << "GenerateSeries cannot handle arguments with type " - << type_.getName(); - } - // Add the output column into the ColumnVectorsValueAccessor container. - results->addColumn(result_vec); - } - - private: - /** - * @brief Constructor. A GenerateSeriesHandle object should only be - * instantiated inside method GenerateSeries::createHandle(). - * - * @param func_name The registered name of the GenerateSeries function. - * @param orig_args The original constant arguments to this function - * @param type The unified type for the arguments. - * @param start The start value. Its type should equal unified_type. - * @param end The end value. Its type should equal unified_type. - * @param step The step size. Its type should equal unified_type. - */ - GenerateSeriesHandle(const std::string &func_name, - const std::vector<TypedValue> &orig_args, - const Type &unified_type, - const TypedValue &start, - const TypedValue &end, - const TypedValue &step) - : GeneratorFunctionHandle(func_name, orig_args), - type_(unified_type), - start_(start), - end_(end), - step_(step) { - } - - template <typename T> - NativeColumnVector* generateColumn() const { - T start = start_.getLiteral<T>(); - T end = end_.getLiteral<T>(); - T step = step_.getLiteral<T>(); - - DCHECK_NE(step, static_cast<T>(0)); - std::size_t length = static_cast<std::size_t>((end - start) / step + 1); - DCHECK_GE(length, static_cast<std::size_t>(0)); - - NativeColumnVector *result_vec = new NativeColumnVector(type_, length); - T value = start; - for (std::size_t i = 0; i < length; ++i) { - result_vec->appendUntypedValue(&value); - value += step; - } - return result_vec; - } - - template <typename T> - std::size_t estimateCardinality() const { - T step = step_.getLiteral<T>(); - DCHECK_NE(step, static_cast<T>(0)); - return static_cast<std::size_t>( - (end_.getLiteral<T>() - start_.getLiteral<T>()) / step + 1); - } - - const Type &type_; - const TypedValue start_; - const TypedValue end_; - const TypedValue step_; - - friend class GenerateSeries; - - DISALLOW_COPY_AND_ASSIGN(GenerateSeriesHandle); -}; - -/** @} */ - -} // namespace quickstep - -#endif /* QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATE_SERIES_HANDLE_HPP_ */ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/table_generator/GeneratorFunction.hpp ---------------------------------------------------------------------- diff --git a/expressions/table_generator/GeneratorFunction.hpp b/expressions/table_generator/GeneratorFunction.hpp deleted file mode 100644 index b83a534..0000000 --- a/expressions/table_generator/GeneratorFunction.hpp +++ /dev/null @@ -1,135 +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_TABLE_GENERATOR_GENERATOR_FUNCTION_HPP_ -#define QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATOR_FUNCTION_HPP_ - -#include <exception> -#include <string> -#include <vector> - -#include "utility/Macros.hpp" - -namespace quickstep { - -class GeneratorFunctionHandle; -class TypedValue; - -/** \addtogroup Expressions - * @{ - */ - -/** - * @brief A class representing a particular generator function in the abstract - * sense. - * - * Generator functions are used for generating tables. A generator function - * takes a list of constant arguments at query compile time, and populates the - * given ColumnVectorValueAccesor at query run time. - * - * The GeneratorFunction class provides informational methods about the - * applicability of a particular generator function to particular constant - * arguments. The actual implementation of the generator functions' logic is in - * the GeneratorFunctionHandle class hierarchy, and can be different depending - * on the particular arguments given to the function. At query compile time, - * a caller should first call GeneratorFunction::generateHandle() to instantiate - * an GeneratorFunctionHandle object. The handle object provides information - * about the concrete function, e.g. the number and types of the output columns - * Then, at query run time, the backend also uses the handle object's methods - * to actually generate a table. - * - * To add a new generator function, subclass both GeneratorFunction and - * GeneratorFunctionHandle to implement the logics. Also add a line in - * GeneratorFunctionFactory's constructor to make the new function registered. - * - * See GenerateSeries and GenerateSeriesHandle as an example of how to implement - * new generator funcitons. - **/ -class GeneratorFunction { - public: - /** - * @brief Get the name of this generator function. The name should be unique - * as it is used to register this function into the generator function pool. - * - * @return The name of this generator function. - **/ - virtual const std::string getName() const = 0; - - /** - * @brief Get the usage syntax of this generator function in text form. The - * syntax information will be displayed when the end users ask for help - * on the usage of this function. - * - * @return The usage syntax of this generator function in text form. - **/ - virtual const std::string getSyntax() const = 0; - - /** - * @brief Create an GeneratorFunctionHandle. - * - * @param arguments A list of zero or more constant arguments to this - * generator funciton. - * @exception GeneratorFunctionInvalidArguments The arguments to this - * generator function are invalid. - * @return A new GeneratorFunctionHandle object that is used to do the actual - * table generation. Caller is responsible for deleting the returned - * object. - **/ - virtual GeneratorFunctionHandle* createHandle( - const std::vector<TypedValue> &arguments) const = 0; - - protected: - GeneratorFunction() { - } - - private: - DISALLOW_COPY_AND_ASSIGN(GeneratorFunction); -}; - - -/** - * @brief Exception thrown for invalid arguments to a generator function. - **/ -class GeneratorFunctionInvalidArguments : public std::exception { - public: - /** - * @brief Constructor. - * - * @param message The error message. - **/ - explicit GeneratorFunctionInvalidArguments(const std::string &message) - : message_(message) { - } - - ~GeneratorFunctionInvalidArguments() throw() { - } - - virtual const char* what() const throw() { - return message_.c_str(); - } - - private: - std::string message_; -}; - -/** @} */ - -} // namespace quickstep - -#endif /* QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATOR_FUNCTION_HPP_ */ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/table_generator/GeneratorFunction.proto ---------------------------------------------------------------------- diff --git a/expressions/table_generator/GeneratorFunction.proto b/expressions/table_generator/GeneratorFunction.proto deleted file mode 100644 index fc50a2f..0000000 --- a/expressions/table_generator/GeneratorFunction.proto +++ /dev/null @@ -1,27 +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. - -syntax = "proto2"; - -package quickstep.serialization; - -import "types/TypedValue.proto"; - -message GeneratorFunctionHandle { - required string function_name = 1; - repeated TypedValue args = 2; -} http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/table_generator/GeneratorFunctionFactory.cpp ---------------------------------------------------------------------- diff --git a/expressions/table_generator/GeneratorFunctionFactory.cpp b/expressions/table_generator/GeneratorFunctionFactory.cpp deleted file mode 100644 index b7dec8b..0000000 --- a/expressions/table_generator/GeneratorFunctionFactory.cpp +++ /dev/null @@ -1,73 +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/table_generator/GeneratorFunctionFactory.hpp" - -#include <string> -#include <utility> -#include <vector> - -#include "expressions/table_generator/GenerateSeries.hpp" -#include "expressions/table_generator/GeneratorFunction.hpp" -#include "expressions/table_generator/GeneratorFunction.pb.h" -#include "types/TypedValue.hpp" - -#include "glog/logging.h" - -namespace quickstep { - -GeneratorFunctionFactory::GeneratorFunctionFactory() { -#define REGISTER_GENERATOR_FUNCTION_(FuncClass) \ - func_map_.emplace(FuncClass::Instance().getName(), &FuncClass::Instance()) - - // Register all generator functions here. - REGISTER_GENERATOR_FUNCTION_(GenerateSeries); - -#undef REGISTER_GENERATOR_FUNCTION_ -} - -const GeneratorFunctionFactory& GeneratorFunctionFactory::Instance() { - static GeneratorFunctionFactory instance; - return instance; -} - -const GeneratorFunction* GeneratorFunctionFactory::getByName(const std::string &name) const { - const auto it = func_map_.find(name); - if (it != func_map_.end()) { - return it->second; - } else { - return nullptr; - } -} - -GeneratorFunctionHandle* GeneratorFunctionFactory::reconstructFromProto( - const serialization::GeneratorFunctionHandle &proto) const { - const GeneratorFunction *func_template = getByName(proto.function_name()); - CHECK(func_template != nullptr) - << "Generator function " << proto.function_name() << " not found"; - - std::vector<TypedValue> args; - for (const auto &arg_proto : proto.args()) { - args.emplace_back(TypedValue::ReconstructFromProto(arg_proto)); - } - - return func_template->createHandle(args); -} - -} // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/table_generator/GeneratorFunctionFactory.hpp ---------------------------------------------------------------------- diff --git a/expressions/table_generator/GeneratorFunctionFactory.hpp b/expressions/table_generator/GeneratorFunctionFactory.hpp deleted file mode 100644 index 1d9784a..0000000 --- a/expressions/table_generator/GeneratorFunctionFactory.hpp +++ /dev/null @@ -1,95 +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_TABLE_GENERATOR_GENERATOR_FUNCTION_FACTORY_HPP_ -#define QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATOR_FUNCTION_FACTORY_HPP_ - -#include <map> -#include <string> - -#include "utility/Macros.hpp" - -namespace quickstep { - -class GeneratorFunction; -class GeneratorFunctionHandle; - -namespace serialization { class GeneratorFunctionHandle; } - -/** \addtogroup Expressions - * @{ - */ - -/** - * @brief Singleton factory class that provides access to the various concrete - * implementations of GeneratorFunction. - * - * @note Generator functions are used for generating tables. A generator - * function takes a list of constant arguments at query compile time, - * and populates a table at query run time. See the documentation in - * GeneratorFunction.hpp for a detailed description and for how to - * implement a new generator function. - **/ -class GeneratorFunctionFactory { - public: - /** - * @brief Singleton instance of the GeneratorFunctionFactory class. - * @return A const reference to the singleton instance of the - * GeneratorFunctionFactory class. - */ - static const GeneratorFunctionFactory& Instance(); - - /** - * @brief Get a particular GeneratorFunction by its name. - * - * @param name The name of the desired GeneratorFunction. - * @return A pointer to the GeneratorFunction specified by name, or NULL if - * name does not match any known GeneratorFunction. - **/ - const GeneratorFunction* getByName(const std::string &name) const; - - /** - * @brief Reconstruct a particular GeneratorFunctionHandle by its protobuf - * message. - * - * @param proto A serialized protocol buffer representation of the - * GeneratorFunctionHandle. - * @return A new GeneratorFunctionHandle object constructed from the protobuf - * message. Caller is responsible for deleting the returned object. - */ - GeneratorFunctionHandle* reconstructFromProto( - const serialization::GeneratorFunctionHandle &proto) const; - - private: - /** - * @brief Constructor. All the implemented generator functions should be - * registered into GeneratorFunctionFactory inside the constructor. - */ - GeneratorFunctionFactory(); - - std::map<std::string, const GeneratorFunction *> func_map_; - - DISALLOW_COPY_AND_ASSIGN(GeneratorFunctionFactory); -}; - -/** @} */ - -} // namespace quickstep - -#endif // QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATOR_FUNCTION_FACTORY_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/table_generator/GeneratorFunctionHandle.hpp ---------------------------------------------------------------------- diff --git a/expressions/table_generator/GeneratorFunctionHandle.hpp b/expressions/table_generator/GeneratorFunctionHandle.hpp deleted file mode 100644 index b2fc068..0000000 --- a/expressions/table_generator/GeneratorFunctionHandle.hpp +++ /dev/null @@ -1,153 +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_TABLE_GENERATOR_GENERATOR_FUNCTION_HANDLE_HPP_ -#define QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATOR_FUNCTION_HANDLE_HPP_ - -#include <cstddef> -#include <memory> -#include <sstream> -#include <string> -#include <vector> - -#include "expressions/table_generator/GeneratorFunction.pb.h" -#include "types/TypedValue.hpp" -#include "types/TypedValue.pb.h" -#include "utility/Macros.hpp" - -namespace quickstep { - -class ColumnVectorsValueAccessor; -class Type; - -/** \addtogroup Expressions - * @{ - */ - -class GeneratorFunctionHandle; -typedef std::shared_ptr<const GeneratorFunctionHandle> GeneratorFunctionHandlePtr; - -/** - * @brief Abstract representation of a concrete generator function. - * - * This class abstracts the required facilities for a particular generator - * function to be usable by the query processor. - * - * To implement a particular generator function, one needs to subclass - * GeneratorFunctionHandle and implement the methods that provide the function - * signature information, i.e. the number of output columns and the value type - * of each output column, where this information will be used by the query - * processor to generate the query plan. Then, the subclass should implement - * the populateColumns() method which will actually populate a column-based - * table (abstracted as ColumnVectorsValueAccessor) at query run time. - **/ -class GeneratorFunctionHandle { - public: - /** - * @brief Get the number of output columns of this generator function. - * - * @return The number of output columns. - */ - virtual int getNumberOfOutputColumns() const = 0; - - /** - * @brief Get the default name of the specified output column. - * - * @param index The index of the output column. - * @return The name of the specified output column. - */ - virtual const std::string getOutputColumnName(int index) const { - std::ostringstream oss; - oss << "attr" << (index+1); - return oss.str(); - } - - /** - * @brief Get the type of the specified output column. - * - * @param index The index of the output column. - * @param The type of the specified output column - */ - virtual const Type &getOutputColumnType(int index) const = 0; - - /** - * @brief Get the estimated number of rows that the function will generate. - * - * @return The estimated number of rows that the function will generate. - */ - virtual std::size_t getEstimatedCardinality() const = 0; - - /** - * @brief Populate the given ColumnVectorsValueAccessor with data. - * - * @param results A mutable ColumnVectorsValueAccessor object that will be - * populated with data columns. - */ - virtual void populateColumns(ColumnVectorsValueAccessor *results) const = 0; - - /** - * @brief Get the name of this generator function. - * - * @return The name of this generator function. - **/ - const std::string &getName() const { - return func_name_; - } - - /** - * @brief Get the serialized protocol buffer representation of this generator - * function handle. - * @note To alleviate the burden of writing serialization for each - * implemenation of generator functions, the serialization will only - * take the function name and the original arguments. Then, the - * function handle will be regenerated by GeneratorFunctionFactory - * from the function name and arguemtns at the destination site. - * - * @return A serialized protocol buffer representation of this generator - * function handle. - **/ - serialization::GeneratorFunctionHandle getProto() const { - serialization::GeneratorFunctionHandle proto; - proto.set_function_name(func_name_); - - for (const TypedValue &arg : orig_args_) { - proto.add_args()->CopyFrom(arg.getProto()); - } - return proto; - } - - protected: - GeneratorFunctionHandle(const std::string &func_name, - const std::vector<TypedValue> &orig_args) - : func_name_(func_name), - orig_args_(orig_args) { - } - - private: - std::string func_name_; - std::vector<TypedValue> orig_args_; - - DISALLOW_COPY_AND_ASSIGN(GeneratorFunctionHandle); -}; - -/** @} */ - -} // namespace quickstep - -#endif /* QUICKSTEP_EXPRESSIONS_TABLE_GENERATOR_GENERATOR_FUNCTION_HANDLE_HPP_ */ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/CMakeLists.txt ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/CMakeLists.txt b/expressions/window_aggregation/CMakeLists.txt deleted file mode 100644 index b33a401..0000000 --- a/expressions/window_aggregation/CMakeLists.txt +++ /dev/null @@ -1,213 +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. - -QS_PROTOBUF_GENERATE_CPP(expressions_windowaggregation_WindowAggregateFunction_proto_srcs - expressions_windowaggregation_WindowAggregateFunction_proto_hdrs - WindowAggregateFunction.proto) - -# Declare micro-libs: -add_library(quickstep_expressions_windowaggregation_WindowAggregateFunction - WindowAggregateFunction.cpp - WindowAggregateFunction.hpp) -add_library(quickstep_expressions_windowaggregation_WindowAggregateFunction_proto - ${expressions_windowaggregation_WindowAggregateFunction_proto_srcs}) -add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionAvg - WindowAggregateFunctionAvg.cpp - WindowAggregateFunctionAvg.hpp) -add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionCount - WindowAggregateFunctionCount.cpp - WindowAggregateFunctionCount.hpp) -add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionFactory - WindowAggregateFunctionFactory.cpp - WindowAggregateFunctionFactory.hpp) -add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionMax - WindowAggregateFunctionMax.cpp - WindowAggregateFunctionMax.hpp) -add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionMin - WindowAggregateFunctionMin.cpp - WindowAggregateFunctionMin.hpp) -add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionSum - WindowAggregateFunctionSum.cpp - WindowAggregateFunctionSum.hpp) -add_library(quickstep_expressions_windowaggregation_WindowAggregationHandle - WindowAggregationHandle.cpp - WindowAggregationHandle.hpp) -add_library(quickstep_expressions_windowaggregation_WindowAggregationHandleAvg - WindowAggregationHandleAvg.cpp - WindowAggregationHandleAvg.hpp) -add_library(quickstep_expressions_windowaggregation_WindowAggregationID - ../../empty_src.cpp - WindowAggregationID.hpp) - -# Link dependencies: -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunction - glog - quickstep_catalog_CatalogTypedefs - quickstep_expressions_windowaggregation_WindowAggregateFunction_proto - quickstep_expressions_windowaggregation_WindowAggregationID - quickstep_storage_StorageBlockInfo - quickstep_utility_Macros) -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunction_proto - ${PROTOBUF_LIBRARY}) -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionAvg - glog - quickstep_expressions_windowaggregation_WindowAggregateFunction - quickstep_expressions_windowaggregation_WindowAggregationHandleAvg - quickstep_expressions_windowaggregation_WindowAggregationID - quickstep_types_Type - quickstep_types_TypeFactory - quickstep_types_TypeID - quickstep_types_operations_binaryoperations_BinaryOperation - quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID - quickstep_utility_Macros) -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionCount - glog - quickstep_expressions_windowaggregation_WindowAggregateFunction - quickstep_expressions_windowaggregation_WindowAggregationHandle - quickstep_expressions_windowaggregation_WindowAggregationID - quickstep_types_Type - quickstep_types_TypeFactory - quickstep_types_TypeID - quickstep_utility_Macros) -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionFactory - glog - quickstep_expressions_windowaggregation_WindowAggregateFunctionAvg - quickstep_expressions_windowaggregation_WindowAggregateFunctionCount - quickstep_expressions_windowaggregation_WindowAggregateFunctionMax - quickstep_expressions_windowaggregation_WindowAggregateFunctionMin - quickstep_expressions_windowaggregation_WindowAggregateFunctionSum - quickstep_expressions_windowaggregation_WindowAggregateFunction_proto - quickstep_expressions_windowaggregation_WindowAggregationID - quickstep_utility_Macros) -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionMax - glog - quickstep_expressions_windowaggregation_WindowAggregateFunction - quickstep_expressions_windowaggregation_WindowAggregationHandle - quickstep_expressions_windowaggregation_WindowAggregationID - quickstep_types_Type - quickstep_types_operations_comparisons_Comparison - quickstep_types_operations_comparisons_ComparisonFactory - quickstep_types_operations_comparisons_ComparisonID - quickstep_utility_Macros) -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionMin - glog - quickstep_expressions_windowaggregation_WindowAggregateFunction - quickstep_expressions_windowaggregation_WindowAggregationHandle - quickstep_expressions_windowaggregation_WindowAggregationID - quickstep_types_Type - quickstep_types_operations_comparisons_Comparison - quickstep_types_operations_comparisons_ComparisonFactory - quickstep_types_operations_comparisons_ComparisonID - quickstep_utility_Macros) -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionSum - glog - quickstep_expressions_windowaggregation_WindowAggregateFunction - quickstep_expressions_windowaggregation_WindowAggregationHandle - quickstep_expressions_windowaggregation_WindowAggregationID - quickstep_types_Type - quickstep_types_TypeFactory - quickstep_types_TypeID - quickstep_types_operations_binaryoperations_BinaryOperation - quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID - quickstep_utility_Macros) -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregationHandle - glog - quickstep_catalog_CatalogRelationSchema - quickstep_catalog_CatalogTypedefs - quickstep_expressions_scalar_Scalar - quickstep_storage_StorageBlockInfo - quickstep_types_Type - quickstep_types_TypeFactory - quickstep_types_TypeID - quickstep_types_TypedValue - quickstep_types_containers_ColumnVector - quickstep_types_containers_ColumnVectorsValueAccessor - quickstep_types_operations_binaryoperations_BinaryOperation - quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID - quickstep_types_operations_comparisons_Comparison - quickstep_types_operations_comparisons_ComparisonFactory - quickstep_types_operations_comparisons_ComparisonID - quickstep_utility_Macros) -target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregationHandleAvg - glog - quickstep_catalog_CatalogTypedefs - quickstep_expressions_windowaggregation_WindowAggregationHandle - quickstep_storage_ValueAccessor - quickstep_types_Type - quickstep_types_TypeFactory - quickstep_types_TypeID - quickstep_types_TypedValue - quickstep_types_containers_ColumnVectorsValueAccessor - quickstep_types_operations_binaryoperations_BinaryOperation - quickstep_types_operations_binaryoperations_BinaryOperationFactory - quickstep_types_operations_binaryoperations_BinaryOperationID - quickstep_types_operations_comparisons_Comparison - quickstep_utility_Macros) - -# Submodule all-in-one library: -add_library(quickstep_expressions_windowaggregation ../../empty_src.cpp) -target_link_libraries(quickstep_expressions_windowaggregation - quickstep_expressions_windowaggregation_WindowAggregateFunction - quickstep_expressions_windowaggregation_WindowAggregateFunction_proto - quickstep_expressions_windowaggregation_WindowAggregateFunctionAvg - quickstep_expressions_windowaggregation_WindowAggregateFunctionCount - quickstep_expressions_windowaggregation_WindowAggregateFunctionFactory - quickstep_expressions_windowaggregation_WindowAggregateFunctionMax - quickstep_expressions_windowaggregation_WindowAggregateFunctionMin - quickstep_expressions_windowaggregation_WindowAggregateFunctionSum - quickstep_expressions_windowaggregation_WindowAggregationHandle - quickstep_expressions_windowaggregation_WindowAggregationHandleAvg - quickstep_expressions_windowaggregation_WindowAggregationID) - -# Tests: - -# Unified executable to ammortize cost of linking. -add_executable(WindowAggregationHandle_tests - "${CMAKE_CURRENT_SOURCE_DIR}/tests/WindowAggregationHandleAvg_unittest.cpp") -target_link_libraries(WindowAggregationHandle_tests - gtest - gtest_main - quickstep_catalog_CatalogAttribute - quickstep_catalog_CatalogTypedefs - quickstep_expressions_scalar_Scalar - quickstep_expressions_scalar_ScalarAttribute - quickstep_expressions_windowaggregation_WindowAggregateFunction - quickstep_expressions_windowaggregation_WindowAggregateFunctionFactory - quickstep_expressions_windowaggregation_WindowAggregationHandle - quickstep_expressions_windowaggregation_WindowAggregationID - quickstep_storage_ValueAccessor - quickstep_types_CharType - quickstep_types_DateOperatorOverloads - quickstep_types_DatetimeIntervalType - quickstep_types_DatetimeType - quickstep_types_DoubleType - quickstep_types_FloatType - quickstep_types_IntType - quickstep_types_IntervalLit - quickstep_types_LongType - quickstep_types_Type - quickstep_types_TypeFactory - quickstep_types_TypeID - quickstep_types_TypedValue - quickstep_types_VarCharType - quickstep_types_YearMonthIntervalType - quickstep_types_containers_ColumnVector - quickstep_types_containers_ColumnVectorsValueAccessor) -add_test(WindowAggregationHandle_tests WindowAggregationHandle_tests) http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunction.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunction.cpp b/expressions/window_aggregation/WindowAggregateFunction.cpp deleted file mode 100644 index db208a9..0000000 --- a/expressions/window_aggregation/WindowAggregateFunction.cpp +++ /dev/null @@ -1,58 +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/window_aggregation/WindowAggregateFunction.hpp" - -#include <type_traits> - -#include "expressions/window_aggregation/WindowAggregateFunction.pb.h" -#include "expressions/window_aggregation/WindowAggregationID.hpp" - -#include "glog/logging.h" - -namespace quickstep { - -serialization::WindowAggregateFunction WindowAggregateFunction::getProto() const { - serialization::WindowAggregateFunction proto; - switch (win_agg_id_) { - case WindowAggregationID::kAvg: - proto.set_window_aggregation_id(serialization::WindowAggregateFunction::AVG); - break; - case WindowAggregationID::kCount: - proto.set_window_aggregation_id(serialization::WindowAggregateFunction::COUNT); - break; - case WindowAggregationID::kMax: - proto.set_window_aggregation_id(serialization::WindowAggregateFunction::MAX); - break; - case WindowAggregationID::kMin: - proto.set_window_aggregation_id(serialization::WindowAggregateFunction::MIN); - break; - case WindowAggregationID::kSum: - proto.set_window_aggregation_id(serialization::WindowAggregateFunction::SUM); - break; - default: { - LOG(FATAL) << "Unrecognized WindowAggregationID: " - << static_cast<std::underlying_type<WindowAggregationID>::type>(win_agg_id_); - } - } - - return proto; -} - -} // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunction.hpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunction.hpp b/expressions/window_aggregation/WindowAggregateFunction.hpp deleted file mode 100644 index 2b26ccf..0000000 --- a/expressions/window_aggregation/WindowAggregateFunction.hpp +++ /dev/null @@ -1,158 +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_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_HPP_ -#define QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_HPP_ - -#include <memory> -#include <string> -#include <vector> - -#include "catalog/CatalogTypedefs.hpp" -#include "expressions/window_aggregation/WindowAggregateFunction.pb.h" -#include "expressions/window_aggregation/WindowAggregationID.hpp" -#include "storage/StorageBlockInfo.hpp" -#include "utility/Macros.hpp" - -namespace quickstep { - -class CatalogRelationSchema; -class Scalar; -class Type; -class WindowAggregationHandle; - -/** \addtogroup Expressions - * @{ - */ - -/** - * @brief A class representing a particular window aggregate function in the - * abstract sense. Each named aggregate function is represented by a - * singleton subclass of WindowAggregateFunction. - * - * WindowAggregateFunction provides informational methods about the - * applicability of a particular window aggregate function to particular - * argument Type(s). The actual implementation of the window aggregate - * functions' logic is in the WindowAggregationHandle class hierarchy, and can - * be different depending on the particular argument Type(s) given to the window - * aggregate. To perform a window aggregation, a caller should first call - * WindowAggregateFunction::createHandle() to instantiate an - * WindowAggregationHandle object, then use the methods of - * WindowAggregationHandle to do the actual window aggregation. Finally, delete - * the WindowAggregationHandle after finished. - * - * See WindowAggregationHandle for more detailed information about how - * window aggregates are actually computed. - **/ -class WindowAggregateFunction { - public: - /** - * @brief Get the ID of this window aggregate (i.e. its unique ID amongst all - * the WindowAggregateFunctions). - * - * @return The WindowAggregationID of this WindowAggregateFunction. - **/ - inline WindowAggregationID getWindowAggregationID() const { - return win_agg_id_; - } - - /** - * @brief Get the human-readable name of this WindowAggregateFunction. - * - * @return The human-readable name of this WindowAggregateFunction. - **/ - virtual std::string getName() const = 0; - - /** - * @brief Get the serialized protocol buffer representation of this - * WindowAggregateFunction. - * - * @return A serialized protocol buffer representation of this - * WindowAggregateFunction. - **/ - virtual serialization::WindowAggregateFunction getProto() const; - - /** - * @brief Determine if this WindowAggregateFunction can be applied to - * arguments of particular Type(s). - * - * @param argument_types A list of zero or more Types (in order) for - * arguments to this WindowAggregateFunction. - * @return Whether this WindowAggregateFunction is applicable to the given - * argument_types. - **/ - virtual bool canApplyToTypes( - const std::vector<const Type*> &argument_types) const = 0; - - /** - * @brief Determine the result Type for this WindowAggregateFunction given - * arguments of particular Type(s). - * - * @param argument_types A list of zero or more Types (in order) for - * arguments to this WindowAggregateFunction. - * @return The result Type for this WindowAggregateFunction applied to the - * specified argument_types, or nullptr if this - * WindowAggregateFunction is not applicable to the specified Type(s). - **/ - virtual const Type* resultTypeForArgumentTypes( - const std::vector<const Type*> &argument_types) const = 0; - - /** - * @brief Create a WindowAggregationHandle to compute aggregates. - * - * @warning It is an error to call this method for argument_types which this - * WindowAggregateFunction can not apply to. For safety, check - * canApplyToTypes() first. - * - * @param argument_types A list of zero or more Types (in order) for - * arguments to this WindowAggregateFunction. - * @param partition_by_attributes A list of attributes used as partition key. - * @param order_by_attributes A list of attributes used as order key. - * @param is_row True if the frame mode is ROWS, false if RANGE. - * @param num_preceding The number of rows/range that precedes the current row. - * @param num_following The number of rows/range that follows the current row. - * - * @return A new WindowAggregationHandle that can be used to compute this - * WindowAggregateFunction over the specified window definition. - * Caller is responsible for deleting the returned object. - **/ - virtual WindowAggregationHandle* createHandle( - const std::vector<const Type*> &argument_types, - const std::vector<std::unique_ptr<const Scalar>> &partition_by_attributes, - const std::vector<std::unique_ptr<const Scalar>> &order_by_attributes, - const bool is_row, - const std::int64_t num_preceding, - const std::int64_t num_following) const = 0; - - protected: - explicit WindowAggregateFunction(const WindowAggregationID win_agg_id) - : win_agg_id_(win_agg_id) { - } - - private: - const WindowAggregationID win_agg_id_; - - DISALLOW_COPY_AND_ASSIGN(WindowAggregateFunction); -}; - -/** @} */ - -} // namespace quickstep - -#endif // QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunction.proto ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunction.proto b/expressions/window_aggregation/WindowAggregateFunction.proto deleted file mode 100644 index 8667422..0000000 --- a/expressions/window_aggregation/WindowAggregateFunction.proto +++ /dev/null @@ -1,32 +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. - -syntax = "proto2"; - -package quickstep.serialization; - -message WindowAggregateFunction { - enum WindowAggregationID { - AVG = 0; - COUNT = 1; - MAX = 2; - MIN = 3; - SUM = 4; - } - - required WindowAggregationID window_aggregation_id = 1; -} http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunctionAvg.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionAvg.cpp b/expressions/window_aggregation/WindowAggregateFunctionAvg.cpp deleted file mode 100644 index 20c296b..0000000 --- a/expressions/window_aggregation/WindowAggregateFunctionAvg.cpp +++ /dev/null @@ -1,93 +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/window_aggregation/WindowAggregateFunctionAvg.hpp" - -#include <vector> - -#include "expressions/window_aggregation/WindowAggregationHandleAvg.hpp" -#include "types/Type.hpp" -#include "types/TypeFactory.hpp" -#include "types/TypeID.hpp" -#include "types/operations/binary_operations/BinaryOperation.hpp" -#include "types/operations/binary_operations/BinaryOperationFactory.hpp" -#include "types/operations/binary_operations/BinaryOperationID.hpp" - -#include "glog/logging.h" - -namespace quickstep { - -bool WindowAggregateFunctionAvg::canApplyToTypes( - const std::vector<const Type*> &argument_types) const { - // AVG is unary. - if (argument_types.size() != 1) { - return false; - } - - // Argument must be addable and divisible. - return BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd) - .canApplyToTypes(*argument_types.front(), *argument_types.front()) && - BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .canApplyToTypes(*argument_types.front(), TypeFactory::GetType(kDouble)); -} - -const Type* WindowAggregateFunctionAvg::resultTypeForArgumentTypes( - const std::vector<const Type*> &argument_types) const { - if (!canApplyToTypes(argument_types)) { - return nullptr; - } - - // The type used to sum values is nullable, and we automatically widen int to - // long and float to double to have more headroom when adding up many values. - const Type *sum_type = &(argument_types.front()->getNullableVersion()); - switch (sum_type->getTypeID()) { - case kInt: - sum_type = &TypeFactory::GetType(kLong, true); - break; - case kFloat: - sum_type = &TypeFactory::GetType(kDouble, true); - break; - default: - break; - } - - return BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kDivide) - .resultTypeForArgumentTypes(*sum_type, TypeFactory::GetType(kDouble)); -} - -WindowAggregationHandle* WindowAggregateFunctionAvg::createHandle( - const std::vector<const Type*> &argument_types, - const std::vector<std::unique_ptr<const Scalar>> &partition_by_attributes, - const std::vector<std::unique_ptr<const Scalar>> &order_by_attributes, - const bool is_row, - const std::int64_t num_preceding, - const std::int64_t num_following) const { - DCHECK(canApplyToTypes(argument_types)) - << "Attempted to create an WindowAggregationHandleAvg for argument Type(s)" - << " that AVG can not be applied to."; - - return new WindowAggregationHandleAvg(partition_by_attributes, - order_by_attributes, - is_row, - num_preceding, - num_following, - argument_types[0]); -} - -} // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunctionAvg.hpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionAvg.hpp b/expressions/window_aggregation/WindowAggregateFunctionAvg.hpp deleted file mode 100644 index 1706ce8..0000000 --- a/expressions/window_aggregation/WindowAggregateFunctionAvg.hpp +++ /dev/null @@ -1,79 +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_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_AVG_HPP_ -#define QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_AVG_HPP_ - -#include <string> -#include <vector> - -#include "expressions/window_aggregation/WindowAggregateFunction.hpp" -#include "expressions/window_aggregation/WindowAggregationID.hpp" -#include "utility/Macros.hpp" - -namespace quickstep { - -class Type; -class WindowAggregationHandle; - -/** \addtogroup Expressions - * @{ - */ - -/** - * @brief WindowAggregateFunction representing SQL AVG() OVER term. - **/ -class WindowAggregateFunctionAvg : public WindowAggregateFunction { - public: - static const WindowAggregateFunctionAvg& Instance() { - static WindowAggregateFunctionAvg instance; - return instance; - } - - std::string getName() const override { - return "AVG"; - } - - bool canApplyToTypes( - const std::vector<const Type*> &argument_types) const override; - - const Type* resultTypeForArgumentTypes( - const std::vector<const Type*> &argument_types) const override; - - WindowAggregationHandle* createHandle( - const std::vector<const Type*> &argument_types, - const std::vector<std::unique_ptr<const Scalar>> &partition_by_attributes, - const std::vector<std::unique_ptr<const Scalar>> &order_by_attributes, - const bool is_row, - const std::int64_t num_preceding, - const std::int64_t num_following) const override; - - private: - WindowAggregateFunctionAvg() - : WindowAggregateFunction(WindowAggregationID::kAvg) { - } - - DISALLOW_COPY_AND_ASSIGN(WindowAggregateFunctionAvg); -}; - -/** @} */ - -} // namespace quickstep - -#endif // QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_AVG_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunctionCount.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionCount.cpp b/expressions/window_aggregation/WindowAggregateFunctionCount.cpp deleted file mode 100644 index 9290ac0..0000000 --- a/expressions/window_aggregation/WindowAggregateFunctionCount.cpp +++ /dev/null @@ -1,63 +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/window_aggregation/WindowAggregateFunctionCount.hpp" - -#include <vector> - -#include "expressions/window_aggregation/WindowAggregationHandle.hpp" -#include "types/Type.hpp" -#include "types/TypeFactory.hpp" -#include "types/TypeID.hpp" - -#include "glog/logging.h" - -namespace quickstep { - -bool WindowAggregateFunctionCount::canApplyToTypes( - const std::vector<const Type*> &argument_types) const { - // COUNT may be nullary (i.e. COUNT(*)) or unary. - return argument_types.size() <= 1; -} - -const Type* WindowAggregateFunctionCount::resultTypeForArgumentTypes( - const std::vector<const Type*> &argument_types) const { - if (!canApplyToTypes(argument_types)) { - return nullptr; - } - - return &TypeFactory::GetType(kLong); -} - -WindowAggregationHandle* WindowAggregateFunctionCount::createHandle( - const std::vector<const Type*> &argument_types, - const std::vector<std::unique_ptr<const Scalar>> &partition_by_attributes, - const std::vector<std::unique_ptr<const Scalar>> &order_by_attributes, - const bool is_row, - const std::int64_t num_preceding, - const std::int64_t num_following) const { - DCHECK(canApplyToTypes(argument_types)) - << "Attempted to create a WindowAggregationHandleCount for argument Types " - << "that COUNT can not be applied to (> 1 argument)."; - - // TODO(Shixuan): Add handle for Count. - return nullptr; -} - -} // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunctionCount.hpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionCount.hpp b/expressions/window_aggregation/WindowAggregateFunctionCount.hpp deleted file mode 100644 index f508105..0000000 --- a/expressions/window_aggregation/WindowAggregateFunctionCount.hpp +++ /dev/null @@ -1,79 +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_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_COUNT_HPP_ -#define QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_COUNT_HPP_ - -#include <string> -#include <vector> - -#include "expressions/window_aggregation/WindowAggregateFunction.hpp" -#include "expressions/window_aggregation/WindowAggregationID.hpp" -#include "utility/Macros.hpp" - -namespace quickstep { - -class Type; -class WindowAggregationHandle; - -/** \addtogroup Expressions - * @{ - */ - -/** - * @brief WindowAggregateFunction representing SQL COUNT() OVER term. - **/ -class WindowAggregateFunctionCount : public WindowAggregateFunction { - public: - static const WindowAggregateFunctionCount& Instance() { - static WindowAggregateFunctionCount instance; - return instance; - } - - std::string getName() const override { - return "COUNT"; - } - - bool canApplyToTypes( - const std::vector<const Type*> &argument_types) const override; - - const Type* resultTypeForArgumentTypes( - const std::vector<const Type*> &argument_types) const override; - - WindowAggregationHandle* createHandle( - const std::vector<const Type*> &argument_types, - const std::vector<std::unique_ptr<const Scalar>> &partition_by_attributes, - const std::vector<std::unique_ptr<const Scalar>> &order_by_attributes, - const bool is_row, - const std::int64_t num_preceding, - const std::int64_t num_following) const override; - - private: - WindowAggregateFunctionCount() - : WindowAggregateFunction(WindowAggregationID::kCount) { - } - - DISALLOW_COPY_AND_ASSIGN(WindowAggregateFunctionCount); -}; - -/** @} */ - -} // namespace quickstep - -#endif // QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_COUNT_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunctionFactory.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionFactory.cpp b/expressions/window_aggregation/WindowAggregateFunctionFactory.cpp deleted file mode 100644 index bb5d02e..0000000 --- a/expressions/window_aggregation/WindowAggregateFunctionFactory.cpp +++ /dev/null @@ -1,106 +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/window_aggregation/WindowAggregateFunctionFactory.hpp" - -#include <string> -#include <type_traits> - -#include "expressions/window_aggregation/WindowAggregateFunction.pb.h" -#include "expressions/window_aggregation/WindowAggregateFunctionAvg.hpp" -#include "expressions/window_aggregation/WindowAggregateFunctionCount.hpp" -#include "expressions/window_aggregation/WindowAggregateFunctionMax.hpp" -#include "expressions/window_aggregation/WindowAggregateFunctionMin.hpp" -#include "expressions/window_aggregation/WindowAggregateFunctionSum.hpp" -#include "expressions/window_aggregation/WindowAggregationID.hpp" - -#include "glog/logging.h" - -namespace quickstep { - -const WindowAggregateFunction& WindowAggregateFunctionFactory::Get( - const WindowAggregationID agg_id) { - switch (agg_id) { - case WindowAggregationID::kAvg: - return WindowAggregateFunctionAvg::Instance(); - case WindowAggregationID::kCount: - return WindowAggregateFunctionCount::Instance(); - case WindowAggregationID::kMax: - return WindowAggregateFunctionMax::Instance(); - case WindowAggregationID::kMin: - return WindowAggregateFunctionMin::Instance(); - case WindowAggregationID::kSum: - return WindowAggregateFunctionSum::Instance(); - default: { - LOG(FATAL) << "Unrecognized WindowAggregationID: " - << static_cast<std::underlying_type<WindowAggregationID>::type>(agg_id); - } - } -} - -const WindowAggregateFunction* WindowAggregateFunctionFactory::GetByName( - const std::string &name) { - if (name == "avg") { - return &WindowAggregateFunctionAvg::Instance(); - } else if (name == "count") { - return &WindowAggregateFunctionCount::Instance(); - } else if (name == "max") { - return &WindowAggregateFunctionMax::Instance(); - } else if (name == "min") { - return &WindowAggregateFunctionMin::Instance(); - } else if (name == "sum") { - return &WindowAggregateFunctionSum::Instance(); - } else { - return nullptr; - } -} - -bool WindowAggregateFunctionFactory::ProtoIsValid( - const serialization::WindowAggregateFunction &proto) { - return proto.IsInitialized() && - serialization::WindowAggregateFunction::WindowAggregationID_IsValid(proto.window_aggregation_id()); -} - -const WindowAggregateFunction& WindowAggregateFunctionFactory::ReconstructFromProto( - const serialization::WindowAggregateFunction &proto) { - DCHECK(ProtoIsValid(proto)) - << "Attempted to reconstruct an WindowAggregateFunction from an invalid proto:\n" - << proto.DebugString(); - - switch (proto.window_aggregation_id()) { - case serialization::WindowAggregateFunction::AVG: - return WindowAggregateFunctionAvg::Instance(); - case serialization::WindowAggregateFunction::COUNT: - return WindowAggregateFunctionCount::Instance(); - case serialization::WindowAggregateFunction::MAX: - return WindowAggregateFunctionMax::Instance(); - case serialization::WindowAggregateFunction::MIN: - return WindowAggregateFunctionMin::Instance(); - case serialization::WindowAggregateFunction::SUM: - return WindowAggregateFunctionSum::Instance(); - default: { - LOG(FATAL) << "Unrecognized serialization::WindowAggregateFunction::WindowAggregationID: " - << proto.window_aggregation_id() - << "\nFull proto debug string:\n" - << proto.DebugString(); - } - } -} - -} // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunctionFactory.hpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionFactory.hpp b/expressions/window_aggregation/WindowAggregateFunctionFactory.hpp deleted file mode 100644 index e572b13..0000000 --- a/expressions/window_aggregation/WindowAggregateFunctionFactory.hpp +++ /dev/null @@ -1,96 +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_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_FACTORY_HPP_ -#define QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_FACTORY_HPP_ - -#include <string> - -#include "expressions/window_aggregation/WindowAggregationID.hpp" -#include "utility/Macros.hpp" - -namespace quickstep { - -class WindowAggregateFunction; -namespace serialization { class WindowAggregateFunction; } - -/** \addtogroup Expressions - * @{ - */ - -/** - * @brief All-static factory with methods that provide access to the various - * concrete implementations of WindowAggregateFunction. - * - * WindowAggregateFunctionFactory allows client code to use any - * WindowAggregateFunction in Quickstep in a generic way without having to know - * about all the specific subclasses of WindowAggregateFunction. In particular, - * it is used to deserialize WindowAggregateFunctions used in - * WindowAggregationOperationState from their protobuf representations - * (originally created by the optimizer) when deserializing a QueryContext. - **/ -namespace WindowAggregateFunctionFactory { - /** - * @brief Get a particular WindowAggregateFunction by its ID. - * - * @param agg_id The ID of the desired WindowAggregateFunction. - * @return A reference to the singleton instance of the - * WindowAggregateFunction specified by agg_id. - **/ - const WindowAggregateFunction& Get(const WindowAggregationID agg_id); - - /** - * @brief Get a particular WindowAggregateFunction by its name in SQL syntax. - * - * @param name The name of the desired WindowAggregateFunction in lower case. - * @return A pointer to the WindowAggregateFunction specified by name, or NULL - * if name does not match any known WindowAggregateFunction. - **/ - const WindowAggregateFunction* GetByName(const std::string &name); - - /** - * @brief Determine if a serialized protobuf representation of a - * WindowAggregateFunction is fully-formed and valid. - * - * @param proto A serialized protobuf representation of a - * WindowAggregateFunction to check for validity. - * @return Whether proto is fully-formed and valid. - **/ - bool ProtoIsValid(const serialization::WindowAggregateFunction &proto); - - /** - * @brief Get the WindowAggregateFunction represented by a proto. - * - * @warning It is an error to call this method with an invalid proto. - * ProtoIsValid() should be called first to check. - * - * @param proto A serialized protobuf representation of a - * WindowAggregateFunction. - * @return The WindowAggregateFunction represented by proto. - **/ - const WindowAggregateFunction& ReconstructFromProto( - const serialization::WindowAggregateFunction &proto); - -} // namespace WindowAggregateFunctionFactory - -/** @} */ - -} // namespace quickstep - -#endif // QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_FACTORY_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunctionMax.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionMax.cpp b/expressions/window_aggregation/WindowAggregateFunctionMax.cpp deleted file mode 100644 index 594301a..0000000 --- a/expressions/window_aggregation/WindowAggregateFunctionMax.cpp +++ /dev/null @@ -1,71 +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/window_aggregation/WindowAggregateFunctionMax.hpp" - -#include <vector> - -#include "expressions/window_aggregation/WindowAggregationHandle.hpp" -#include "types/Type.hpp" -#include "types/operations/comparisons/Comparison.hpp" -#include "types/operations/comparisons/ComparisonFactory.hpp" -#include "types/operations/comparisons/ComparisonID.hpp" - -#include "glog/logging.h" - -namespace quickstep { - -bool WindowAggregateFunctionMax::canApplyToTypes( - const std::vector<const Type*> &argument_types) const { - // MAX is unary. - if (argument_types.size() != 1) { - return false; - } - - // Argument must be comparable by '>'. - return ComparisonFactory::GetComparison(ComparisonID::kGreater).canCompareTypes( - *argument_types.front(), - *argument_types.front()); -} - -const Type* WindowAggregateFunctionMax::resultTypeForArgumentTypes( - const std::vector<const Type*> &argument_types) const { - if (!canApplyToTypes(argument_types)) { - return nullptr; - } - - return &(argument_types.front()->getNullableVersion()); -} - -WindowAggregationHandle* WindowAggregateFunctionMax::createHandle( - const std::vector<const Type*> &argument_types, - const std::vector<std::unique_ptr<const Scalar>> &partition_by_attributes, - const std::vector<std::unique_ptr<const Scalar>> &order_by_attributes, - const bool is_row, - const std::int64_t num_preceding, - const std::int64_t num_following) const { - DCHECK(canApplyToTypes(argument_types)) - << "Attempted to create a WindowAggregationHandleMax for argument Type(s) " - << "that MAX can not be applied to."; - - // TODO(Shixuan): Add handle for Max. - return nullptr; -} - -} // namespace quickstep http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunctionMax.hpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionMax.hpp b/expressions/window_aggregation/WindowAggregateFunctionMax.hpp deleted file mode 100644 index 15563df..0000000 --- a/expressions/window_aggregation/WindowAggregateFunctionMax.hpp +++ /dev/null @@ -1,79 +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_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_MAX_HPP_ -#define QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_MAX_HPP_ - -#include <string> -#include <vector> - -#include "expressions/window_aggregation/WindowAggregateFunction.hpp" -#include "expressions/window_aggregation/WindowAggregationID.hpp" -#include "utility/Macros.hpp" - -namespace quickstep { - -class Type; -class WindowAggregationHandle; - -/** \addtogroup Expressions - * @{ - */ - -/** - * @brief WindowAggregateFunction representing SQL MAX() OVER term. - **/ -class WindowAggregateFunctionMax : public WindowAggregateFunction { - public: - static const WindowAggregateFunctionMax& Instance() { - static WindowAggregateFunctionMax instance; - return instance; - } - - std::string getName() const override { - return "MAX"; - } - - bool canApplyToTypes( - const std::vector<const Type*> &argument_types) const override; - - const Type* resultTypeForArgumentTypes( - const std::vector<const Type*> &argument_types) const override; - - WindowAggregationHandle* createHandle( - const std::vector<const Type*> &argument_types, - const std::vector<std::unique_ptr<const Scalar>> &partition_by_attributes, - const std::vector<std::unique_ptr<const Scalar>> &order_by_attributes, - const bool is_row, - const std::int64_t num_preceding, - const std::int64_t num_following) const override; - - private: - WindowAggregateFunctionMax() - : WindowAggregateFunction(WindowAggregationID::kMax) { - } - - DISALLOW_COPY_AND_ASSIGN(WindowAggregateFunctionMax); -}; - -/** @} */ - -} // namespace quickstep - -#endif // QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_MAX_HPP_ http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/expressions/window_aggregation/WindowAggregateFunctionMin.cpp ---------------------------------------------------------------------- diff --git a/expressions/window_aggregation/WindowAggregateFunctionMin.cpp b/expressions/window_aggregation/WindowAggregateFunctionMin.cpp deleted file mode 100644 index 650241f..0000000 --- a/expressions/window_aggregation/WindowAggregateFunctionMin.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/window_aggregation/WindowAggregateFunctionMin.hpp" - -#include <vector> - -#include "expressions/window_aggregation/WindowAggregationHandle.hpp" -#include "types/Type.hpp" -#include "types/operations/comparisons/Comparison.hpp" -#include "types/operations/comparisons/ComparisonFactory.hpp" -#include "types/operations/comparisons/ComparisonID.hpp" - -#include "glog/logging.h" - -namespace quickstep { - -bool WindowAggregateFunctionMin::canApplyToTypes( - const std::vector<const Type*> &argument_types) const { - // MIN is unary. - if (argument_types.size() != 1) { - return false; - } - - // Argument must be comparable by '<'. - return ComparisonFactory::GetComparison(ComparisonID::kLess).canCompareTypes( - *argument_types.front(), - *argument_types.front()); -} - -const Type* WindowAggregateFunctionMin::resultTypeForArgumentTypes( - const std::vector<const Type*> &argument_types) const { - if (!canApplyToTypes(argument_types)) { - return nullptr; - } - - return &(argument_types.front()->getNullableVersion()); -} - -WindowAggregationHandle* WindowAggregateFunctionMin::createHandle( - const std::vector<const Type*> &argument_types, - const std::vector<std::unique_ptr<const Scalar>> &partition_by_attributes, - const std::vector<std::unique_ptr<const Scalar>> &order_by_attributes, - const bool is_row, - const std::int64_t num_preceding, - const std::int64_t num_following) const { - DCHECK(canApplyToTypes(argument_types)) - << "Attempted to create a WindowAggregationHandleMin for argument Type(s) " - << "that MIN can not be applied to."; - - return nullptr; -} - -} // namespace quickstep
