You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@quickstep.apache.org by sp...@apache.org on 2016/12/11 17:45:32 UTC
[09/51] [abbrv] [partial] incubator-quickstep git commit: remove c++
files
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/SimpleCase.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/SimpleCase.cpp b/query_optimizer/expressions/SimpleCase.cpp
deleted file mode 100644
index 454d7b9..0000000
--- a/query_optimizer/expressions/SimpleCase.cpp
+++ /dev/null
@@ -1,188 +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 "query_optimizer/expressions/SimpleCase.hpp"
-
-#include <cstddef>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "expressions/predicate/Predicate.hpp"
-#include "expressions/scalar/ScalarCaseExpression.hpp"
-#include "expressions/scalar/ScalarLiteral.hpp"
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/ComparisonExpression.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/Predicate.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "types/Type.hpp"
-#include "types/operations/comparisons/ComparisonID.hpp"
-#include "types/operations/comparisons/ComparisonFactory.hpp"
-#include "utility/Cast.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-// We treat a SimpleCase as constant only if all operands are constant.
-bool SimpleCase::isConstant() const {
- if (!case_operand_->isConstant()) {
- return false;
- }
- for (const ScalarPtr &condition_operand : condition_operands_) {
- if (!condition_operand->isConstant()) {
- return false;
- }
- }
- for (const ScalarPtr &conditional_result_expression : conditional_result_expressions_) {
- if (!conditional_result_expression->isConstant()) {
- return false;
- }
- }
- return (else_result_expression_ == nullptr || else_result_expression_->isConstant());
-}
-
-std::vector<AttributeReferencePtr> SimpleCase::getReferencedAttributes() const {
- std::vector<AttributeReferencePtr> referenced_attributes;
-
- const std::vector<AttributeReferencePtr> referenced_attributes_in_case_operand =
- case_operand_->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_case_operand.begin(),
- referenced_attributes_in_case_operand.end());
-
- for (const ScalarPtr &condition_operand : condition_operands_) {
- const std::vector<AttributeReferencePtr> referenced_attributes_in_condition_operand =
- condition_operand->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_condition_operand.begin(),
- referenced_attributes_in_condition_operand.end());
- }
- for (const ScalarPtr &conditional_result_expression : conditional_result_expressions_) {
- const std::vector<AttributeReferencePtr> referenced_attributes_in_conditional_result_expression =
- conditional_result_expression->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_conditional_result_expression.begin(),
- referenced_attributes_in_conditional_result_expression.end());
- }
- if (else_result_expression_ != nullptr) {
- const std::vector<AttributeReferencePtr> referenced_attributes_in_else_result_expression =
- else_result_expression_->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_else_result_expression.begin(),
- referenced_attributes_in_else_result_expression.end());
- }
-
- return referenced_attributes;
-}
-
-ExpressionPtr SimpleCase::copyWithNewChildren(const std::vector<ExpressionPtr> &new_children) const {
- DCHECK_EQ(getNumChildren(), new_children.size());
-
- ScalarPtr new_case_operand;
- std::vector<ScalarPtr> new_condition_operands;
- std::vector<ScalarPtr> new_conditional_result_expressions;
- ScalarPtr new_else_result_expression;
-
- new_condition_operands.reserve(condition_operands_.size());
- new_conditional_result_expressions.reserve(condition_operands_.size());
-
- new_case_operand = std::static_pointer_cast<const Scalar>(new_children[0]);
- std::size_t num_when_clauses = condition_operands_.size();
- for (std::size_t index = 1; index <= num_when_clauses; ++index) {
- new_condition_operands.push_back(
- std::static_pointer_cast<const Scalar>(new_children[index]));
-
- new_conditional_result_expressions.push_back(
- std::static_pointer_cast<const Scalar>(new_children[index + num_when_clauses]));
- }
- if (else_result_expression_ != nullptr) {
- new_else_result_expression =
- std::static_pointer_cast<const Scalar>(new_children.back());
- }
-
- return Create(new_case_operand,
- new_condition_operands,
- new_conditional_result_expressions,
- new_else_result_expression,
- value_type_);
-}
-
-::quickstep::Scalar* SimpleCase::concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
- std::vector<std::unique_ptr<quickstep::Predicate>> when_predicates;
- for (const ScalarPtr &condition_operand : condition_operands_) {
- const PredicatePtr predicate =
- ComparisonExpression::Create(
- quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kEqual),
- case_operand_,
- condition_operand);
- when_predicates.emplace_back(predicate->concretize(substitution_map));
- }
-
- std::vector<std::unique_ptr<quickstep::Scalar>> result_expressions;
- for (const ScalarPtr &expression : conditional_result_expressions_) {
- result_expressions.emplace_back(expression->concretize(substitution_map));
- }
-
- std::unique_ptr<quickstep::Scalar> else_result_expression;
- if (else_result_expression_ == nullptr) {
- else_result_expression.reset(
- new quickstep::ScalarLiteral(value_type_.makeNullValue(), value_type_));
- } else {
- else_result_expression.reset(
- else_result_expression_->concretize(substitution_map));
- }
-
- return new quickstep::ScalarCaseExpression(
- value_type_,
- std::move(when_predicates),
- std::move(result_expressions),
- else_result_expression.release());
-}
-
-void SimpleCase::getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const {
- non_container_child_field_names->push_back("case_operand");
- non_container_child_fields->push_back(case_operand_);
-
- container_child_field_names->push_back("condition_operands");
- container_child_fields->push_back(CastSharedPtrVector<OptimizerTreeBase>(condition_operands_));
-
- container_child_field_names->push_back("result_expressions");
- container_child_fields->push_back(CastSharedPtrVector<OptimizerTreeBase>(conditional_result_expressions_));
-
- if (else_result_expression_ != nullptr) {
- non_container_child_field_names->push_back("else_result_expression");
- non_container_child_fields->push_back(else_result_expression_);
- }
-}
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/SimpleCase.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/SimpleCase.hpp b/query_optimizer/expressions/SimpleCase.hpp
deleted file mode 100644
index 897d87f..0000000
--- a/query_optimizer/expressions/SimpleCase.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_QUERY_OPTIMIZER_EXPRESSIONS_SIMPLE_CASE_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SIMPLE_CASE_HPP_
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "expressions/scalar/Scalar.hpp"
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/ExpressionType.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class Type;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class SimpleCase;
-typedef std::shared_ptr<const SimpleCase> SimpleCasePtr;
-
-/**
- * @brief A simple CASE expression. It searches the first expression in
- * <condition_operands_> with a value equal to <case_operand_>, and
- * returns the value of the expression in <conditional_result_expressions_>
- * at the same position; if none of <condition_operands_> meet the
- * condition, returns the value of <else_result_expression_> when
- * <else_result_expression_> is not NULL, otherwise returns NULL.
- */
-class SimpleCase : public Scalar {
- public:
- ExpressionType getExpressionType() const override {
- return ExpressionType::kSimpleCase;
- }
-
- std::string getName() const override {
- return "SimpleCase";
- }
-
- const Type& getValueType() const override {
- return value_type_;
- }
-
- /**
- * @return The CASE operand.
- */
- const ScalarPtr& case_operand() const {
- return case_operand_;
- }
-
- /**
- * @return The vector of condition operands.
- */
- const std::vector<ScalarPtr>& condition_operands() const {
- return condition_operands_;
- }
-
- /**
- * @return The vector of conditional result expressions, one for each
- * condition operand.
- */
- const std::vector<ScalarPtr>& conditional_result_expressions() const {
- return conditional_result_expressions_;
- }
-
- /**
- * @return The ELSE result expression.
- */
- const ScalarPtr& else_result_expression() const {
- return else_result_expression_;
- }
-
- bool isConstant() const override;
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override;
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override;
-
- ::quickstep::Scalar* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*>& substitution_map) const override;
-
- /**
- * @brief Creates an immutable SimpleCase.
- *
- * @param case_operand The CASE operand.
- * @param condition_operands A vector of expressions to be compared with
- * the \p case_operand.
- * @param conditional_result_expressions A vector of result expressions, one
- * per expression of \p condition_operands.
- * @param else_result_expression The optional ELSE expression.
- * @param value_type The data type of this expression which should be the
- * unified type of all result expressions.
- * @return An immutable SimpleCase.
- */
- static SimpleCasePtr Create(const ScalarPtr &case_operand,
- const std::vector<ScalarPtr> &condition_operands,
- const std::vector<ScalarPtr> &conditional_result_expressions,
- const ScalarPtr &else_result_expression,
- const Type &value_type) {
- return SimpleCasePtr(new SimpleCase(case_operand,
- condition_operands,
- conditional_result_expressions,
- else_result_expression,
- value_type));
- }
-
- protected:
- void getFieldStringItems(std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const override;
-
- private:
- SimpleCase(const ScalarPtr &case_operand,
- const std::vector<ScalarPtr> &condition_operands,
- const std::vector<ScalarPtr> &conditional_result_expressions,
- const ScalarPtr &else_result_expression,
- const Type &value_type)
- : case_operand_(case_operand),
- condition_operands_(condition_operands),
- conditional_result_expressions_(conditional_result_expressions),
- else_result_expression_(else_result_expression),
- value_type_(value_type) {
- addChild(case_operand_);
- for (const ScalarPtr &condition_operand : condition_operands_) {
- addChild(condition_operand);
- }
- for (const ScalarPtr &conditional_result_expression : conditional_result_expressions_) {
- addChild(conditional_result_expression);
- }
- if (else_result_expression_ != nullptr) {
- addChild(else_result_expression);
- }
- }
-
- ScalarPtr case_operand_;
- std::vector<ScalarPtr> condition_operands_;
- std::vector<ScalarPtr> conditional_result_expressions_;
-
- // May be NULL.
- ScalarPtr else_result_expression_;
-
- const Type &value_type_;
-
- DISALLOW_COPY_AND_ASSIGN(SimpleCase);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SIMPLE_CASE_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/SubqueryExpression.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/SubqueryExpression.cpp b/query_optimizer/expressions/SubqueryExpression.cpp
deleted file mode 100644
index dbcb6d6..0000000
--- a/query_optimizer/expressions/SubqueryExpression.cpp
+++ /dev/null
@@ -1,68 +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 "query_optimizer/expressions/SubqueryExpression.hpp"
-
-#include <string>
-#include <vector>
-
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class Scalar;
-
-namespace optimizer {
-namespace expressions {
-
-::quickstep::Scalar* SubqueryExpression::concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
- LOG(FATAL) << "SubqueryExpression should not be concretized";
-}
-
-std::vector<AttributeReferencePtr> SubqueryExpression::getReferencedAttributes() const {
- // Note(jianqiao): Here simply return an empty set so that we skip the validation
- // for this expression at the end of the resolving phase (otherwise we need to
- // revise the Validate() function to deal with OUTER scoped attributes). Note
- // that SubqueryExpression will always be eliminated by UnnestSubqueries as the
- // first logical optimization pass in LogicalGenerator. So any dangling attribute
- // will still be detected by Validate() at the end of the logical optimization
- // phase.
- return {};
-}
-
-void SubqueryExpression::getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const {
- non_container_child_field_names->push_back("subquery");
- non_container_child_fields->push_back(subquery_);
-}
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/SubqueryExpression.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/SubqueryExpression.hpp b/query_optimizer/expressions/SubqueryExpression.hpp
deleted file mode 100644
index a128e7f..0000000
--- a/query_optimizer/expressions/SubqueryExpression.hpp
+++ /dev/null
@@ -1,132 +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_QUERY_OPTIMIZER_EXPRESSIONS_SUBQUERY_EXPRESSION_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SUBQUERY_EXPRESSION_HPP_
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/ExpressionType.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "query_optimizer/logical/Logical.hpp"
-#include "query_optimizer/OptimizerTree.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class Scalar;
-class Type;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class SubqueryExpression;
-typedef std::shared_ptr<const SubqueryExpression> SubqueryExpressionPtr;
-
-/**
- * @brief A subquery used in an expression.
- */
-class SubqueryExpression : public Scalar {
- public:
- ExpressionType getExpressionType() const override {
- return ExpressionType::kSubqueryExpression;
- }
-
- std::string getName() const override { return "SubqueryExpression"; }
-
- const Type& getValueType() const override {
- return output_attribute_->getValueType();
- }
-
- bool isConstant() const override {
- return output_attribute_->isConstant();
- }
-
- /**
- * @return The referenced logical subquery node.
- */
- const logical::LogicalPtr& subquery() const {
- return subquery_;
- }
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override;
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override {
- DCHECK(new_children.empty());
- return Create(subquery_);
- }
-
- ::quickstep::Scalar* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
-
- /**
- * @brief Creates a subquery expression.
- * @note This expression can only be used in a logical plan.
- *
- * @param subquery The logical subquery node.
- * @return An immutable SubqueryExpression.
- */
- static SubqueryExpressionPtr Create(const logical::LogicalPtr &subquery) {
- return SubqueryExpressionPtr(new SubqueryExpression(subquery));
- }
-
- protected:
- void getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const override;
-
- private:
- explicit SubqueryExpression(const logical::LogicalPtr &subquery)
- : subquery_(subquery),
- output_attribute_(subquery->getOutputAttributes()[0]) {
- DCHECK(!subquery->getOutputAttributes().empty());
- }
-
- logical::LogicalPtr subquery_;
- // Set to the first output attribute if the subquery is a multi-column table query.
- const AttributeReferencePtr output_attribute_;
-
- DISALLOW_COPY_AND_ASSIGN(SubqueryExpression);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SUBQUERY_EXPRESSION_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/UnaryExpression.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/UnaryExpression.cpp b/query_optimizer/expressions/UnaryExpression.cpp
deleted file mode 100644
index b0fff62..0000000
--- a/query_optimizer/expressions/UnaryExpression.cpp
+++ /dev/null
@@ -1,72 +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 "query_optimizer/expressions/UnaryExpression.hpp"
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "expressions/scalar/ScalarUnaryExpression.hpp"
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/PatternMatcher.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "types/operations/unary_operations/UnaryOperation.hpp"
-#include "types/operations/unary_operations/UnaryOperationID.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-std::string UnaryExpression::getName() const {
- return operation_.getName();
-}
-
-ExpressionPtr UnaryExpression::copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const {
- DCHECK_EQ(new_children.size(), children().size());
- DCHECK(SomeScalar::Matches(new_children[0]));
- return UnaryExpression::Create(
- operation_, std::static_pointer_cast<const Scalar>(new_children[0]));
-}
-
-::quickstep::Scalar* UnaryExpression::concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
- return new ::quickstep::ScalarUnaryExpression(
- operation_, operand_->concretize(substitution_map));
-}
-
-void UnaryExpression::getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const {
- non_container_child_field_names->push_back("Operand");
- non_container_child_fields->push_back(operand_);
-}
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/UnaryExpression.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/UnaryExpression.hpp b/query_optimizer/expressions/UnaryExpression.hpp
deleted file mode 100644
index c4542d0..0000000
--- a/query_optimizer/expressions/UnaryExpression.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_QUERY_OPTIMIZER_EXPRESSIONS_UNARY_EXPRESSION_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_UNARY_EXPRESSION_HPP_
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/ExpressionType.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "types/operations/unary_operations/UnaryOperation.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class Scalar;
-class Type;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class UnaryExpression;
-typedef std::shared_ptr<const UnaryExpression> UnaryExpressionPtr;
-
-class UnaryExpression : public Scalar {
- public:
- ExpressionType getExpressionType() const override {
- return ExpressionType::kUnaryExpression;
- }
-
- std::string getName() const override;
-
- bool isConstant() const override { return operand_->isConstant(); }
-
- /**
- * @return The unary operator.
- */
- const UnaryOperation& operation() const { return operation_; }
-
- /**
- * @return The operand of the unary operator.
- */
- const ScalarPtr& operand() const { return operand_; }
-
- const Type& getValueType() const override {
- return *(operation_.resultTypeForArgumentType(operand_->getValueType()));
- }
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override;
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override {
- return operand_->getReferencedAttributes();
- }
-
- ::quickstep::Scalar* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
-
- /**
- * @brief Creates an immutable UnaryExpression.
- *
- * @param operation The unary operation.
- * @param operand The operand.
- * @return An immutable UnaryExpression that applies the operation to the
- * operand.
- */
- static UnaryExpressionPtr Create(const UnaryOperation &operation,
- const ScalarPtr &operand) {
- return UnaryExpressionPtr(new UnaryExpression(operation, operand));
- }
-
- protected:
- void getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const override;
-
- private:
- UnaryExpression(const UnaryOperation &operation,
- const ScalarPtr &operand)
- : operation_(operation), operand_(operand) {
- DCHECK(operation_.canApplyToType(operand_->getValueType())) << toString();
- addChild(operand);
- }
-
- const UnaryOperation &operation_;
- ScalarPtr operand_;
-
- DISALLOW_COPY_AND_ASSIGN(UnaryExpression);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_UNARY_EXPRESSION_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/WindowAggregateFunction.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/WindowAggregateFunction.cpp b/query_optimizer/expressions/WindowAggregateFunction.cpp
deleted file mode 100644
index bba7c0e..0000000
--- a/query_optimizer/expressions/WindowAggregateFunction.cpp
+++ /dev/null
@@ -1,194 +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 "query_optimizer/expressions/WindowAggregateFunction.hpp"
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "expressions/window_aggregation/WindowAggregateFunction.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/PatternMatcher.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "types/Type.hpp"
-#include "utility/Cast.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-bool WindowAggregateFunction::isNullable() const {
- std::vector<const Type*> argument_types;
- for (const ScalarPtr &argument : arguments_) {
- argument_types.emplace_back(&argument->getValueType());
- }
-
- const Type *return_type = window_aggregate_.resultTypeForArgumentTypes(argument_types);
- DCHECK(return_type != nullptr);
- return return_type->isNullable();
-}
-
-const Type& WindowAggregateFunction::getValueType() const {
- std::vector<const Type*> argument_types;
- for (const ScalarPtr &argument : arguments_) {
- argument_types.emplace_back(&argument->getValueType());
- }
-
- const Type *return_type = window_aggregate_.resultTypeForArgumentTypes(argument_types);
- DCHECK(return_type != nullptr);
- return *return_type;
-}
-
-WindowAggregateFunctionPtr WindowAggregateFunction::Create(
- const ::quickstep::WindowAggregateFunction &window_aggregate,
- const std::vector<ScalarPtr> &arguments,
- const WindowInfo &window_info,
- const std::string &window_name,
- const bool is_distinct) {
-#ifdef QUICKSTEP_DEBUG
- std::vector<const Type*> argument_types;
- for (const ScalarPtr &argument : arguments) {
- argument_types.emplace_back(&argument->getValueType());
- }
- DCHECK(window_aggregate.canApplyToTypes(argument_types));
-#endif // QUICKSTEP_DEBUG
-
- return WindowAggregateFunctionPtr(
- new WindowAggregateFunction(window_aggregate, arguments, window_info, window_name, is_distinct));
-}
-
-ExpressionPtr WindowAggregateFunction::copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const {
- std::vector<ScalarPtr> new_arguments;
- for (const ExpressionPtr &expression_ptr : new_children) {
- ScalarPtr expr_as_scalar;
- CHECK(SomeScalar::MatchesWithConditionalCast(expression_ptr, &expr_as_scalar))
- << expression_ptr->toString();
- new_arguments.emplace_back(std::move(expr_as_scalar));
- }
-
- return WindowAggregateFunctionPtr(
- new WindowAggregateFunction(window_aggregate_,
- new_arguments,
- window_info_,
- window_name_,
- is_distinct_));
-}
-
-std::vector<AttributeReferencePtr> WindowAggregateFunction::getReferencedAttributes() const {
- std::vector<AttributeReferencePtr> referenced_attributes;
- for (const ScalarPtr &argument : arguments_) {
- const std::vector<AttributeReferencePtr> referenced_attributes_in_argument =
- argument->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_argument.begin(),
- referenced_attributes_in_argument.end());
- }
-
- referenced_attributes.insert(referenced_attributes.end(),
- window_info_.partition_by_attributes.begin(),
- window_info_.partition_by_attributes.end());
-
- referenced_attributes.insert(referenced_attributes.end(),
- window_info_.order_by_attributes.begin(),
- window_info_.order_by_attributes.end());
-
- return referenced_attributes;
-}
-
-void WindowAggregateFunction::getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const {
- inline_field_names->push_back("function");
- inline_field_values->push_back(window_aggregate_.getName());
-
- container_child_field_names->push_back("arguments");
- container_child_fields->emplace_back(CastSharedPtrVector<OptimizerTreeBase>(arguments_));
-
- inline_field_names->push_back("window_name");
- inline_field_values->push_back(window_name_);
-
- container_child_field_names->push_back("partition_by");
- container_child_fields->emplace_back(
- CastSharedPtrVector<OptimizerTreeBase>(window_info_.partition_by_attributes));
-
- container_child_field_names->push_back("order_by");
- container_child_fields->emplace_back(
- CastSharedPtrVector<OptimizerTreeBase>(window_info_.order_by_attributes));
-
- inline_field_names->push_back("is_ascending");
- std::string ascending_list("[");
- for (const bool is_ascending : window_info_.order_by_directions) {
- if (is_ascending) {
- ascending_list.append("true,");
- } else {
- ascending_list.append("false,");
- }
- }
- if (!window_info_.order_by_directions.empty()) {
- ascending_list.pop_back();
- }
- ascending_list.append("]");
- inline_field_values->push_back(ascending_list);
-
- inline_field_names->push_back("nulls_first");
- std::string nulls_first_flags("[");
- for (const bool nulls_first_flag : window_info_.nulls_first) {
- if (nulls_first_flag) {
- nulls_first_flags.append("true,");
- } else {
- nulls_first_flags.append("false,");
- }
- }
- if (!window_info_.nulls_first.empty()) {
- nulls_first_flags.pop_back();
- }
- nulls_first_flags.append("]");
- inline_field_values->push_back(nulls_first_flags);
-
- if (window_info_.frame_info != nullptr) {
- const WindowFrameInfo *frame_info = window_info_.frame_info;
-
- inline_field_names->push_back("frame_mode");
- inline_field_values->push_back(frame_info->is_row ? "row" : "range");
-
- inline_field_names->push_back("num_preceding");
- inline_field_values->push_back(std::to_string(frame_info->num_preceding));
-
- inline_field_names->push_back("num_following");
- inline_field_values->push_back(std::to_string(frame_info->num_following));
- }
-
- if (is_distinct_) {
- inline_field_names->push_back("is_distinct");
- inline_field_values->push_back("true");
- }
-}
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/WindowAggregateFunction.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/WindowAggregateFunction.hpp b/query_optimizer/expressions/WindowAggregateFunction.hpp
deleted file mode 100644
index 04b4b51..0000000
--- a/query_optimizer/expressions/WindowAggregateFunction.hpp
+++ /dev/null
@@ -1,246 +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_QUERY_OPTIMIZER_EXPRESSIONS_WINDOW_AGGREGATE_FUNCTION_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_WINDOW_AGGREGATE_FUNCTION_HPP_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/ExpressionType.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class Type;
-class WindowAggregateFunction;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-struct WindowFrameInfo {
- /**
- * @brief Cosntructor.
- *
- * @param is_row_in True if this window frame is defined by ROWS, false if
- * defined by RANGE.
- * @param num_preceding_in The number of preceding tuples the window frame
- * will cover, -1 means UNBOUNDED.
- * @param num_following_in The number of following tuples the window frame
- * will cover, -1 means UNBOUNDED.
- **/
- WindowFrameInfo(const bool is_row_in,
- const int num_preceding_in,
- const int num_following_in)
- : is_row(is_row_in),
- num_preceding(num_preceding_in),
- num_following(num_following_in) {}
-
- const bool is_row;
- const int num_preceding;
- const int num_following;
-};
-
-struct WindowInfo {
- /**
- * @brief Constructor.
- *
- * @param partition_by_attributes_in The partition keys for the window.
- * @param order_by_attributes_in The order keys for the window.
- * @param order_by_directions_in The order direction for order key.
- * @param nulls_first_in The nulls' position for order key.
- * @param frame_info_in The window frame information for the window. Null
- * means there is no explicit window frame definition.
- **/
- WindowInfo(const std::vector<AttributeReferencePtr> &partition_by_attributes_in,
- const std::vector<AttributeReferencePtr> &order_by_attributes_in,
- const std::vector<bool> &order_by_directions_in,
- const std::vector<bool> &nulls_first_in,
- const WindowFrameInfo *frame_info_in)
- : partition_by_attributes(partition_by_attributes_in),
- order_by_attributes(order_by_attributes_in),
- order_by_directions(order_by_directions_in),
- nulls_first(nulls_first_in),
- frame_info(frame_info_in) {}
-
- const std::vector<AttributeReferencePtr> partition_by_attributes;
- const std::vector<AttributeReferencePtr> order_by_attributes;
- const std::vector<bool> order_by_directions;
- const std::vector<bool> nulls_first;
- const WindowFrameInfo *frame_info;
-};
-
-class WindowAggregateFunction;
-typedef std::shared_ptr<const WindowAggregateFunction> WindowAggregateFunctionPtr;
-
-/**
- * @brief Represents a window aggregate function and its arguments in the
- * optimizer. This class wraps some of the functionality from
- * quickstep::AggregateFunction and represents a particular instance
- * of an aggregate during query optimization.
- **/
-class WindowAggregateFunction : public Expression {
- public:
- /**
- * @brief Destructor.
- */
- ~WindowAggregateFunction() override {}
-
- ExpressionType getExpressionType() const override {
- return ExpressionType::kWindowAggregateFunction;
- }
-
- std::string getName() const override {
- return "WindowAggregateFunction";
- }
-
- const Type& getValueType() const override;
-
- bool isConstant() const override {
- // Window aggregate function is never considered as a constant expression.
- return false;
- }
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override;
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override;
-
- /**
- * @return Whether the type of the return value is nullable.
- **/
- bool isNullable() const;
-
- /**
- * @return The WindowAggregateFunction singleton (from the expression system)
- * for this node.
- **/
- inline const ::quickstep::WindowAggregateFunction& window_aggregate() const {
- return window_aggregate_;
- }
-
- /**
- * @return The list of scalar arguments to this aggregate.
- **/
- inline const std::vector<ScalarPtr>& arguments() const {
- return arguments_;
- }
-
- /**
- * @return The window info of this window aggregate function.
- **/
- inline const WindowInfo window_info() const {
- return window_info_;
- }
-
- /**
- * @return The name of the window.
- **/
- inline const std::string window_name() const {
- return window_name_;
- }
-
- /**
- * @return Whether this is a DISTINCT aggregation.
- **/
- inline bool is_distinct() const {
- return is_distinct_;
- }
-
- /**
- * @brief Create a new WindowAggregateFunction by directly defined window.
- *
- * @warning It is an error to call this with arguments that the given
- * aggregate can not apply to.
- *
- * @param aggregate The underlying WindowAggregateFunction from the expression
- * system.
- * @param arguments A list of arguments to the window aggregate function.
- * @param window_info The window info of the window aggregate function.
- * @param is_distinct Whether this is a DISTINCT aggregation.
- * @return A new AggregateFunctionPtr.
- **/
- static WindowAggregateFunctionPtr Create(const ::quickstep::WindowAggregateFunction &window_aggregate,
- const std::vector<ScalarPtr> &arguments,
- const WindowInfo &window_info,
- const std::string &window_name,
- const bool is_distinct);
-
- protected:
- void getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const override;
-
- private:
- /**
- * @brief Constructor.
- *
- * @param window_aggregate The actual AggregateFunction to use.
- * @param arguments A list of arguments to the window aggregate function.
- * @param window_info The window info of the window aggregate function.
- * @param is_distinct Indicates whether this is a DISTINCT aggregation.
- */
- WindowAggregateFunction(const ::quickstep::WindowAggregateFunction &window_aggregate,
- const std::vector<ScalarPtr> &arguments,
- const WindowInfo &window_info,
- const std::string &window_name,
- const bool is_distinct)
- : window_aggregate_(window_aggregate),
- arguments_(arguments),
- window_info_(window_info),
- window_name_(window_name),
- is_distinct_(is_distinct) {
- for (const ScalarPtr &child : arguments_) {
- addChild(child);
- }
- }
-
- // TODO(Shixuan): Currently this class uses AggregationFunction as
- // window_aggregate_. If it really needs to be seperated from the
- // AggregationFunction, a new class for WindowAggregationFunction should be
- // created as quickstep::WindowAggregateFunction.
- const ::quickstep::WindowAggregateFunction &window_aggregate_;
- std::vector<ScalarPtr> arguments_;
- const WindowInfo window_info_;
- const std::string window_name_;
- const bool is_distinct_;
-
- DISALLOW_COPY_AND_ASSIGN(WindowAggregateFunction);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif // QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_WINDOW_AGGREGATE_FUNCTION_HPP_
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/logical/Aggregate.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/logical/Aggregate.cpp b/query_optimizer/logical/Aggregate.cpp
deleted file mode 100644
index 6559aca..0000000
--- a/query_optimizer/logical/Aggregate.cpp
+++ /dev/null
@@ -1,127 +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 "query_optimizer/logical/Aggregate.hpp"
-
-#include <string>
-#include <vector>
-
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/ExpressionUtil.hpp"
-#include "query_optimizer/expressions/NamedExpression.hpp"
-#include "query_optimizer/expressions/PatternMatcher.hpp"
-#include "utility/Cast.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace logical {
-
-namespace E = ::quickstep::optimizer::expressions;
-
-LogicalPtr Aggregate::copyWithNewChildren(
- const std::vector<LogicalPtr> &new_children) const {
- DCHECK_EQ(getNumChildren(), new_children.size());
- return Create(new_children[0], grouping_expressions_, aggregate_expressions_);
-}
-
-std::vector<E::AttributeReferencePtr> Aggregate::getOutputAttributes() const {
- std::vector<E::AttributeReferencePtr> output_attributes(
- E::ToRefVector(grouping_expressions_));
- const std::vector<E::AttributeReferencePtr> aggregate_output_attributes =
- E::ToRefVector(aggregate_expressions_);
- output_attributes.insert(output_attributes.end(),
- aggregate_output_attributes.begin(),
- aggregate_output_attributes.end());
- return output_attributes;
-}
-
-std::vector<E::AttributeReferencePtr> Aggregate::getReferencedAttributes() const {
- std::vector<E::AttributeReferencePtr> referenced_attributes;
- for (const E::NamedExpressionPtr &grouping_expression :
- grouping_expressions_) {
- const std::vector<E::AttributeReferencePtr> referenced_attributes_in_expression =
- grouping_expression->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_expression.begin(),
- referenced_attributes_in_expression.end());
- }
- for (const E::AliasPtr &aggregate_expression :
- aggregate_expressions_) {
- const std::vector<E::AttributeReferencePtr> referenced_attributes_in_expression =
- aggregate_expression->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_expression.begin(),
- referenced_attributes_in_expression.end());
- }
- return referenced_attributes;
-}
-
-LogicalPtr Aggregate::copyWithNewInputExpressions(
- const std::vector<E::ExpressionPtr> &input_expressions) const {
- DCHECK_EQ(grouping_expressions_.size() + aggregate_expressions_.size(),
- input_expressions.size());
-
- std::vector<E::NamedExpressionPtr> new_grouping_expressions;
- for (std::vector<E::ExpressionPtr>::size_type index = 0;
- index < grouping_expressions_.size();
- ++index) {
- E::NamedExpressionPtr grouping_expression;
- E::SomeNamedExpression::MatchesWithConditionalCast(input_expressions[index],
- &grouping_expression);
- DCHECK(grouping_expression != nullptr);
- new_grouping_expressions.emplace_back(grouping_expression);
- }
-
- std::vector<E::AliasPtr> new_aggregate_expressions;
- for (std::vector<E::ExpressionPtr>::size_type index = grouping_expressions_.size();
- index < input_expressions.size();
- ++index) {
- E::AliasPtr aggregate_expression;
- E::SomeAlias::MatchesWithConditionalCast(input_expressions[index], &aggregate_expression);
- DCHECK(aggregate_expression != nullptr);
- new_aggregate_expressions.emplace_back(aggregate_expression);
- }
-
- return Create(input_, new_grouping_expressions, new_aggregate_expressions);
-}
-
-void Aggregate::getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const {
- non_container_child_field_names->push_back("input");
- non_container_child_fields->push_back(input_);
-
- container_child_field_names->push_back("grouping_expressions");
- container_child_fields->push_back(
- CastSharedPtrVector<OptimizerTreeBase>(grouping_expressions_));
- container_child_field_names->push_back("aggregate_expressions");
- container_child_fields->push_back(
- CastSharedPtrVector<OptimizerTreeBase>(aggregate_expressions_));
-}
-
-} // namespace logical
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/logical/Aggregate.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/logical/Aggregate.hpp b/query_optimizer/logical/Aggregate.hpp
deleted file mode 100644
index d8c02ba..0000000
--- a/query_optimizer/logical/Aggregate.hpp
+++ /dev/null
@@ -1,136 +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_QUERY_OPTIMIZER_LOGICAL_AGGREGATE_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_LOGICAL_AGGREGATE_HPP_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/NamedExpression.hpp"
-#include "query_optimizer/expressions/Alias.hpp"
-#include "query_optimizer/logical/Logical.hpp"
-#include "query_optimizer/logical/LogicalType.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-namespace optimizer {
-namespace logical {
-
-/** \addtogroup OptimizerLogical
- * @{
- */
-
-class Aggregate;
-typedef std::shared_ptr<const Aggregate> AggregatePtr;
-
-/**
- * @brief Aggregate operator that computes aggregate expressions for each combination
- * of the values of grouping expressions.
- */
-class Aggregate : public Logical {
- public:
- LogicalType getLogicalType() const override { return LogicalType::kAggregate; }
-
- std::string getName() const override { return "Aggregate"; }
-
- /**
- * @return The input logical node.
- */
- const LogicalPtr& input() const { return input_; }
-
- /**
- * @return Grouping expressions.
- */
- const std::vector<expressions::NamedExpressionPtr>& grouping_expressions() const {
- return grouping_expressions_;
- }
-
- /**
- * @return Aggregate expressions.
- */
- const std::vector<expressions::AliasPtr>& aggregate_expressions() const {
- return aggregate_expressions_;
- }
-
- LogicalPtr copyWithNewChildren(
- const std::vector<LogicalPtr> &new_children) const override;
-
- LogicalPtr copyWithNewInputExpressions(
- const std::vector<expressions::ExpressionPtr> &input_expressions) const override;
-
- std::vector<expressions::AttributeReferencePtr> getOutputAttributes() const override;
-
- std::vector<expressions::AttributeReferencePtr> getReferencedAttributes() const override;
-
- /**
- * @brief Creates an Aggregate logical node.
- *
- * @param input The input node.
- * @param aggregate_expressions The aggregate expressions.
- * @param grouping_expressions The grouping expressions.
- * @return An immutable Aggregate node.
- */
- static AggregatePtr Create(
- LogicalPtr input,
- const std::vector<expressions::NamedExpressionPtr> &grouping_expressions,
- const std::vector<expressions::AliasPtr> &aggregate_expressions) {
- return AggregatePtr(
- new Aggregate(input, grouping_expressions, aggregate_expressions));
- }
-
- protected:
- void getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const override;
-
- private:
- Aggregate(LogicalPtr input,
- const std::vector<expressions::NamedExpressionPtr> &grouping_expressions,
- const std::vector<expressions::AliasPtr> &aggregate_expressions)
- : input_(input),
- grouping_expressions_(grouping_expressions),
- aggregate_expressions_(aggregate_expressions) {
- addChild(input_);
- addInputExpressions(grouping_expressions_);
- addInputExpressions(aggregate_expressions_);
- }
-
- LogicalPtr input_;
- std::vector<expressions::NamedExpressionPtr> grouping_expressions_;
- std::vector<expressions::AliasPtr> aggregate_expressions_;
-
- DISALLOW_COPY_AND_ASSIGN(Aggregate);
-};
-
-/** @} */
-
-} // namespace logical
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_LOGICAL_AGGREGATE_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/logical/BinaryJoin.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/logical/BinaryJoin.cpp b/query_optimizer/logical/BinaryJoin.cpp
deleted file mode 100644
index 5d859b6..0000000
--- a/query_optimizer/logical/BinaryJoin.cpp
+++ /dev/null
@@ -1,61 +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 "query_optimizer/logical/BinaryJoin.hpp"
-
-#include <string>
-#include <vector>
-
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-
-namespace quickstep {
-namespace optimizer {
-namespace logical {
-
-namespace E = ::quickstep::optimizer::expressions;
-
-std::vector<E::AttributeReferencePtr> BinaryJoin::getOutputAttributes() const {
- std::vector<E::AttributeReferencePtr> output_attributes =
- left_->getOutputAttributes();
- const std::vector<E::AttributeReferencePtr> output_attributes_by_right_operand =
- right_->getOutputAttributes();
- output_attributes.insert(output_attributes.end(),
- output_attributes_by_right_operand.begin(),
- output_attributes_by_right_operand.end());
- return output_attributes;
-}
-
-void BinaryJoin::getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const {
- non_container_child_field_names->push_back("left");
- non_container_child_field_names->push_back("right");
-
- non_container_child_fields->push_back(left_);
- non_container_child_fields->push_back(right_);
-}
-
-} // namespace logical
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/logical/BinaryJoin.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/logical/BinaryJoin.hpp b/query_optimizer/logical/BinaryJoin.hpp
deleted file mode 100644
index ca68ced..0000000
--- a/query_optimizer/logical/BinaryJoin.hpp
+++ /dev/null
@@ -1,104 +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_QUERY_OPTIMIZER_LOGICAL_BINARY_JOIN_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_LOGICAL_BINARY_JOIN_HPP_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/logical/Join.hpp"
-#include "query_optimizer/logical/Logical.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace logical {
-
-/** \addtogroup OptimizerLogical
- * @{
- */
-
-class BinaryJoin;
-typedef std::shared_ptr<const BinaryJoin> BinaryJoinPtr;
-
-/**
- * @brief Base class for binary join operators that take exactly two operators
- * as input.
- */
-class BinaryJoin : public Join {
- public:
- /**
- * @return Destructor.
- */
- ~BinaryJoin() override {}
-
- /**
- * @return The left logical join operator.
- */
- const LogicalPtr& left() const { return left_; }
-
- /**
- * @return The right logical join operator.
- */
- const LogicalPtr& right() const { return right_; }
-
- std::vector<expressions::AttributeReferencePtr> getOutputAttributes() const override;
-
- protected:
- /**
- * @brief Constructor.
- *
- * @param left The left join operator.
- * @param right The right join operator.
- */
- BinaryJoin(const LogicalPtr &left,
- const LogicalPtr &right)
- : left_(left), right_(right) {
- addChild(left_);
- addChild(right_);
- }
-
- void getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const override;
-
- private:
- LogicalPtr left_;
- LogicalPtr right_;
-
- DISALLOW_COPY_AND_ASSIGN(BinaryJoin);
-};
-
-/** @} */
-
-} // namespace logical
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_LOGICAL_BINARY_JOIN_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/logical/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/query_optimizer/logical/CMakeLists.txt b/query_optimizer/logical/CMakeLists.txt
deleted file mode 100644
index c67f96f..0000000
--- a/query_optimizer/logical/CMakeLists.txt
+++ /dev/null
@@ -1,306 +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_queryoptimizer_logical_Aggregate Aggregate.cpp Aggregate.hpp)
-add_library(quickstep_queryoptimizer_logical_BinaryJoin BinaryJoin.cpp BinaryJoin.hpp)
-add_library(quickstep_queryoptimizer_logical_CopyFrom CopyFrom.cpp CopyFrom.hpp)
-add_library(quickstep_queryoptimizer_logical_CreateIndex CreateIndex.cpp CreateIndex.hpp)
-add_library(quickstep_queryoptimizer_logical_CreateTable CreateTable.cpp CreateTable.hpp)
-add_library(quickstep_queryoptimizer_logical_DeleteTuples DeleteTuples.cpp DeleteTuples.hpp)
-add_library(quickstep_queryoptimizer_logical_DropTable DropTable.cpp DropTable.hpp)
-add_library(quickstep_queryoptimizer_logical_Filter Filter.cpp Filter.hpp)
-add_library(quickstep_queryoptimizer_logical_HashJoin ../../empty_src.cpp HashJoin.hpp)
-add_library(quickstep_queryoptimizer_logical_InsertSelection InsertSelection.cpp InsertSelection.hpp)
-add_library(quickstep_queryoptimizer_logical_InsertTuple InsertTuple.cpp InsertTuple.hpp)
-add_library(quickstep_queryoptimizer_logical_Join ../../empty_src.cpp Join.hpp)
-add_library(quickstep_queryoptimizer_logical_Logical ../../empty_src.cpp Logical.hpp)
-add_library(quickstep_queryoptimizer_logical_LogicalType ../../empty_src.cpp LogicalType.hpp)
-add_library(quickstep_queryoptimizer_logical_MultiwayCartesianJoin MultiwayCartesianJoin.cpp MultiwayCartesianJoin.hpp)
-add_library(quickstep_queryoptimizer_logical_NestedLoopsJoin ../../empty_src.cpp NestedLoopsJoin.hpp)
-add_library(quickstep_queryoptimizer_logical_PatternMatcher ../../empty_src.cpp PatternMatcher.hpp)
-add_library(quickstep_queryoptimizer_logical_Project Project.cpp Project.hpp)
-add_library(quickstep_queryoptimizer_logical_Sample Sample.cpp Sample.hpp)
-add_library(quickstep_queryoptimizer_logical_SharedSubplanReference
- SharedSubplanReference.cpp
- SharedSubplanReference.hpp)
-add_library(quickstep_queryoptimizer_logical_Sort Sort.cpp Sort.hpp)
-add_library(quickstep_queryoptimizer_logical_TableReference TableReference.cpp TableReference.hpp)
-add_library(quickstep_queryoptimizer_logical_TableGenerator ../../empty_src.cpp TableGenerator.hpp)
-add_library(quickstep_queryoptimizer_logical_TopLevelPlan TopLevelPlan.cpp TopLevelPlan.hpp)
-add_library(quickstep_queryoptimizer_logical_UpdateTable UpdateTable.cpp UpdateTable.hpp)
-add_library(quickstep_queryoptimizer_logical_WindowAggregate WindowAggregate.cpp WindowAggregate.hpp)
-
-# Link dependencies:
-target_link_libraries(quickstep_queryoptimizer_logical_Aggregate
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_Alias
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_Expression
- quickstep_queryoptimizer_expressions_ExpressionUtil
- quickstep_queryoptimizer_expressions_NamedExpression
- quickstep_queryoptimizer_expressions_PatternMatcher
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_BinaryJoin
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_logical_Join
- quickstep_queryoptimizer_logical_Logical
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_CopyFrom
- glog
- quickstep_catalog_CatalogRelation
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Macros
- quickstep_utility_StringUtil)
-target_link_libraries(quickstep_queryoptimizer_logical_CreateIndex
- glog
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_storage_StorageBlockLayout_proto
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_CreateTable
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_storage_StorageBlockLayout_proto
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_DeleteTuples
- glog
- quickstep_catalog_CatalogRelation
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_Predicate
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_DropTable
- glog
- quickstep_catalog_CatalogRelation
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_Filter
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_Expression
- quickstep_queryoptimizer_expressions_LogicalAnd
- quickstep_queryoptimizer_expressions_PatternMatcher
- quickstep_queryoptimizer_expressions_Predicate
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_queryoptimizer_logical_PatternMatcher
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_HashJoin
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_ExpressionUtil
- quickstep_queryoptimizer_expressions_Predicate
- quickstep_queryoptimizer_logical_BinaryJoin
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_InsertSelection
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_InsertTuple
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_ScalarLiteral
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_Join
- quickstep_queryoptimizer_logical_Logical
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_Expression
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_MultiwayCartesianJoin
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_logical_Join
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_NestedLoopsJoin
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_Expression
- quickstep_queryoptimizer_expressions_PatternMatcher
- quickstep_queryoptimizer_expressions_Predicate
- quickstep_queryoptimizer_expressions_PredicateLiteral
- quickstep_queryoptimizer_logical_BinaryJoin
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_PatternMatcher
- quickstep_queryoptimizer_logical_LogicalType)
-target_link_libraries(quickstep_queryoptimizer_logical_Project
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_Expression
- quickstep_queryoptimizer_expressions_ExpressionUtil
- quickstep_queryoptimizer_expressions_NamedExpression
- quickstep_queryoptimizer_expressions_PatternMatcher
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_Sample
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_ExpressionUtil
- quickstep_queryoptimizer_expressions_NamedExpression
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_SharedSubplanReference
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_Sort
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_ExpressionUtil
- quickstep_queryoptimizer_expressions_NamedExpression
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_TableGenerator
- quickstep_expressions_tablegenerator_GeneratorFunctionHandle
- quickstep_queryoptimizer_OptimizerContext
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_ExprId
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_TableReference
- glog
- quickstep_queryoptimizer_OptimizerContext
- quickstep_queryoptimizer_OptimizerTree
- quickstep_catalog_CatalogRelation
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_TopLevelPlan
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_ExprId
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_UpdateTable
- glog
- quickstep_queryoptimizer_OptimizerTree
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_Predicate
- quickstep_queryoptimizer_expressions_Scalar
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_utility_Cast
- quickstep_utility_Macros)
-target_link_libraries(quickstep_queryoptimizer_logical_WindowAggregate
- glog
- quickstep_queryoptimizer_expressions_Alias
- quickstep_queryoptimizer_expressions_AttributeReference
- quickstep_queryoptimizer_expressions_Expression
- quickstep_queryoptimizer_expressions_ExpressionUtil
- quickstep_queryoptimizer_expressions_NamedExpression
- quickstep_queryoptimizer_expressions_PatternMatcher
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_queryoptimizer_OptimizerTree
- quickstep_utility_Cast
- quickstep_utility_Macros)
-
-
-# Module all-in-one library:
-add_library(quickstep_queryoptimizer_logical ../../empty_src.cpp OptimizerLogicalModule.hpp)
-target_link_libraries(quickstep_queryoptimizer_logical
- quickstep_queryoptimizer_logical_Aggregate
- quickstep_queryoptimizer_logical_BinaryJoin
- quickstep_queryoptimizer_logical_CopyFrom
- quickstep_queryoptimizer_logical_CreateIndex
- quickstep_queryoptimizer_logical_CreateTable
- quickstep_queryoptimizer_logical_DeleteTuples
- quickstep_queryoptimizer_logical_DropTable
- quickstep_queryoptimizer_logical_Filter
- quickstep_queryoptimizer_logical_HashJoin
- quickstep_queryoptimizer_logical_InsertSelection
- quickstep_queryoptimizer_logical_InsertTuple
- quickstep_queryoptimizer_logical_Join
- quickstep_queryoptimizer_logical_Logical
- quickstep_queryoptimizer_logical_LogicalType
- quickstep_queryoptimizer_logical_MultiwayCartesianJoin
- quickstep_queryoptimizer_logical_NestedLoopsJoin
- quickstep_queryoptimizer_logical_PatternMatcher
- quickstep_queryoptimizer_logical_Project
- quickstep_queryoptimizer_logical_Sample
- quickstep_queryoptimizer_logical_SharedSubplanReference
- quickstep_queryoptimizer_logical_Sort
- quickstep_queryoptimizer_logical_TableGenerator
- quickstep_queryoptimizer_logical_TableReference
- quickstep_queryoptimizer_logical_TopLevelPlan
- quickstep_queryoptimizer_logical_UpdateTable
- quickstep_queryoptimizer_logical_WindowAggregate)
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/logical/CopyFrom.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/logical/CopyFrom.cpp b/query_optimizer/logical/CopyFrom.cpp
deleted file mode 100644
index b0a1423..0000000
--- a/query_optimizer/logical/CopyFrom.cpp
+++ /dev/null
@@ -1,56 +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 "query_optimizer/logical/CopyFrom.hpp"
-
-#include <string>
-#include <vector>
-
-#include "query_optimizer/OptimizerTree.hpp"
-#include "catalog/CatalogRelation.hpp"
-#include "utility/StringUtil.hpp"
-
-namespace quickstep {
-namespace optimizer {
-namespace logical {
-
-void CopyFrom::getFieldStringItems(
- std::vector<std::string> *inline_field_names,
- std::vector<std::string> *inline_field_values,
- std::vector<std::string> *non_container_child_field_names,
- std::vector<OptimizerTreeBaseNodePtr> *non_container_child_fields,
- std::vector<std::string> *container_child_field_names,
- std::vector<std::vector<OptimizerTreeBaseNodePtr>> *container_child_fields) const {
- inline_field_names->push_back("relation");
- inline_field_values->push_back(catalog_relation_->getName());
-
- inline_field_names->push_back("file_name");
- inline_field_values->push_back(file_name_);
-
- inline_field_names->push_back("column_delimiter");
- inline_field_values->push_back("\"" + EscapeSpecialChars(std::string(1, column_delimiter_)) +
- "\"");
-
- inline_field_names->push_back("escape_strings");
- inline_field_values->push_back(escape_strings_ ? "true" : "false");
-}
-
-} // namespace logical
-} // namespace optimizer
-} // namespace quickstep