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:33 UTC
[10/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/InValueList.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/InValueList.hpp b/query_optimizer/expressions/InValueList.hpp
deleted file mode 100644
index 0ef3bba..0000000
--- a/query_optimizer/expressions/InValueList.hpp
+++ /dev/null
@@ -1,159 +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_IN_VALUE_LIST_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_IN_VALUE_LIST_HPP_
-
-#include <cstddef>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#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/Predicate.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class Predicate;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class InValueList;
-typedef std::shared_ptr<const InValueList> InValueListPtr;
-
-/**
- * @brief IN predicate with a value list.
- */
-class InValueList : public Predicate {
- public:
- ExpressionType getExpressionType() const override {
- return ExpressionType::kInValueList;
- }
-
- std::string getName() const override {
- return "InValueList";
- }
-
- bool isConstant() const override {
- return false;
- }
-
- /**
- * @return The expression to test with a value list.
- */
- const ScalarPtr& test_expression() const {
- return test_expression_;
- }
-
- /**
- * @return Expressions to search for the value of the test_expression.
- */
- const std::vector<ScalarPtr>& match_expressions() const {
- return match_expressions_;
- }
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override {
- DCHECK_EQ(children().size(), new_children.size());
- std::vector<ScalarPtr> new_match_expressions;
- for (std::size_t idx = 1; idx < new_children.size(); ++idx) {
- new_match_expressions.emplace_back(
- std::static_pointer_cast<const Scalar>(new_children[idx]));
- }
- return Create(std::static_pointer_cast<const Scalar>(new_children[0]),
- new_match_expressions);
- }
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override {
- std::vector<AttributeReferencePtr> referenced_attrs =
- test_expression_->getReferencedAttributes();
- for (const ScalarPtr &match_expression : match_expressions_) {
- const std::vector<AttributeReferencePtr> referenced_attrs_in_match_expr =
- match_expression->getReferencedAttributes();
- referenced_attrs.insert(referenced_attrs.end(),
- referenced_attrs_in_match_expr.begin(),
- referenced_attrs_in_match_expr.end());
- }
- return referenced_attrs;
- }
-
- ::quickstep::Predicate* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
-
- /**
- * @brief Create an IN predicate with a value list.
- *
- * @param test_expression The expression to test with a value list.
- * @param match_expressions Expressions to search for the value of the test_expression.
- *
- * @return An immutable IN predicate node with a value list.
- */
- static InValueListPtr Create(const ScalarPtr &test_expression,
- const std::vector<ScalarPtr> &match_expressions) {
- return InValueListPtr(new InValueList(test_expression, match_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:
- InValueList(const ScalarPtr &test_expression,
- const std::vector<ScalarPtr> &match_expressions)
- : test_expression_(test_expression),
- match_expressions_(match_expressions) {
- addChild(test_expression_);
- for (const ScalarPtr &match_expression : match_expressions_) {
- addChild(match_expression);
- }
- }
-
- ScalarPtr test_expression_;
- std::vector<ScalarPtr> match_expressions_;
-
- DISALLOW_COPY_AND_ASSIGN(InValueList);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif // QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_IN_VALUE_LIST_HPP_
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/LogicalAnd.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/LogicalAnd.cpp b/query_optimizer/expressions/LogicalAnd.cpp
deleted file mode 100644
index 80ee0eb..0000000
--- a/query_optimizer/expressions/LogicalAnd.cpp
+++ /dev/null
@@ -1,125 +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/LogicalAnd.hpp"
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "expressions/predicate/ConjunctionPredicate.hpp"
-#include "expressions/predicate/TrivialPredicates.hpp"
-#include "query_optimizer/expressions/AttributeReference.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/PatternMatcher.hpp"
-#include "query_optimizer/expressions/Predicate.hpp"
-#include "query_optimizer/expressions/PredicateLiteral.hpp"
-#include "utility/Cast.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-LogicalAnd::LogicalAnd(const std::vector<PredicatePtr> &operands) {
- // Flatten the predicate tree.
- for (const PredicatePtr &operand : operands) {
- LogicalAndPtr logical_and;
- PredicateLiteralPtr literal;
- if (SomeLogicalAnd::MatchesWithConditionalCast(operand, &logical_and)) {
- operands_.insert(operands_.end(),
- logical_and->operands().begin(),
- logical_and->operands().end());
- } else if (!(SomePredicateLiteral::MatchesWithConditionalCast(operand, &literal) &&
- literal->is_true())) {
- operands_.push_back(operand);
- }
- }
-
- for (const PredicatePtr &operand : operands_) {
- addChild(operand);
- }
-}
-
-ExpressionPtr LogicalAnd::copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const {
- DCHECK_EQ(getNumChildren(), new_children.size());
- std::vector<PredicatePtr> operands;
- for (const ExpressionPtr &expression : new_children) {
- PredicatePtr new_expression;
- CHECK(SomePredicate::MatchesWithConditionalCast(expression, &new_expression));
- operands.push_back(new_expression);
- }
- return LogicalAnd::Create(operands);
-}
-
-std::vector<AttributeReferencePtr> LogicalAnd::getReferencedAttributes() const {
- std::vector<AttributeReferencePtr> referenced_attributes;
- for (const PredicatePtr &operand : operands()) {
- const std::vector<AttributeReferencePtr> referenced_attributes_in_operand =
- operand->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_operand.begin(),
- referenced_attributes_in_operand.end());
- }
- return referenced_attributes;
-}
-
-::quickstep::Predicate* LogicalAnd::concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
- if (operands_.empty()) {
- return new TruePredicate();
- }
-
- if (operands_.size() == 1u) {
- return operands_[0]->concretize(substitution_map);
- }
-
- std::unique_ptr<::quickstep::ConjunctionPredicate> concretized_predicate;
- concretized_predicate.reset(new ::quickstep::ConjunctionPredicate());
-
- for (const PredicatePtr &operand : operands_) {
- concretized_predicate->addPredicate(
- operand->concretize(substitution_map));
- }
-
- return concretized_predicate.release();
-}
-
-void LogicalAnd::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 {
- if (!operands_.empty()) {
- container_child_field_names->push_back("");
- container_child_fields->emplace_back(CastSharedPtrVector<OptimizerTreeBase>(operands_));
- } else {
- inline_field_names->push_back("static_value");
- 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/LogicalAnd.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/LogicalAnd.hpp b/query_optimizer/expressions/LogicalAnd.hpp
deleted file mode 100644
index 8152728..0000000
--- a/query_optimizer/expressions/LogicalAnd.hpp
+++ /dev/null
@@ -1,128 +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_LOGICAL_AND_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_LOGICAL_AND_HPP_
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#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/Predicate.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-class CatalogAttribute;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class LogicalAnd;
-typedef std::shared_ptr<const LogicalAnd> LogicalAndPtr;
-
-/**
- * @brief A logical conjunction (AND) of a list of predicate
- * operands.
- */
-class LogicalAnd : public Predicate {
- public:
- ExpressionType getExpressionType() const override {
- return ExpressionType::kLogicalAnd;
- }
-
- std::string getName() const override {
- return "And";
- }
-
- // FIXME(qzeng): isConstant() is not strictly well-defined.
- // We do not determine the constant value for each expression.
- // A logical AND or OR is considered as not constant
- // only if any predicate is not constant, even it may have
- // a static value.
- bool isConstant() const override {
- for (const PredicatePtr &operand : operands_) {
- if (!operand->isConstant()) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * @return Operands that the logical AND is applied on.
- */
- const std::vector<PredicatePtr>& operands() const { return operands_; }
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override;
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override;
-
- ::quickstep::Predicate* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
-
- /**
- * @brief Creates an immutable LogicalAnd. If any operand is also a LogicalAnd,
- * the operand is pulled out and merged into the returned predicate
- * (i.e. nested AND expressions are flattened).
- *
- * @param operands The operands to be applied to.
- * @return An immutable LogicalAnd.
- */
- static LogicalAndPtr Create(const std::vector<PredicatePtr> &operands) {
- DCHECK_GT(operands.size(), 1u);
- return LogicalAndPtr(new LogicalAnd(operands));
- }
-
- 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 LogicalAnd(const std::vector<PredicatePtr> &operands);
-
- std::vector<PredicatePtr> operands_;
- DISALLOW_COPY_AND_ASSIGN(LogicalAnd);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_LOGICAL_AND_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/LogicalNot.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/LogicalNot.cpp b/query_optimizer/expressions/LogicalNot.cpp
deleted file mode 100644
index dce13a9..0000000
--- a/query_optimizer/expressions/LogicalNot.cpp
+++ /dev/null
@@ -1,65 +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/LogicalNot.hpp"
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "expressions/predicate/NegationPredicate.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/PatternMatcher.hpp"
-#include "query_optimizer/expressions/Predicate.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-ExpressionPtr LogicalNot::copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const {
- DCHECK_EQ(new_children.size(), children().size());
- PredicatePtr operand;
- CHECK(SomePredicate::MatchesWithConditionalCast(new_children[0], &operand));
- return LogicalNot::Create(operand);
-}
-
-::quickstep::Predicate* LogicalNot::concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
- return new ::quickstep::NegationPredicate(
- operand_->concretize(substitution_map));
-}
-
-void LogicalNot::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("");
- 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/LogicalNot.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/LogicalNot.hpp b/query_optimizer/expressions/LogicalNot.hpp
deleted file mode 100644
index 90a98cd..0000000
--- a/query_optimizer/expressions/LogicalNot.hpp
+++ /dev/null
@@ -1,114 +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_LOGICAL_NOT_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_LOGICAL_NOT_HPP_
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#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/Predicate.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class CatalogAttribute;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class LogicalNot;
-typedef std::shared_ptr<const LogicalNot> LogicalNotPtr;
-
-/**
- * @brief Applies a logical negation (NOT) operator to a predicate expression.
- */
-class LogicalNot : public Predicate {
- public:
- ExpressionType getExpressionType() const override {
- return ExpressionType::kLogicalNot;
- }
-
- std::string getName() const override { return "NOT"; }
-
- bool isConstant() const override { return operand_->isConstant(); }
-
- /**
- * @return The operand of this negation.
- */
- const PredicatePtr& operand() const { return operand_; }
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override;
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override {
- return operand_->getReferencedAttributes();
- }
-
- ::quickstep::Predicate* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
-
- /**
- * @brief Creates an immutable LogicalNot.
- *
- * @param operand Operand of the logical not operator.
- * @return An immutable LogicalNot.
- */
- static LogicalNotPtr Create(const PredicatePtr &operand) {
- return LogicalNotPtr(new LogicalNot(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:
- explicit LogicalNot(const PredicatePtr &operand)
- : operand_(operand) {
- addChild(operand_);
- }
-
- PredicatePtr operand_;
-
- DISALLOW_COPY_AND_ASSIGN(LogicalNot);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_LOGICAL_NOT_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/LogicalOr.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/LogicalOr.cpp b/query_optimizer/expressions/LogicalOr.cpp
deleted file mode 100644
index 02028e1..0000000
--- a/query_optimizer/expressions/LogicalOr.cpp
+++ /dev/null
@@ -1,123 +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/LogicalOr.hpp"
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "expressions/predicate/DisjunctionPredicate.hpp"
-#include "expressions/predicate/TrivialPredicates.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/PatternMatcher.hpp"
-#include "query_optimizer/expressions/Predicate.hpp"
-#include "query_optimizer/expressions/PredicateLiteral.hpp"
-#include "utility/Cast.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-LogicalOr::LogicalOr(const std::vector<PredicatePtr> &operands) {
- // Flatten the predicate tree.
- for (const PredicatePtr &operand : operands) {
- LogicalOrPtr logical_or;
- PredicateLiteralPtr literal;
- if (SomeLogicalOr::MatchesWithConditionalCast(operand, &logical_or)) {
- operands_.insert(operands_.end(),
- logical_or->operands().begin(),
- logical_or->operands().end());
- } else if (!SomePredicateLiteral::MatchesWithConditionalCast(operand, &literal) ||
- !literal->is_true()) {
- operands_.push_back(operand);
- }
- }
-
- for (const PredicatePtr &operand : operands_) {
- addChild(operand);
- }
-}
-
-ExpressionPtr LogicalOr::copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const {
- DCHECK_EQ(getNumChildren(), new_children.size());
- std::vector<PredicatePtr> operands;
- for (const ExpressionPtr &expression : new_children) {
- PredicatePtr new_expression;
- CHECK(SomePredicate::MatchesWithConditionalCast(expression, &new_expression));
- operands.push_back(new_expression);
- }
- return LogicalOr::Create(operands);
-}
-
-std::vector<AttributeReferencePtr> LogicalOr::getReferencedAttributes() const {
- std::vector<AttributeReferencePtr> referenced_attributes;
- for (const PredicatePtr &operand : operands()) {
- const std::vector<AttributeReferencePtr> referenced_attributes_in_operand =
- operand->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_operand.begin(),
- referenced_attributes_in_operand.end());
- }
- return referenced_attributes;
-}
-
-::quickstep::Predicate* LogicalOr::concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
- if (operands_.empty()) {
- return new FalsePredicate();
- }
-
- if (operands_.size() == 1u) {
- return operands_[0]->concretize(substitution_map);
- }
-
- std::unique_ptr<::quickstep::DisjunctionPredicate> concretized_predicate;
- concretized_predicate.reset(new ::quickstep::DisjunctionPredicate());
-
- for (const PredicatePtr &operand : operands_) {
- concretized_predicate->addPredicate(
- operand->concretize(substitution_map));
- }
-
- return concretized_predicate.release();
-}
-
-void LogicalOr::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 {
- if (!operands_.empty()) {
- container_child_field_names->push_back("");
- container_child_fields->emplace_back(CastSharedPtrVector<OptimizerTreeBase>(operands_));
- } else {
- inline_field_names->push_back("static_value");
- inline_field_values->push_back("false");
- }
-}
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/LogicalOr.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/LogicalOr.hpp b/query_optimizer/expressions/LogicalOr.hpp
deleted file mode 100644
index f96b6cd..0000000
--- a/query_optimizer/expressions/LogicalOr.hpp
+++ /dev/null
@@ -1,128 +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_LOGICAL_OR_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_LOGICAL_OR_HPP_
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#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/Predicate.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-class CatalogAttribute;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class LogicalOr;
-typedef std::shared_ptr<const LogicalOr> LogicalOrPtr;
-
-/**
- * @brief A logical disconjunction (OR) of a list of predicate
- * operands.
- */
-class LogicalOr : public Predicate {
- public:
- ExpressionType getExpressionType() const override {
- return ExpressionType::kLogicalOr;
- }
-
- std::string getName() const override {
- return "Or";
- }
-
- // FIXME(qzeng): isConstant() is not strictly well-defined.
- // We do not determine the constant value for each expression.
- // A logical AND or OR is considered as not constant
- // only if any predicate is not constant, even it may have
- // a static value.
- bool isConstant() const override {
- for (const PredicatePtr &operand : operands_) {
- if (!operand->isConstant()) {
- return false;
- }
- }
- return true;
- }
-
- /**
- * @return Operands that the logical OR is applied on.
- */
- const std::vector<PredicatePtr>& operands() const { return operands_; }
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override;
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override;
-
- ::quickstep::Predicate* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
-
- /**
- * @brief Creates an immutable LogicalOr. If any operand is also a LogicalOr,
- * the operand is pulled out and merged into the returned predicate
- * (i.e. nested OR expressions are flattened).
- *
- * @param operands The operands to be applied to.
- * @return An immutable LogicalOr.
- */
- static LogicalOrPtr Create(const std::vector<PredicatePtr> &operands) {
- DCHECK_GT(operands.size(), 1u);
- return LogicalOrPtr(new LogicalOr(operands));
- }
-
- 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 LogicalOr(const std::vector<PredicatePtr> &operands);
-
- std::vector<PredicatePtr> operands_;
- DISALLOW_COPY_AND_ASSIGN(LogicalOr);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_LOGICAL_OR_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/NamedExpression.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/NamedExpression.cpp b/query_optimizer/expressions/NamedExpression.cpp
deleted file mode 100644
index 992a84a..0000000
--- a/query_optimizer/expressions/NamedExpression.cpp
+++ /dev/null
@@ -1,59 +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/NamedExpression.hpp"
-
-#include <string>
-#include <vector>
-
-#include "query_optimizer/OptimizerTree.hpp"
-#include "types/Type.hpp"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-void NamedExpression::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("id");
- inline_field_values->push_back(std::to_string(id_));
-
- inline_field_names->push_back("name");
- inline_field_values->push_back(attribute_name_);
-
- if (attribute_name_ != attribute_alias_) {
- inline_field_names->push_back("alias");
- inline_field_values->push_back(attribute_alias_);
- }
-
- inline_field_names->push_back("relation");
- inline_field_values->push_back(relation_name_);
-
- inline_field_names->push_back("type");
- inline_field_values->push_back(getValueType().getName());
-}
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/NamedExpression.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/NamedExpression.hpp b/query_optimizer/expressions/NamedExpression.hpp
deleted file mode 100644
index 9de8005..0000000
--- a/query_optimizer/expressions/NamedExpression.hpp
+++ /dev/null
@@ -1,131 +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_NAMED_EXPRESSION_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_NAMED_EXPRESSION_HPP_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "query_optimizer/OptimizerTree.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class NamedExpression;
-typedef std::shared_ptr<const NamedExpression> NamedExpressionPtr;
-
-/**
- * @brief Expression with an expression ID and name, including Alias and
- * AttributeReference. A NamedExpression can be referenced by other
- * expressions.
- */
-class NamedExpression : public Scalar {
- public:
- ~NamedExpression() override {}
-
- /**
- * @return The expression ID.
- */
- inline ExprId id() const { return id_; }
-
- /**
- * @return The (internal) attribute name.
- */
- inline const std::string& attribute_name() const { return attribute_name_; }
-
- /**
- * @return The attribute alias.
- */
- inline const std::string& attribute_alias() const { return attribute_alias_; }
-
- /**
- * @return The relation name. May be empty.
- */
- inline const std::string& relation_name() const { return relation_name_; }
-
- /**
- * @brief Compares this named expression with \p other. Two named expressions
- * are equal if they have the same ExprId and are both Alias or
- * AttributeReference.
- *
- * @param other Another named expression to compare with.
- * @return True if the named expression is equal to \p other.
- */
- inline bool equals(const NamedExpressionPtr &other) const {
- return getExpressionType() == other->getExpressionType() &&
- id_ == other->id();
- }
-
- protected:
- /**
- * @brief Constructor.
- *
- * @param id ExprId assigned to this expression.
- * @param attribute_name The (internal) attribute name.
- * @param attribute_alias The attribute name for display.
- * @param relation_name A relation name indicating where it comes from. Can be
- * empty. This is only for the printing purpose only.
- * When this named expression is converted to a
- * CatalogAttribute, the relation name may not be
- * \p relation_name.
- */
- NamedExpression(const ExprId id,
- const std::string &attribute_name,
- const std::string &attribute_alias,
- const std::string &relation_name)
- : id_(id),
- attribute_name_(attribute_name),
- attribute_alias_(attribute_alias),
- relation_name_(relation_name) {}
-
- 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:
- ExprId id_;
- std::string attribute_name_;
- std::string attribute_alias_;
- std::string relation_name_;
-
- DISALLOW_COPY_AND_ASSIGN(NamedExpression);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_NAMED_EXPRESSION_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/OptimizerExpressionsModule.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/OptimizerExpressionsModule.hpp b/query_optimizer/expressions/OptimizerExpressionsModule.hpp
deleted file mode 100644
index 4462201..0000000
--- a/query_optimizer/expressions/OptimizerExpressionsModule.hpp
+++ /dev/null
@@ -1,24 +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.
- **/
-
-/** @defgroup OptimizerExpressions
- * @ingroup QueryOptimizer
- *
- * Expressions used in the query optimizer.
- **/
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/PatternMatcher.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/PatternMatcher.hpp b/query_optimizer/expressions/PatternMatcher.hpp
deleted file mode 100644
index 18d6b1c..0000000
--- a/query_optimizer/expressions/PatternMatcher.hpp
+++ /dev/null
@@ -1,171 +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_PATTERN_MATCHER_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_PATTERN_MATCHER_HPP_
-
-#include <memory>
-#include <type_traits>
-
-#include "query_optimizer/expressions/ExpressionType.hpp"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-class AggregateFunction;
-class Alias;
-class Avg;
-class AttributeReference;
-class BinaryExpression;
-class Cast;
-class ComparisonExpression;
-class Count;
-class Exists;
-class InTableQuery;
-class InValueList;
-class LogicalAnd;
-class LogicalNot;
-class LogicalOr;
-class Max;
-class Min;
-class NamedExpression;
-class Predicate;
-class PredicateLiteral;
-class Scalar;
-class ScalarLiteral;
-class Sum;
-class UnaryExpression;
-class WindowAggregateFunction;
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-/**
- * @brief Templated matcher for each Expression node class.
- *
- * @param ExpressionClass The Expression class for the expression node to be matched with.
- * @param expression_types All the expression types of the Expression class.
- */
-template <class ExpressionClass, ExpressionType... expression_types>
-class SomeExpressionNode {
- public:
- /**
- * @brief Checks whether the object managed in \p expression is an instance
- * of the template argument ExpressionClass by checking whether
- * it is one of types in the given template arguments expression_types.
- *
- * @param expression The expression node to be checked.
- * @return True for a match; otherwise false.
- */
- template <class OtherExpressionClass>
- static bool Matches(const std::shared_ptr<const OtherExpressionClass> &expression) {
- for (const ExpressionType expression_type : kExpressionTypes) {
- if (expression->getExpressionType() == expression_type) {
- return true;
- }
- }
- return false;
- }
-
- /**
- * @brief Checks whether the object managed in \p expression is an instance
- * of the template argument ExpressionClass by checking whether
- * it is one of types in the given template arguments expression_types,
- * If true, it additionally casts \p expression to a std::shared_ptr
- * \p cast_expression of the template argument ExpressionClass.
- *
- * @param expression The expression node to be checked.
- * @param cast_expression The cast expression node.
- * @return True if the object managed in \p expression is an instance of ExpressionClass.
- */
- template <class OtherExpressionClass>
- static bool MatchesWithConditionalCast(
- const std::shared_ptr<const OtherExpressionClass> &expression,
- std::shared_ptr<const ExpressionClass> *cast_expression) {
- bool is_match = Matches(expression);
- if (is_match) {
- *cast_expression = std::static_pointer_cast<const ExpressionClass>(expression);
- }
- return is_match;
- }
-
- private:
- constexpr static ExpressionType kExpressionTypes[] = {expression_types...};
-};
-
-template <class ExpressionClass, ExpressionType... expression_types>
-constexpr ExpressionType SomeExpressionNode<ExpressionClass, expression_types...>::kExpressionTypes[];
-
-// Specializations for all Expression classes.
-
-using SomeAlias = SomeExpressionNode<Alias, ExpressionType::kAlias>;
-using SomeAttributeReference = SomeExpressionNode<AttributeReference, ExpressionType::kAttributeReference>;
-using SomeBinaryExpression = SomeExpressionNode<BinaryExpression, ExpressionType::kBinaryExpression>;
-using SomeCast = SomeExpressionNode<Cast, ExpressionType::kCast>;
-using SomeComparisonExpression = SomeExpressionNode<ComparisonExpression, ExpressionType::kComparisonExpression>;
-using SomeExists = SomeExpressionNode<Exists, ExpressionType::kExists>;
-using SomeInTableQuery = SomeExpressionNode<InTableQuery, ExpressionType::kInTableQuery>;
-using SomeInValueList = SomeExpressionNode<InValueList, ExpressionType::kInValueList>;
-using SomeLogicalAnd = SomeExpressionNode<LogicalAnd, ExpressionType::kLogicalAnd>;
-using SomeLogicalNot = SomeExpressionNode<LogicalNot, ExpressionType::kLogicalNot>;
-using SomeLogicalOr = SomeExpressionNode<LogicalOr, ExpressionType::kLogicalOr>;
-using SomeNamedExpression = SomeExpressionNode<NamedExpression,
- ExpressionType::kAttributeReference,
- ExpressionType::kAlias>;
-using SomePredicate = SomeExpressionNode<Predicate,
- ExpressionType::kComparisonExpression,
- ExpressionType::kExists,
- ExpressionType::kInTableQuery,
- ExpressionType::kInValueList,
- ExpressionType::kLogicalAnd,
- ExpressionType::kLogicalNot,
- ExpressionType::kLogicalOr,
- ExpressionType::kPredicateLiteral>;
-using SomePredicateLiteral = SomeExpressionNode<PredicateLiteral, ExpressionType::kPredicateLiteral>;
-using SomeScalar = SomeExpressionNode<Scalar,
- ExpressionType::kAlias,
- ExpressionType::kAttributeReference,
- ExpressionType::kBinaryExpression,
- ExpressionType::kCast,
- ExpressionType::kComparisonExpression,
- ExpressionType::kLogicalAnd,
- ExpressionType::kLogicalNot,
- ExpressionType::kLogicalOr,
- ExpressionType::kPredicateLiteral,
- ExpressionType::kScalarLiteral,
- ExpressionType::kSearchedCase,
- ExpressionType::kSimpleCase,
- ExpressionType::kUnaryExpression>;
-using SomeScalarLiteral = SomeExpressionNode<ScalarLiteral, ExpressionType::kScalarLiteral>;
-using SomeUnaryExpression = SomeExpressionNode<UnaryExpression, ExpressionType::kUnaryExpression>;
-using SomeWindowAggregateFunction = SomeExpressionNode<WindowAggregateFunction,
- ExpressionType::kWindowAggregateFunction>;
-
-using SomeAggregateFunction = SomeExpressionNode<AggregateFunction,
- ExpressionType::kAggregateFunction>;
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_PATTERN_MATCHER_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/Predicate.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/Predicate.hpp b/query_optimizer/expressions/Predicate.hpp
deleted file mode 100644
index 444af6b..0000000
--- a/query_optimizer/expressions/Predicate.hpp
+++ /dev/null
@@ -1,91 +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_PREDICATE_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_PREDICATE_HPP_
-
-#include <memory>
-#include <unordered_map>
-
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-#include "types/Type.hpp"
-#include "types/TypeFactory.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class Predicate;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class Predicate;
-typedef std::shared_ptr<const Predicate> PredicatePtr;
-
-/**
- * @brief Expression that returns boolean values.
- */
-class Predicate : public Expression {
- public:
- /**
- * @brief Destructor.
- */
- ~Predicate() override {}
-
- const Type& getValueType() const override {
- // The type system does not have a bool type, so we use non-nullable kInt
- // instead.
- return TypeFactory::GetType(kInt /* TypeID */,
- false /* nullable */);
- }
-
- /**
- * @brief Returns a concretized predicate in the Quickstep execution
- * expression system with AttributeReferences replaced by
- * CatalogAttribute references provided in \p substitution_map.
- * @note In the Quickstep execution expression system, Predicate is not Scalar
- *type. We do not use concretize() for predicate concretization.
- *
- * @param substitution_map Map from ExprId to CatalogAttribute for use in
- * replacing AttributeReference.
- * @return A concretized predicate for evaluation.
- */
- virtual ::quickstep::Predicate* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*>& substitution_map) const = 0;
-
- protected:
- Predicate() {}
-
- private:
- DISALLOW_COPY_AND_ASSIGN(Predicate);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_PREDICATE_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/PredicateLiteral.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/PredicateLiteral.cpp b/query_optimizer/expressions/PredicateLiteral.cpp
deleted file mode 100644
index 724458e..0000000
--- a/query_optimizer/expressions/PredicateLiteral.cpp
+++ /dev/null
@@ -1,64 +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/PredicateLiteral.hpp"
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "expressions/predicate/TrivialPredicates.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "query_optimizer/expressions/Expression.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-ExpressionPtr PredicateLiteral::copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const {
- DCHECK_EQ(new_children.size(), children().size());
- return PredicateLiteral::Create(is_true_);
-}
-
-::quickstep::Predicate* PredicateLiteral::concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
- if (is_true()) {
- return new TruePredicate();
- } else {
- return new FalsePredicate();
- }
-}
-
-void PredicateLiteral::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("value");
- inline_field_values->push_back(is_true_ ? "true" : "false");
-}
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/PredicateLiteral.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/PredicateLiteral.hpp b/query_optimizer/expressions/PredicateLiteral.hpp
deleted file mode 100644
index 234b6e1..0000000
--- a/query_optimizer/expressions/PredicateLiteral.hpp
+++ /dev/null
@@ -1,108 +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_PREDICATE_LITERAL_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_PREDICATE_LITERAL_HPP_
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#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/Predicate.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class CatalogAttribute;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class PredicateLiteral;
-typedef std::shared_ptr<const PredicateLiteral> PredicateLiteralPtr;
-
-/**
- * @brief A boolean true or false literal.
- */
-class PredicateLiteral : public Predicate {
- public:
- ExpressionType getExpressionType() const override {
- return ExpressionType::kPredicateLiteral;
- }
-
- std::string getName() const override { return "Literal"; }
-
- bool isConstant() const override { return true; }
-
- bool is_true() const { return is_true_; }
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override;
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override {
- return {};
- }
-
- ::quickstep::Predicate* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
-
- /**
- * @brief Creates an immutable PredicateLiteral.
- *
- * @param is_true Indicates whether the value is true or false.
- * @return An immutable PredicateLiteral with the given boolean value.
- */
- static PredicateLiteralPtr Create(bool is_true) {
- return PredicateLiteralPtr(new PredicateLiteral(is_true));
- }
-
- 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 PredicateLiteral(bool is_true) : is_true_(is_true) {}
-
- bool is_true_;
-
- DISALLOW_COPY_AND_ASSIGN(PredicateLiteral);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_PREDICATE_LITERAL_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/Scalar.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/Scalar.hpp b/query_optimizer/expressions/Scalar.hpp
deleted file mode 100644
index 4870118..0000000
--- a/query_optimizer/expressions/Scalar.hpp
+++ /dev/null
@@ -1,81 +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_SCALAR_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SCALAR_HPP_
-
-#include <memory>
-#include <unordered_map>
-
-#include "query_optimizer/expressions/Expression.hpp"
-#include "query_optimizer/expressions/ExprId.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class Scalar;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class Scalar;
-typedef std::shared_ptr<const Scalar> ScalarPtr;
-
-/**
- * @brief Scalar expression that returns a single value based on input values
- * that are not across multiple rows in an input relation.
- */
-class Scalar : public Expression {
- public:
- ~Scalar() override {}
-
- /**
- * @brief Converts this expression to an expression for evaluation (in
- * quickstep execution expressions system under /expressions)
- * with each attribute reference being replaced by a CatalogAttribute
- * reference provided in \p substitution_map.
- *
- * @param substitution_map Map from ExprId to CatalogAttribute for use in
- * substituting CatalogAttribute for
- * AttributeReference.
- * @return Concretized expression for evaluation.
- */
- virtual ::quickstep::Scalar* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*>& substitution_map)
- const = 0;
-
- protected:
- Scalar() {}
-
- private:
- DISALLOW_COPY_AND_ASSIGN(Scalar);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SCALAR_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/ScalarLiteral.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/ScalarLiteral.cpp b/query_optimizer/expressions/ScalarLiteral.cpp
deleted file mode 100644
index d70c4cf..0000000
--- a/query_optimizer/expressions/ScalarLiteral.cpp
+++ /dev/null
@@ -1,74 +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/ScalarLiteral.hpp"
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "expressions/scalar/ScalarLiteral.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 "types/Type.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-namespace optimizer {
-namespace expressions {
-
-const Type& ScalarLiteral::getValueType() const {
- return value_type_;
-}
-
-ExpressionPtr ScalarLiteral::copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const {
- DCHECK_EQ(new_children.size(), children().size());
- return ScalarLiteral::Create(value_, value_type_);
-}
-
-::quickstep::Scalar *ScalarLiteral::concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
- return new ::quickstep::ScalarLiteral(value_, value_type_);
-}
-
-void ScalarLiteral::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("value");
- if (value_.isNull()) {
- inline_field_values->push_back("NULL");
- } else {
- inline_field_values->push_back(value_type_.printValueToString(value_));
- }
-
- inline_field_names->push_back("type");
- inline_field_values->push_back(getValueType().getName());
-}
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/ScalarLiteral.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/ScalarLiteral.hpp b/query_optimizer/expressions/ScalarLiteral.hpp
deleted file mode 100644
index 8ebc41c..0000000
--- a/query_optimizer/expressions/ScalarLiteral.hpp
+++ /dev/null
@@ -1,120 +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_SCALAR_LITERAL_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SCALAR_LITERAL_HPP_
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#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 "types/TypedValue.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class Type;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class ScalarLiteral;
-typedef std::shared_ptr<const ScalarLiteral> ScalarLiteralPtr;
-
-/**
- * @brief A non-boolean scalar literal.
- */
-class ScalarLiteral : public Scalar {
- public:
- std::string getName() const override {
- return "Literal";
- }
-
- ExpressionType getExpressionType() const override {
- return ExpressionType::kScalarLiteral;
- }
-
- const Type& getValueType() const override;
-
- bool isConstant() const override { return true; }
-
- /**
- * @return The literal value.
- */
- const TypedValue& value() const { return value_; }
-
- ExpressionPtr copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const override;
-
- std::vector<AttributeReferencePtr> getReferencedAttributes() const override {
- return {};
- }
-
- ::quickstep::Scalar* concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const override;
-
- /**
- * @brief Creates an immutable ScalarLiteral.
- * @param literal_value The literal value.
- * @return An immutable ScalarLiteral with the given literal value.
- */
- static const ScalarLiteralPtr Create(const TypedValue &literal_value,
- const Type &literal_value_type) {
- return ScalarLiteralPtr(new ScalarLiteral(literal_value, literal_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:
- ScalarLiteral(const TypedValue &literal_value,
- const Type &literal_value_type)
- : value_(literal_value),
- value_type_(literal_value_type) {}
-
- const TypedValue value_;
- const Type &value_type_;
- DISALLOW_COPY_AND_ASSIGN(ScalarLiteral);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SCALAR_LITERAL_HPP_ */
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/query_optimizer/expressions/SearchedCase.cpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/SearchedCase.cpp b/query_optimizer/expressions/SearchedCase.cpp
deleted file mode 100644
index 2de52c9..0000000
--- a/query_optimizer/expressions/SearchedCase.cpp
+++ /dev/null
@@ -1,166 +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/SearchedCase.hpp"
-
-#include <cstddef>
-#include <memory>
-#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/Expression.hpp"
-#include "query_optimizer/expressions/Predicate.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 SearchedCase::isConstant() const {
- // We treat a SearchedCase as constant only if all operands are constant.
- for (const PredicatePtr &condition_predicate : condition_predicates_) {
- if (!condition_predicate->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> SearchedCase::getReferencedAttributes() const {
- std::vector<AttributeReferencePtr> referenced_attributes;
- for (const PredicatePtr &condition_predicate : condition_predicates_) {
- const std::vector<AttributeReferencePtr> referenced_attributes_in_condition_predicate =
- condition_predicate->getReferencedAttributes();
- referenced_attributes.insert(referenced_attributes.end(),
- referenced_attributes_in_condition_predicate.begin(),
- referenced_attributes_in_condition_predicate.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 SearchedCase::copyWithNewChildren(
- const std::vector<ExpressionPtr> &new_children) const {
- DCHECK_EQ(getNumChildren(), new_children.size());
-
- std::vector<PredicatePtr> new_condition_predicates;
- std::vector<ScalarPtr> new_conditional_result_expressions;
- ScalarPtr new_else_result_expression;
-
- new_condition_predicates.reserve(condition_predicates_.size());
- new_conditional_result_expressions.reserve(condition_predicates_.size());
-
- std::size_t num_when_clauses = condition_predicates_.size();
- for (std::size_t index = 0; index < num_when_clauses; ++index) {
- new_condition_predicates.push_back(
- std::static_pointer_cast<const Predicate>(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_condition_predicates,
- new_conditional_result_expressions,
- new_else_result_expression, value_type_);
-}
-
-::quickstep::Scalar* SearchedCase::concretize(
- const std::unordered_map<ExprId, const CatalogAttribute*> &substitution_map) const {
- std::vector<std::unique_ptr<quickstep::Predicate>> when_predicates;
- for (const PredicatePtr &predicate : condition_predicates_) {
- 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_->concretize(substitution_map));
-}
-
-void SearchedCase::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 {
- container_child_field_names->push_back("condition_perdicates");
- container_child_fields->push_back(
- CastSharedPtrVector<OptimizerTreeBase>(condition_predicates_));
-
- container_child_field_names->push_back("conditional_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/SearchedCase.hpp
----------------------------------------------------------------------
diff --git a/query_optimizer/expressions/SearchedCase.hpp b/query_optimizer/expressions/SearchedCase.hpp
deleted file mode 100644
index 79c37a5..0000000
--- a/query_optimizer/expressions/SearchedCase.hpp
+++ /dev/null
@@ -1,172 +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_SEARCHED_CASE_HPP_
-#define QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SEARCHED_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/Predicate.hpp"
-#include "query_optimizer/expressions/Scalar.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class CatalogAttribute;
-class Type;
-
-namespace optimizer {
-namespace expressions {
-
-/** \addtogroup OptimizerExpressions
- * @{
- */
-
-class SearchedCase;
-typedef std::shared_ptr<const SearchedCase> SearchedCasePtr;
-
-/**
- * @brief A searched CASE expression. It searches the first predicate in
- * <condition_predicates_> that evaluates to true and returns the value
- * of the expression in <conditional_result_expressions_> at the same
- * position; if none of <condition_predicates_> evaluate to true, returns
- * the value of <else_result_expression_> when <else_result_expression_>
- * is not NULL, otherwise returns NULL.
- */
-class SearchedCase : public Scalar {
- public:
- ExpressionType getExpressionType() const override {
- return ExpressionType::kSearchedCase;
- }
-
- std::string getName() const override {
- return "SearchedCase";
- }
-
- const Type& getValueType() const override {
- return value_type_;
- }
-
- /**
- * @return The vector of condition predicates.
- */
- const std::vector<PredicatePtr>& condition_predicates() const {
- return condition_predicates_;
- }
-
- /**
- * @return The vector of conditional result expressions.
- */
- 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 SearchedCase.
- *
- * @param condition_predicates A vector of condition predicates.
- * @param conditional_result_expressions A vector of result expressions, one
- * for each condition predicate.
- * @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 SearchedCasePtr Create(const std::vector<PredicatePtr> &condition_predicates,
- const std::vector<ScalarPtr> &conditional_result_expressions,
- const ScalarPtr &else_result_expression,
- const Type &value_type) {
- return SearchedCasePtr(new SearchedCase(condition_predicates,
- 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:
- SearchedCase(const std::vector<PredicatePtr> &condition_predicates,
- const std::vector<ScalarPtr> &conditional_result_expressions,
- const ScalarPtr &else_result_expression,
- const Type &value_type)
- : condition_predicates_(condition_predicates),
- conditional_result_expressions_(conditional_result_expressions),
- else_result_expression_(else_result_expression),
- value_type_(value_type) {
- for (const PredicatePtr &condition_predicate : condition_predicates_) {
- addChild(condition_predicate);
- }
- for (const ScalarPtr &conditional_result_expression : conditional_result_expressions_) {
- addChild(conditional_result_expression);
- }
- if (else_result_expression_ != nullptr) {
- addChild(else_result_expression_);
- }
- }
-
- std::vector<PredicatePtr> condition_predicates_;
- std::vector<ScalarPtr> conditional_result_expressions_;
-
- // May be NULL.
- ScalarPtr else_result_expression_;
-
- const Type &value_type_;
-
- DISALLOW_COPY_AND_ASSIGN(SearchedCase);
-};
-
-/** @} */
-
-} // namespace expressions
-} // namespace optimizer
-} // namespace quickstep
-
-#endif /* QUICKSTEP_QUERY_OPTIMIZER_EXPRESSIONS_SEARCHED_CASE_HPP_ */