[30/51] [abbrv] [partial] incubator-quickstep git commit: remove c++ files

[sp...@apache.org]

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseIndexProperties.hpp
----------------------------------------------------------------------
diff --git a/parser/ParseIndexProperties.hpp b/parser/ParseIndexProperties.hpp
deleted file mode 100644
index 1ff13be..0000000
--- a/parser/ParseIndexProperties.hpp
+++ /dev/null
@@ -1,512 +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_PARSER_PARSE_INDEX_PROPERTIES_HPP_
-#define QUICKSTEP_PARSER_PARSE_INDEX_PROPERTIES_HPP_
-
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <vector>
-#include <unordered_map>
-
-#include "parser/ParseKeyValue.hpp"
-#include "parser/ParseString.hpp"
-#include "parser/ParseTreeNode.hpp"
-#include "storage/StorageBlockLayout.pb.h"
-#include "utility/Macros.hpp"
-#include "utility/PtrList.hpp"
-#include "utility/StringUtil.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-/** \addtogroup Parser
- *  @{
- */
-
-/**
- * @brief Base class for different types of indices and their associated properties
- */
-class IndexProperties {
- public:
-  typedef std::unordered_map<const char*, ParseKeyValue::KeyValueType> valid_property_map_type;
-
-  // An enum specifying the reason for an invalid index description, if any.
-  enum class InvalidIndexType {
-    kNone = 0,
-    kUnimplemented,
-    kDuplicateKey,
-    kInvalidKey,
-    kInvalidValue,
-    kTypeIsNotString,
-    kSizeIsFloat,
-    kSizeIsNegative,
-    kNumHashesIsFloat,
-    kNumHashesIsNegative,
-    kProjectedCountIsFloat,
-    kProjectedCountIsNegative
-  };
-
-  /**
-   * @brief Constructor.
-   * @note The constructor takes ownership of index_sub_block_description.
-   *
-   * @param index_sub_block_description A pointer to an IndexSubBlockDescription proto object.
-   * @param invalid_index_type An enum describing the validity of index.
-   * @param invalid_property_node A pointer to an invalid ParseKeyValue node, if any.
-   **/
-  IndexProperties(IndexSubBlockDescription *index_sub_block_description,
-                  const InvalidIndexType invalid_index_type = InvalidIndexType::kNone,
-                  const ParseKeyValue *invalid_property_node = nullptr)
-      : index_sub_block_description_(index_sub_block_description),
-        invalid_index_type_(invalid_index_type),
-        invalid_property_node_(invalid_property_node) {
-  }
-
-  /**
-   * @brief Virtual Destructor
-   */
-  virtual ~IndexProperties() {
-  }
-
-  /**
-   * @brief Returns printable string that specifies reason for invalid index instance.
-   *
-   * @return The string describing the reason for invalid index
-   **/
-  virtual std::string getReasonForInvalidIndexDescription() const = 0;
-
-  /**
-   * @brief Modifies the index description given a set of custom properties
-   *        specified as a key-value list of properties.
-   *
-   * @param key_value_list Key Value list of custom properties.
-   * @return Returns true if the given set of custom properties was valid
-   *         and was applied correctly, otherwise returns false.
-   **/
-  virtual bool addCustomProperties(const PtrList<ParseKeyValue> *key_value_list) = 0;
-
-  /**
-   * @brief Checks whether this instance describes a valid index or not.
-   *
-   * @return True if index description is valid, false otherwise.
-   **/
-  bool isIndexPropertyValid() const {
-    return invalid_index_type_ == InvalidIndexType::kNone;
-  }
-
-  /**
-   * @brief Returns the parse node corresponding for invalid index instance, if any.
-   *
-   * @return The parse node.
-   **/
-  const ParseKeyValue* getInvalidPropertyNode() const {
-    return invalid_property_node_;
-  }
-
-  /**
-   * @brief Returns a protobuf object representing the index description.
-   *
-   * @return An IndexSubBlockDescription object.
-   **/
-  const IndexSubBlockDescription* getIndexDescription() const {
-    return index_sub_block_description_.get();
-  }
-
-  /**
-   * @brief A helper function that checks whether the given list of custom properties
-   *        contains duplicate keys or not.
-   *
-   * @param key_value_list Key Value list of custom properties.
-   * @param invalid_node Double pointer to an invalid node that is used to store duplicate node, if any.
-   * @return Returns true if the given set of custom properties contains duplicate
-   *         keys, otherwise returns false.
-   **/
-  bool hasDuplicateCustomProperty(const PtrList<ParseKeyValue> *key_value_list, const ParseKeyValue **invalid_node) {
-    // Define an existence map, which checks for duplicate properties in the key_value_list.
-    std::unordered_map<std::string, bool> is_duplicate_property;
-    for (const ParseKeyValue &key_value : *key_value_list) {
-      const std::string key = ToLower(key_value.key()->value());
-      if (is_duplicate_property.find(key) != is_duplicate_property.end()) {
-        *invalid_node = &key_value;
-        return true;  // duplicate found, return true.
-      } else {
-        is_duplicate_property[key] = true;
-      }
-    }
-    return false;  // no duplicates, return false.
-  }
-
- protected:
-  std::unique_ptr<IndexSubBlockDescription> index_sub_block_description_;
-  InvalidIndexType invalid_index_type_;
-  const ParseKeyValue *invalid_property_node_;  // referred object owned by ParseIndexProperties class.
-
-  /**
-   * @brief A setter function that be used to invalidate the index.
-   *
-   * @param invalid_index_type An enum corresponding to the reason, which invalidated the index.
-   * @param invalid_property_node Pointer to the node, which may have caused invalidation.
-   **/
-  void setIndexDescriptionAsInvalid(const InvalidIndexType invalid_index_type,
-                                    const ParseKeyValue *invalid_property_node) {
-    invalid_index_type_ = invalid_index_type;
-    invalid_property_node_ = invalid_property_node;
-    index_sub_block_description_.reset();
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(IndexProperties);
-};
-
-/**
- * @brief Implementation of index properties for a BitWeaving Index (H or V).
- */
-class BitWeavingIndexProperties : public IndexProperties {
- public:
-  static const char *kBitWeavingType;  // is of type string.
-
-  /**
-   * @brief Constructor.
-   **/
-  BitWeavingIndexProperties()
-    : IndexProperties(new IndexSubBlockDescription()) {
-    // Default to BITWEAVING_V, custom properties can change this to H.
-    index_sub_block_description_->set_sub_block_type(IndexSubBlockDescription::BITWEAVING_V);
-  }
-
-  ~BitWeavingIndexProperties() override {
-  }
-
-  std::string getReasonForInvalidIndexDescription() const override {
-    switch (invalid_index_type_) {
-      case InvalidIndexType::kNone:
-        return "";
-      case InvalidIndexType::kDuplicateKey:  // Fall through.
-      case InvalidIndexType::kInvalidKey:
-        return "The only valid property for BitWeaving is TYPE.";
-      case InvalidIndexType::kTypeIsNotString:  // Fall through.
-      case InvalidIndexType::kInvalidValue:
-        return "The only valid values for TYPE are V or H.";
-      default:
-        return "Unknown reason";
-    }
-  }
-
-  bool addCustomProperties(const PtrList<ParseKeyValue> *key_value_list) override {
-    if (key_value_list->size() == 0u) {
-      // No properties specified.
-      return true;
-    } else if (key_value_list->size() == 1u) {
-      const ParseKeyValue &key_value = *key_value_list->begin();
-      if (key_value.getKeyValueType() != ParseKeyValue::KeyValueType::kStringString) {
-        setIndexDescriptionAsInvalid(InvalidIndexType::kTypeIsNotString, &key_value);
-        return false;
-      }
-      const std::string key = ToLower(key_value.key()->value());
-      const std::string value = ToLower(
-          static_cast<const ParseKeyStringValue&>(key_value).value()->value());
-      if (key.compare(kBitWeavingType) == 0) {
-        if (value.compare("h") == 0) {
-          index_sub_block_description_->set_sub_block_type(IndexSubBlockDescription::BITWEAVING_H);
-          return true;
-        } else if (value.compare("v") != 0) {
-          setIndexDescriptionAsInvalid(InvalidIndexType::kInvalidValue, &key_value);
-          return false;
-        } else {
-          // If V was specified, then we do nothing because it's set to V by default.
-          return true;
-        }
-      } else {
-        // Incorrect key specified.
-        setIndexDescriptionAsInvalid(InvalidIndexType::kInvalidKey, &key_value);
-        return false;
-      }
-    } else {
-      // More than one key. This must be an error.
-      invalid_index_type_ = InvalidIndexType::kDuplicateKey;
-      return false;
-    }
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(BitWeavingIndexProperties);
-};
-
-/**
- * @brief Implementation of index properties for Bloom Filter Index
- */
-class BloomFilterIndexProperties : public IndexProperties {
- public:
-  // Index properties associated with this index.
-
-  static const char *kBloomFilterSizeInBytes;    // is of type integer
-  static const char *kBloomFilterNumHashes;      // is of type integer
-  static const char *kBloomFilterProjectElementCount;  // is of type integer
-
-  /**
-   * @brief Constructor.
-   **/
-  BloomFilterIndexProperties()
-      : IndexProperties(new IndexSubBlockDescription()) {
-    index_sub_block_description_->set_sub_block_type(IndexSubBlockDescription::BLOOM_FILTER);
-
-    // Initialize the valid_property_map_ for this index with appropriate type for each property.
-    valid_property_map_[kBloomFilterSizeInBytes] = ParseKeyValue::KeyValueType::kStringInteger;
-    valid_property_map_[kBloomFilterNumHashes] = ParseKeyValue::KeyValueType::kStringInteger;
-    valid_property_map_[kBloomFilterProjectElementCount] = ParseKeyValue::KeyValueType::kStringInteger;
-  }
-
-  ~BloomFilterIndexProperties() override {
-  }
-
-  std::string getReasonForInvalidIndexDescription() const override {
-    switch (invalid_index_type_) {
-      case InvalidIndexType::kNone:
-        return "";
-      case InvalidIndexType::kUnimplemented:
-        return "Bloom Filter index is not yet implemented";
-      case InvalidIndexType::kDuplicateKey:
-        return "Index property is specified more than once";
-      case InvalidIndexType::kInvalidKey:
-        return "Invalid property for this index";
-      case InvalidIndexType::kSizeIsFloat:
-        return "Size cannot be specified as a float";
-      case InvalidIndexType::kSizeIsNegative:
-        return "Size cannot be negative";
-      case InvalidIndexType::kNumHashesIsFloat:
-        return "Num_hashes cannot be specified as a float";
-      case InvalidIndexType::kNumHashesIsNegative:
-        return "Num_hashes cannot be negative";
-      case InvalidIndexType::kProjectedCountIsFloat:
-        return "Projected_element_count cannot be specified as a float";
-      case InvalidIndexType::kProjectedCountIsNegative:
-        return "Projected_element_count cannot be negative";
-      default:
-        return "Unknown reason";
-    }
-  }
-
-  bool addCustomProperties(const PtrList<ParseKeyValue> *key_value_list) override {
-    // If the index is unimplemented, skip adding the custom properties.
-    if (invalid_index_type_ == InvalidIndexType::kUnimplemented) {
-      return false;
-    }
-
-    // Verify for duplicates, if any.
-    if (hasDuplicateCustomProperty(key_value_list, &invalid_property_node_)) {
-      invalid_index_type_ = InvalidIndexType::kDuplicateKey;
-      return false;
-    }
-
-    for (const ParseKeyValue &key_value : *key_value_list) {
-      const std::string key = ToLower(key_value.key()->value());
-      if (key.compare(kBloomFilterSizeInBytes) == 0) {
-        const ParseKeyIntegerValue *key_integer_value = static_cast<const ParseKeyIntegerValue*>(&key_value);
-        if (key_integer_value->value()->float_like()) {
-          setIndexDescriptionAsInvalid(InvalidIndexType::kSizeIsFloat, &key_value);
-          return false;
-        }
-        const std::int64_t bloom_filter_size = key_integer_value->value()->long_value();
-        if (bloom_filter_size < 0) {
-          setIndexDescriptionAsInvalid(InvalidIndexType::kSizeIsNegative, &key_value);
-          return false;
-        }
-        // All good! allow the default bloom filter size to be modified.
-        index_sub_block_description_->SetExtension(BloomFilterIndexSubBlockDescription::bloom_filter_size,
-                                                   bloom_filter_size);
-      } else if (key.compare(kBloomFilterNumHashes) == 0) {
-        const ParseKeyIntegerValue *key_integer_value = static_cast<const ParseKeyIntegerValue*>(&key_value);
-        if (key_integer_value->value()->float_like()) {
-          setIndexDescriptionAsInvalid(InvalidIndexType::kNumHashesIsFloat, &key_value);
-          return false;
-        }
-        const std::int64_t number_of_hashes = key_integer_value->value()->long_value();
-        if (number_of_hashes < 0) {
-          setIndexDescriptionAsInvalid(InvalidIndexType::kNumHashesIsNegative, &key_value);
-          return false;
-        }
-        // All good! allow the default num_hashes to be modified.
-        index_sub_block_description_->SetExtension(BloomFilterIndexSubBlockDescription::number_of_hashes,
-                                                   number_of_hashes);
-      } else if (key.compare(kBloomFilterProjectElementCount) == 0) {
-        const ParseKeyIntegerValue *key_integer_value = static_cast<const ParseKeyIntegerValue*>(&key_value);
-        if (key_integer_value->value()->float_like()) {
-          setIndexDescriptionAsInvalid(InvalidIndexType::kProjectedCountIsFloat, &key_value);
-          return false;
-        }
-        const std::int64_t projected_element_count = key_integer_value->value()->long_value();
-        if (projected_element_count < 0) {
-          setIndexDescriptionAsInvalid(InvalidIndexType::kProjectedCountIsNegative, &key_value);
-          return false;
-        }
-        // All good! allow the default projected_element_count to be modified.
-        index_sub_block_description_->SetExtension(BloomFilterIndexSubBlockDescription::projected_element_count,
-                                                   projected_element_count);
-      } else {
-        // None of the defined properties matched, this is an invalid property for this index.
-        setIndexDescriptionAsInvalid(InvalidIndexType::kInvalidKey, &key_value);
-        return false;
-      }
-    }
-    invalid_index_type_ = InvalidIndexType::kNone;
-    invalid_property_node_ = nullptr;
-    return true;
-  }
-
- private:
-  // A map of index property constants and their associated type.
-  valid_property_map_type valid_property_map_;
-
-  DISALLOW_COPY_AND_ASSIGN(BloomFilterIndexProperties);
-};
-
-/**
- * @brief Implementation of index properties for CSB Tree Index.
- */
-class CSBTreeIndexProperties : public IndexProperties {
- public:
-  /**
-   * @brief Constructor.
-   **/
-  CSBTreeIndexProperties()
-    : IndexProperties(new IndexSubBlockDescription()) {
-    index_sub_block_description_->set_sub_block_type(IndexSubBlockDescription::CSB_TREE);
-  }
-
-  ~CSBTreeIndexProperties() override {
-  }
-
-  std::string getReasonForInvalidIndexDescription() const override {
-    switch (invalid_index_type_) {
-      case InvalidIndexType::kNone:
-        return "";
-      case InvalidIndexType::kUnimplemented:
-        return "CSB Tree index is not yet implemented";
-      case InvalidIndexType::kInvalidKey:
-        return "CSB Tree index does not define index properties";
-      default:
-        return "Unknown reason";
-    }
-  }
-
-  bool addCustomProperties(const PtrList<ParseKeyValue> *key_value_list) override {
-    // CSBTreeIndex does not define any additional index property,
-    // so a call to this function will invalidate the index.
-    invalid_index_type_ = InvalidIndexType::kInvalidKey;
-    invalid_property_node_ = nullptr;
-    index_sub_block_description_.reset();
-    return false;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CSBTreeIndexProperties);
-};
-
-/**
- * @brief Implementation of index properties for SMA Index.
- */
-class SMAIndexProperties : public IndexProperties {
- public:
-  /**
-   * @brief Constructor.
-   */
-  SMAIndexProperties() : IndexProperties(new IndexSubBlockDescription()) {
-    index_sub_block_description_->set_sub_block_type(IndexSubBlockDescription::SMA);
-  }
-
-  ~SMAIndexProperties() override {
-  }
-
-  std::string getReasonForInvalidIndexDescription() const override {
-    switch (invalid_index_type_) {
-      case InvalidIndexType::kNone:
-        return "";
-      case InvalidIndexType::kInvalidKey:
-        return "SMA index does not define index properties";
-      default:
-        return "Unknown reason";
-    }
-  }
-
-  bool addCustomProperties(const PtrList<ParseKeyValue> *key_value_list) override {
-    // SMA does not define any index properties, so calling this function
-    // will invalidate the index.
-    invalid_index_type_ = InvalidIndexType::kInvalidKey;
-    invalid_property_node_ = nullptr;
-    index_sub_block_description_.reset();
-    return false;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SMAIndexProperties);
-};
-
-/**
- * @brief Encapsulates the IndexProperties key-value list. Makes the job
- *        of resolving IndexProperties easy.
- */
-class ParseIndexProperties : public ParseTreeNode {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param line_number Beginning line number.
-   * @param column_number Beginning column number.
-   * @param properties PtrList to the KeyValues.
-   */
-  ParseIndexProperties(const int line_number,
-                       const int column_number,
-                       PtrList<ParseKeyValue> *key_value_list)
-      : ParseTreeNode(line_number, column_number),
-        key_value_list_(key_value_list) {
-  }
-
-  std::string getName() const override { return "IndexProperties"; }
-
-  const PtrList<ParseKeyValue>* getKeyValueList() const {
-    return key_value_list_.get();
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-      std::vector<std::string> *container_child_field_names,
-      std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override {
-    for (const ParseKeyValue &index_property : *key_value_list_) {
-      non_container_child_field_names->push_back("index_property");
-      non_container_child_fields->push_back(&index_property);
-    }
-  }
-
- private:
-  std::unique_ptr<PtrList<ParseKeyValue>> key_value_list_;
-
-  DISALLOW_COPY_AND_ASSIGN(ParseIndexProperties);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif  // QUICKSTEP_PARSER_PARSE_INDEX_PROPERTIES_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseJoinedTableReference.cpp
----------------------------------------------------------------------
diff --git a/parser/ParseJoinedTableReference.cpp b/parser/ParseJoinedTableReference.cpp
deleted file mode 100644
index b2cbeb2..0000000
--- a/parser/ParseJoinedTableReference.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- **/
-
-#include "parser/ParseJoinedTableReference.hpp"
-
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-void ParseJoinedTableReference::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<const ParseTreeNode*> *non_container_child_fields,
-    std::vector<std::string> *container_child_field_names,
-    std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  ParseTableReference::getFieldStringItems(inline_field_names,
-                                           inline_field_values,
-                                           non_container_child_field_names,
-                                           non_container_child_fields,
-                                           container_child_field_names,
-                                           container_child_fields);
-
-  inline_field_names->push_back("join_type");
-  switch (join_type_) {
-    case JoinType::kInnerJoin:
-      inline_field_values->push_back("InnerJoin");
-      break;
-    case JoinType::kLeftOuterJoin:
-      inline_field_values->push_back("LeftOuterJoin");
-      break;
-    case JoinType::kRightOuterJoin:
-      inline_field_values->push_back("RightOuterJoin");
-      break;
-    case JoinType::kFullOuterJoin:
-      inline_field_values->push_back("FullOuterJoin");
-      break;
-    default:
-      LOG(FATAL) << "Invalid JoinType: "
-                 << static_cast<typename std::underlying_type<JoinType>::type>(join_type_);
-  }
-
-  non_container_child_field_names->push_back("left_table");
-  non_container_child_fields->push_back(left_table_.get());
-
-  non_container_child_field_names->push_back("right_table");
-  non_container_child_fields->push_back(right_table_.get());
-
-  non_container_child_field_names->push_back("join_predicate");
-  non_container_child_fields->push_back(join_predicate_.get());
-}
-
-}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseJoinedTableReference.hpp
----------------------------------------------------------------------
diff --git a/parser/ParseJoinedTableReference.hpp b/parser/ParseJoinedTableReference.hpp
deleted file mode 100644
index f1f4aa2..0000000
--- a/parser/ParseJoinedTableReference.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_PARSER_PARSE_JOINED_TABLE_REFERENCE_HPP_
-#define QUICKSTEP_PARSER_PARSE_JOINED_TABLE_REFERENCE_HPP_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "parser/ParsePredicate.hpp"
-#include "parser/ParseTableReference.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-class ParseTreeNode;
-
-/** \addtogroup Parser
- *  @{
- */
-
-/**
- * @brief Parsed representation of a joined table.
- */
-class ParseJoinedTableReference : public ParseTableReference {
- public:
-  enum class JoinType {
-    kInnerJoin = 0,
-    kLeftOuterJoin,
-    kRightOuterJoin,
-    kFullOuterJoin
-  };
-
-  /**
-   * @brief Constructor.
-   *
-   * @param line_number The line number of the token "JOIN" in the SQL statement.
-   * @param column_number The column number of the token "JOIN" in the SQL statement.
-   * @param join_type The join type.
-   * @param left_table The left-hand side table.
-   * @param right_table The right-hand side table.
-   * @param join_predicate The join predicate.
-   */
-  ParseJoinedTableReference(const int line_number,
-                            const int column_number,
-                            const JoinType join_type,
-                            ParseTableReference *left_table,
-                            ParseTableReference *right_table,
-                            ParsePredicate *join_predicate)
-    : ParseTableReference(line_number, column_number),
-      join_type_(join_type),
-      left_table_(left_table),
-      right_table_(right_table),
-      join_predicate_(join_predicate) {
-  }
-
-  TableReferenceType getTableReferenceType() const override {
-    return kJoinedTableReference;
-  }
-
-  std::string getName() const override { return "JoinedTable"; }
-
-  /**
-   * @return The join type.
-   */
-  JoinType join_type() const {
-    return join_type_;
-  }
-
-  /**
-   * @return The left-side table.
-   */
-  const ParseTableReference* left_table() const {
-    return left_table_.get();
-  }
-
-  /**
-   * @return The right-side table.
-   */
-  const ParseTableReference* right_table() const {
-    return right_table_.get();
-  }
-
-  /**
-   * @return The join predicate.
-   */
-  const ParsePredicate* join_predicate() const {
-    return join_predicate_.get();
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-      std::vector<std::string> *container_child_field_names,
-      std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override;
-
- private:
-  const JoinType join_type_;
-  std::unique_ptr<ParseTableReference> left_table_;
-  std::unique_ptr<ParseTableReference> right_table_;
-  std::unique_ptr<ParsePredicate> join_predicate_;
-
-  DISALLOW_COPY_AND_ASSIGN(ParseJoinedTableReference);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif /* QUICKSTEP_PARSER_PARSE_JOINED_TABLE_REFERENCE_HPP_ */

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseKeyValue.hpp
----------------------------------------------------------------------
diff --git a/parser/ParseKeyValue.hpp b/parser/ParseKeyValue.hpp
deleted file mode 100644
index 9d6d511..0000000
--- a/parser/ParseKeyValue.hpp
+++ /dev/null
@@ -1,257 +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_PARSER_PARSE_KEY_VALUE_HPP_
-#define QUICKSTEP_PARSER_PARSE_KEY_VALUE_HPP_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "parser/ParseLiteralValue.hpp"
-#include "parser/ParseString.hpp"
-#include "parser/ParseTreeNode.hpp"
-#include "utility/Macros.hpp"
-#include "utility/PtrList.hpp"
-
-namespace quickstep {
-
-/**
- * @brief Base class for the Parse Key Values.
- */
-class ParseKeyValue : public ParseTreeNode {
- public:
-  enum class KeyValueType {
-    kStringString,
-    kStringStringList,
-    kStringInteger
-  };
-
-  /**
-   * @brief Single value constructor.
-   *
-   * @param line_number Line number of the first token of this node in the SQL statement.
-   * @param column_number Column number of the first token of this node in the SQL statement.
-   * @param value A single literal value.
-   **/
-  ParseKeyValue(const int line_number,
-                const int column_number,
-                ParseString *key)
-      : ParseTreeNode(line_number, column_number),
-        key_(key) { }
-
-  /**
-   * @brief Destructor.
-   **/
-  ~ParseKeyValue() override { }
-
-  /**
-   * @brief Get the subclass type of the parse key value.
-   */
-  virtual KeyValueType getKeyValueType() const = 0;
-
-  /**
-   * @return Pointer to the key string.
-   */
-  const ParseString* key() const {
-    return key_.get();
-  }
-
-  std::string getName() const override {
-    return "KeyValue";
-  }
-
- protected:
-  std::unique_ptr<ParseString> key_;
-};
-
-/**
- * @brief The parsed representation of a key-value pair.
- **/
-class ParseKeyStringValue : public ParseKeyValue {
- public:
-  /**
-   * @brief Single value constructor.
-   *
-   * @param line_number Line number of the first token of this node in the SQL statement.
-   * @param column_number Column number of the first token of this node in the SQL statement.
-   * @param key A parse string representing the key.
-   * @param value A parse string representing the key.
-   **/
-  ParseKeyStringValue(const int line_number,
-                      const int column_number,
-                      ParseString *key,
-                      ParseString *value)
-      : ParseKeyValue(line_number, column_number, key),
-        value_(value) { }
-
-  KeyValueType getKeyValueType() const override {
-    return ParseKeyValue::KeyValueType::kStringString;
-  }
-
-  /**
-   * @return A pointer to the value ParseString.
-   */
-  const ParseString* value() const {
-    return value_.get();
-  }
-
-  std::string getName() const override {
-    return "KeyStringValue";
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-      std::vector<std::string> *container_child_field_names,
-      std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override {
-    inline_field_names->push_back("key");
-    inline_field_values->push_back(key_->value());
-
-    non_container_child_field_names->push_back("value");
-    non_container_child_fields->push_back(value_.get());
-  }
-
- private:
-  std::unique_ptr<ParseString> value_;
-
-  DISALLOW_COPY_AND_ASSIGN(ParseKeyStringValue);
-};
-
-/**
- * @brief The parsed representation of a key-value pair. Value is a list of values.
- **/
-class ParseKeyStringList : public ParseKeyValue {
- public:
-  /**
-   * @brief Single value constructor.
-   *
-   * @param line_number Line number of the first token of this node in the SQL statement.
-   * @param column_number Column number of the first token of this node in the SQL statement.
-   * @param key A parse string representing the key.
-   * @param value A list of string values.
-   **/
-  ParseKeyStringList(const int line_number,
-                     const int column_number,
-                     ParseString *key,
-                     PtrList<ParseString> *value)
-      : ParseKeyValue(line_number, column_number, key),
-        value_(value) { }
-
-  KeyValueType getKeyValueType() const override {
-    return ParseKeyValue::KeyValueType::kStringStringList;
-  }
-
-  /**
-   * @return A list of ParseStrings.
-   */
-  const PtrList<ParseString>* value() const {
-    return value_.get();
-  }
-
-  std::string getName() const override {
-    return "KeyStringList";
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-      std::vector<std::string> *container_child_field_names,
-      std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override {
-    inline_field_names->push_back("key");
-    inline_field_values->push_back(key_->value());
-
-    container_child_field_names->push_back("value_list");
-    container_child_fields->emplace_back();
-    for (const ParseString &value : *value_) {
-      container_child_fields->back().push_back(&value);
-    }
-  }
-
- private:
-  std::unique_ptr<PtrList<ParseString> > value_;
-
-  DISALLOW_COPY_AND_ASSIGN(ParseKeyStringList);
-};
-
-/**
- * @brief The parsed representation of a key-value pair.
- **/
-class ParseKeyIntegerValue : public ParseKeyValue {
- public:
-  /**
-   * @brief Single value constructor.
-   *
-   * @param line_number Line number of the first token of this node in the SQL statement.
-   * @param column_number Column number of the first token of this node in the SQL statement.
-   * @param key A parse string representing the key.
-   * @param value A single numeric literal value.
-   **/
-  ParseKeyIntegerValue(const int line_number,
-                       const int column_number,
-                       ParseString *key,
-                       NumericParseLiteralValue *value)
-      : ParseKeyValue(line_number, column_number, key),
-        value_(value) { }
-
-  KeyValueType getKeyValueType() const override {
-    return ParseKeyValue::KeyValueType::kStringInteger;
-  }
-
-  /**
-   * @return A pointer to the value ParseString.
-   */
-  const NumericParseLiteralValue* value() const {
-    return value_.get();
-  }
-
-  std::string getName() const override {
-    return "KeyIntegerValue";
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-      std::vector<std::string> *container_child_field_names,
-      std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override {
-    inline_field_names->push_back("key");
-    inline_field_values->push_back(key_->value());
-
-    non_container_child_field_names->push_back("value");
-    non_container_child_fields->push_back(value_.get());
-  }
-
- private:
-  std::unique_ptr<NumericParseLiteralValue> value_;
-
-  DISALLOW_COPY_AND_ASSIGN(ParseKeyIntegerValue);
-};
-
-}  // namespace quickstep
-
-#endif  // QUICKSTEP_PARSER_PARSE_KEY_VALUE_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseLimit.cpp
----------------------------------------------------------------------
diff --git a/parser/ParseLimit.cpp b/parser/ParseLimit.cpp
deleted file mode 100644
index f39c430..0000000
--- a/parser/ParseLimit.cpp
+++ /dev/null
@@ -1,39 +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 "parser/ParseLimit.hpp"
-
-#include <string>
-#include <vector>
-
-#include "parser/ParseLiteralValue.hpp"
-
-namespace quickstep {
-
-void ParseLimit::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<const ParseTreeNode*> *non_container_child_fields,
-                                     std::vector<std::string> *container_child_field_names,
-                                     std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  non_container_child_field_names->push_back("");
-  non_container_child_fields->push_back(limit_expression_.get());
-}
-
-}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseLimit.hpp
----------------------------------------------------------------------
diff --git a/parser/ParseLimit.hpp b/parser/ParseLimit.hpp
deleted file mode 100644
index 2afb049..0000000
--- a/parser/ParseLimit.hpp
+++ /dev/null
@@ -1,90 +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_PARSER_PARSE_LIMIT_HPP_
-#define QUICKSTEP_PARSER_PARSE_LIMIT_HPP_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "parser/ParseLiteralValue.hpp"
-#include "parser/ParseTreeNode.hpp"
-#include "utility/Macros.hpp"
-
-namespace quickstep {
-
-/** \addtogroup Parser
- *  @{
- */
-
-/**
- * @brief A parsed representation of LIMIT.
- */
-class ParseLimit : public ParseTreeNode {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param line_number The line number of "LIMIT" in the SQL statement.
-   * @param column_number The column number of "LIMIT" in the SQL statement.
-   * @param limit_expression The LIMIT value expression.
-   */
-  ParseLimit(const int line_number, const int column_number, NumericParseLiteralValue *limit_expression)
-      : ParseTreeNode(line_number, column_number),
-        limit_expression_(limit_expression) {
-  }
-
-  /**
-   * @brief Destructor.
-   */
-  ~ParseLimit() override {}
-
-  /**
-   * @brief Gets the LIMIT expression.
-   *
-   * @return LIMIT expression
-   */
-  const NumericParseLiteralValue* limit_expression() const {
-    return limit_expression_.get();
-  }
-
-  std::string getName() const override {
-    return "LIMIT";
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-                           std::vector<std::string> *container_child_field_names,
-                           std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override;
-
- private:
-  std::unique_ptr<NumericParseLiteralValue> limit_expression_;
-
-  DISALLOW_COPY_AND_ASSIGN(ParseLimit);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif /* QUICKSTEP_PARSER_PARSELIMIT_HPP_ */

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseLiteralValue.cpp
----------------------------------------------------------------------
diff --git a/parser/ParseLiteralValue.cpp b/parser/ParseLiteralValue.cpp
deleted file mode 100644
index d4753ab..0000000
--- a/parser/ParseLiteralValue.cpp
+++ /dev/null
@@ -1,211 +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 __STDC_FORMAT_MACROS
-#define __STDC_FORMAT_MACROS
-#endif
-
-#include "parser/ParseLiteralValue.hpp"
-
-#include <cinttypes>
-#include <cstdint>
-#include <cstdio>
-#include <limits>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "types/DatetimeIntervalType.hpp"
-#include "types/DoubleType.hpp"
-#include "types/IntType.hpp"
-#include "types/LongType.hpp"
-#include "types/NullType.hpp"
-#include "types/Type.hpp"
-#include "types/VarCharType.hpp"
-#include "types/YearMonthIntervalType.hpp"
-#include "utility/SqlError.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-TypedValue NullParseLiteralValue::concretize(
-    const Type *type_hint,
-    const Type **concretized_type) const {
-  if (type_hint == nullptr) {
-    *concretized_type = &NullType::InstanceNullable();
-  } else {
-    *concretized_type = &(type_hint->getNullableVersion());
-  }
-  return (*concretized_type)->makeNullValue();
-}
-
-NumericParseLiteralValue::NumericParseLiteralValue(const int line_number,
-                                                   const int column_number,
-                                                   const char *numstring)
-    : ParseLiteralValue(line_number, column_number),
-      numeric_string_(numstring) {
-  float_like_ = (numeric_string_.find('.') != std::string::npos)
-                || (numeric_string_.find('e') != std::string::npos)
-                || (numeric_string_.find('E') != std::string::npos);
-
-  if (!float_like_) {
-    CHECK_EQ(1, std::sscanf(numeric_string_.c_str(), "%" SCNd64, &long_value_))
-        << "Failed to parse int64_t from numeric string \""
-        << numeric_string_ << "\n";
-  }
-}
-
-void NumericParseLiteralValue::prependMinus() {
-  std::string minused("-");
-  minused.append(numeric_string_);
-  numeric_string_ = std::move(minused);
-
-  if (!float_like_) {
-    long_value_ = -long_value_;
-  }
-}
-
-TypedValue NumericParseLiteralValue::concretize(
-    const Type *type_hint,
-    const Type **concretized_type) const {
-  TypedValue parsed_value;
-  if ((type_hint != nullptr)
-      && (type_hint->getSuperTypeID() == Type::kNumeric)
-      && (type_hint->parseValueFromString(numeric_string_, &parsed_value))) {
-    *concretized_type = &(type_hint->getNonNullableVersion());
-    return parsed_value;
-  }
-
-  if (float_like_) {
-    *concretized_type = &DoubleType::InstanceNonNullable();
-    CHECK((*concretized_type)->parseValueFromString(numeric_string_, &parsed_value))
-        << "Failed to parse double from numeric string \""
-        << numeric_string_ << "\"";
-    return parsed_value;
-  } else {
-    if ((long_value_ >= std::numeric_limits<int>::min())
-        && (long_value_ <= std::numeric_limits<int>::max())) {
-      *concretized_type = &IntType::InstanceNonNullable();
-      return TypedValue(static_cast<int>(long_value_));
-    } else {
-      *concretized_type = &LongType::InstanceNonNullable();
-      return TypedValue(long_value_);
-    }
-  }
-}
-
-void NumericParseLiteralValue::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<const ParseTreeNode*> *non_container_child_fields,
-    std::vector<std::string> *container_child_field_names,
-    std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  inline_field_names->push_back("numeric_string");
-  inline_field_values->push_back(numeric_string_);
-
-  inline_field_names->push_back("float_like");
-  inline_field_values->push_back(float_like_ ? "true" : "false");
-}
-
-bool StringParseLiteralValue::ParseAmbiguousInterval(
-    ParseString *value,
-    StringParseLiteralValue **output) {
-  *output = new StringParseLiteralValue(value,
-                                        nullptr);  // Initially no explicit type.
-
-  // Try parsing as DatetimeInterval.
-  (*output)->explicit_type_ = &DatetimeIntervalType::InstanceNonNullable();
-  if ((*output)->tryExplicitTypeParse()) {
-    return true;
-  }
-
-  // Try parsing as YearMonthInterval.
-  (*output)->explicit_type_ = &YearMonthIntervalType::InstanceNonNullable();
-  if ((*output)->tryExplicitTypeParse()) {
-    return true;
-  }
-
-  delete *output;
-  *output = nullptr;
-  return false;
-}
-
-TypedValue StringParseLiteralValue::concretize(const Type *type_hint,
-                                               const Type **concretized_type) const {
-  if (explicit_type_ != nullptr) {
-    if ((type_hint != nullptr) && (type_hint->isSafelyCoercibleFrom(*explicit_type_))) {
-      *concretized_type = type_hint;
-      return type_hint->coerceValue(explicit_parsed_value_, *explicit_type_);
-    } else {
-      *concretized_type = explicit_type_;
-      return explicit_parsed_value_;
-    }
-  } else {
-    TypedValue parsed_value;
-    if ((type_hint != nullptr)
-        && (type_hint->parseValueFromString(value_->value(), &parsed_value))) {
-      *concretized_type = &(type_hint->getNonNullableVersion());
-      return parsed_value;
-    } else {
-      *concretized_type = &VarCharType::InstanceNonNullable(value_->value().length());
-      CHECK((*concretized_type)->parseValueFromString(value_->value(), &parsed_value));
-      return parsed_value;
-    }
-  }
-}
-
-std::string StringParseLiteralValue::generateName() const {
-  std::string name;
-  if (explicit_type_ != nullptr) {
-    name.append(explicit_type_->getName());
-    name.push_back('(');
-  }
-  name.push_back('\'');
-  name.append(value_->value());
-  name.push_back('\'');
-  if (explicit_type_ != nullptr) {
-    name.push_back(')');
-  }
-  return name;
-}
-
-bool StringParseLiteralValue::tryExplicitTypeParse() {
-  DCHECK(explicit_type_ != nullptr);
-  return explicit_type_->parseValueFromString(value_->value(), &explicit_parsed_value_);
-}
-
-void StringParseLiteralValue::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<const ParseTreeNode*> *non_container_child_fields,
-    std::vector<std::string> *container_child_field_names,
-    std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  inline_field_names->push_back("value");
-  inline_field_values->push_back(value_->value());
-
-  if (explicit_type_ != nullptr) {
-    inline_field_names->push_back("explicit_type");
-    inline_field_values->push_back(explicit_type_->getName());
-  }
-}
-
-}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseLiteralValue.hpp
----------------------------------------------------------------------
diff --git a/parser/ParseLiteralValue.hpp b/parser/ParseLiteralValue.hpp
deleted file mode 100644
index 105a774..0000000
--- a/parser/ParseLiteralValue.hpp
+++ /dev/null
@@ -1,354 +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_PARSER_PARSE_LITERAL_VALUE_HPP_
-#define QUICKSTEP_PARSER_PARSE_LITERAL_VALUE_HPP_
-
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "parser/ParseString.hpp"
-#include "parser/ParseTreeNode.hpp"
-#include "types/TypedValue.hpp"
-#include "utility/Macros.hpp"
-
-#include "glog/logging.h"
-
-namespace quickstep {
-
-class Type;
-
-/** \addtogroup Parser
- *  @{
- */
-
-/**
- * @brief The parsed representation of a literal data value.
- **/
-class ParseLiteralValue : public ParseTreeNode {
- public:
-  /**
-   * @brief Virtual destructor.
-   **/
-  ~ParseLiteralValue() override {
-  }
-
-  /**
-   * @brief Obtain this value as a literal TypedValue in the quickstep type
-   *        system.
-   *
-   * @param type_hint A hint of what Type is expected. This may be used to give
-   *        NULL values the correct Type, or to disambiguate between types that
-   *        have similar human-readable text formats. type_hint may be NULL, in
-   *        which case the most sensible guess for the value's Type is used
-   *        (for a NULL literal, the special type NullType is used).
-   * @param concretized_type After the call, *concretized_type will point to
-   *        the actual Type that the returned TypedValue belongs to.
-   * @return The concrete version of this literal value.
-   **/
-  virtual TypedValue concretize(const Type *type_hint,
-                                const Type **concretized_type) const = 0;
-
-  /**
-   * @brief Obtain an exact, deep copy of this ParseLiteralValue.
-   *
-   * @return A copy of this ParseLiteralValue.
-   **/
-  virtual ParseLiteralValue* clone() const = 0;
-
-  /**
-   * @brief Get a human-readable representation of this value.
-   *
-   * @return The human-readable form of this value.
-   **/
-  virtual std::string generateName() const = 0;
-
- protected:
-  /**
-   * @brief Constructor.
-   *
-   * @param line_number Line number of the first token of this node in the SQL statement.
-   * @param column_number Column number of the first token of this node in the SQL statement.
-   **/
-  ParseLiteralValue(const int line_number, const int column_number)
-      : ParseTreeNode(line_number, column_number) {
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ParseLiteralValue);
-};
-
-/**
- * @brief The parsed representation of a NULL literal.
- **/
-class NullParseLiteralValue: public ParseLiteralValue {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param line_number Line number of the first token of this node in the SQL statement.
-   * @param column_number Column number of the first token of this node in the SQL statement.
-   **/
-  NullParseLiteralValue(const int line_number, const int column_number)
-      : ParseLiteralValue(line_number, column_number) {
-  }
-
-  std::string getName() const override {
-    return "NullLiteral";
-  }
-
-  TypedValue concretize(const Type *type_hint,
-                        const Type **concretized_type) const override;
-
-  ParseLiteralValue* clone() const override {
-    return new NullParseLiteralValue(line_number(), column_number());
-  }
-
-  std::string generateName() const override {
-    return "NULL";
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-      std::vector<std::string> *container_child_field_names,
-      std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override {
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(NullParseLiteralValue);
-};
-
-/**
- * @brief The parsed representation of an unquoted numeric literal.
- **/
-class NumericParseLiteralValue : public ParseLiteralValue {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param line_number Line number of the first token of this node in the SQL statement.
-   * @param column_number Column number of the first token of this node in the SQL statement.
-   * @param numstring The C-string form of the numeric value.
-   **/
-  NumericParseLiteralValue(const int line_number,
-                           const int column_number,
-                           const char *numstring);
-
-  /**
-   * @brief Destructor.
-   **/
-  ~NumericParseLiteralValue() override {
-  }
-
-  std::string getName() const override {
-    return "NumericLiteral";
-  }
-
-  /**
-   * @brief Prepend a minus sign to this numeric value, negating it.
-   * @note This exists to work around a quirk in our Bison SQL grammar, since
-   *       a minus sign can be the leading character in a negative number OR
-   *       can represent the unary negation operation applied to a numeric
-   *       value. Our solution is to have the Lexer scan all numeric literals
-   *       as unsigned values, while the parser has a rule that calls this
-   *       method when a minus-sign token occurs in front of a numeric literal.
-   **/
-  void prependMinus();
-
-  /**
-   * @brief Determine whether this numeric value looks like a floating-point
-   *        value.
-   *
-   * @return True if the value is "float-like", false otherwise.
-   **/
-  bool float_like() const {
-    return float_like_;
-  }
-
-  /**
-   * @brief Get this numeric value as a long.
-   *
-   * @return This numeric value as a long.
-   **/
-  std::int64_t long_value() const {
-    DCHECK(!float_like_)
-        << "Attempted to read integer value from float-like "
-        << "NumericParseLiteralValue";
-    return long_value_;
-  }
-
-  /**
-   * @note This implementation of concretize() always tries to honor the given
-   *       type_hint first. If resolution with the supplied type_hint fails, or
-   *       if no type_hint is given, then the following rules apply:
-   *         1. If the literal contains a decimal point or exponent, resolve as
-   *            DoubleType (unless FloatType is hinted, we always use
-   *            DoubleType for more precision).
-   *         2. Otherwise, if the literal is in-range for a 32-bit signed
-   *            integer, resolve as IntType.
-   *         3. Otherwise, resolve as LongType.
-   **/
-  TypedValue concretize(const Type *type_hint,
-                        const Type **concretized_type) const override;
-
-  ParseLiteralValue* clone() const override {
-    return new NumericParseLiteralValue(line_number(),
-                                        column_number(),
-                                        numeric_string_.c_str());
-  }
-
-  std::string generateName() const override {
-    return numeric_string_;
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-      std::vector<std::string> *container_child_field_names,
-      std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override;
-
- private:
-  std::int64_t long_value_;
-  bool float_like_;
-
-  std::string numeric_string_;
-
-  DISALLOW_COPY_AND_ASSIGN(NumericParseLiteralValue);
-};
-
-/**
- * @brief The parsed representation of a quoted string value. This includes
- *        explicitly typed literals of the form "TYPE 'literal value'".
- **/
-class StringParseLiteralValue : public ParseLiteralValue {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param value The string.
-   * @param explicit_type If non-NULL, indicates an explicit Type that appeared
-   *        immediately before a quoted string in the SQL syntax. If NULL, then
-   *        value appeared by itself as a quoted string without an explicit
-   *        Type.
-   **/
-  explicit StringParseLiteralValue(ParseString *value,
-                                   const Type *explicit_type)
-      : ParseLiteralValue(value->line_number(), value->column_number()),
-        value_(value),
-        explicit_type_(explicit_type) {
-  }
-
-  ~StringParseLiteralValue() override {
-  }
-
-  /**
-   * @brief Attempt to parse an interval literal that was specified
-   *        in the form "INTERVAL 'value string'" in SQL syntax.
-   * @note There are two distinct INTERVAL Types in Quickstep:
-   *       DatetimeInterval ("DATETIME INTERVAL" in SQL) and YearMonthInterval
-   *       ("YEARMONTH INTERVAL" in SQL). The INTERVAL keyword by itself is
-   *       ambiguous and does not name a Type, however the text formats for
-   *       literals of the two different interval Types are distinct and
-   *       non-overlapping, so if a valid interval literal string follows the
-   *       INTERVAL keyword, the Type can be determined unambiguously. This
-   *       method does just that, allowing the SQL parser to be more forgiving
-   *       when interval literals don't specify the flavor of interval
-   *       up-front.
-   *
-   * @param value A string literal that followed an INTERVAL keyword in SQL
-   *        syntax. On successful parse, this becomes owned by the parsed
-   *        StringParseLiteralValue. On failure, it is deleted.
-   * @param output On successful parse, *output is overwritten to point to a
-   *        new heap-allocated StringParseLiteralValue representing the parsed
-   *        interval literal.
-   * @return true if value was successfully parsed as either of the interval
-   *         types, false otherwise.
-   **/
-  static bool ParseAmbiguousInterval(ParseString *value,
-                                     StringParseLiteralValue **output);
-
-  /**
-   * @note The rules for what type this literal is resolved as depend on
-   *       whether an explicit_type_ from the SQL context exists, and whether
-   *       a type_hint is provided. Specifically, they are:
-   *         1. If there is an explicit_type_:
-   *           a. If there is a type_hint and it is safely coercible from
-   *              explicit_type_, do the coercion and resolve as type_hint.
-   *           b. Otherwise resolve as explicit_type_.
-   *         2. If there is no explicit_type_:
-   *           a. If there is a type_hint and it can successfully parse the
-   *              string value, resolve as the hinted type.
-   *           b. Otherwise, resolve as a non-nullable VarCharType that is
-   *              exactly long enough for this string literal.
-   **/
-  TypedValue concretize(const Type *type_hint,
-                        const Type **concretized_type) const override;
-
-  std::string getName() const override {
-    return "StringLiteral";
-  }
-
-  ParseLiteralValue* clone() const override {
-    return new StringParseLiteralValue(value_->clone(), explicit_type_);
-  }
-
-  std::string generateName() const override;
-
-  /**
-   * @brief Attempt to parse this string literal as an instance of the
-   *        explicit Type provided to the constructor. This should ALWAYS be
-   *        called by the parser immediately after creating a
-   *        StringParseLiteralValue with an explicit Type.
-   *
-   * @return true if parse was successful, false if the string was not in a
-   *         valid format for the specified explicit Type.
-   **/
-  bool tryExplicitTypeParse();
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-      std::vector<std::string> *container_child_field_names,
-      std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override;
-
- private:
-  std::unique_ptr<ParseString> value_;
-  const Type *explicit_type_;
-  TypedValue explicit_parsed_value_;
-
-  DISALLOW_COPY_AND_ASSIGN(StringParseLiteralValue);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif  // QUICKSTEP_PARSER_PARSE_LITERAL_VALUE_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseOrderBy.cpp
----------------------------------------------------------------------
diff --git a/parser/ParseOrderBy.cpp b/parser/ParseOrderBy.cpp
deleted file mode 100644
index da46a1f..0000000
--- a/parser/ParseOrderBy.cpp
+++ /dev/null
@@ -1,57 +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 "parser/ParseOrderBy.hpp"
-
-#include <string>
-#include <vector>
-
-#include "parser/ParseExpression.hpp"
-
-namespace quickstep {
-
-void ParseOrderByItem::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<const ParseTreeNode*> *non_container_child_fields,
-    std::vector<std::string> *container_child_field_names,
-    std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  inline_field_names->push_back("is_asc");
-  inline_field_values->push_back(is_ascending_ ? "true" : "false");
-  inline_field_names->push_back("nulls_first");
-  inline_field_values->push_back(nulls_first_ ? "true" : "false");
-
-  non_container_child_field_names->push_back("");
-  non_container_child_fields->push_back(ordering_expression_.get());
-}
-
-void ParseOrderBy::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<const ParseTreeNode*> *non_container_child_fields,
-                                       std::vector<std::string> *container_child_field_names,
-                                       std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  for (const ParseOrderByItem &order_by_item : *order_by_items_) {
-    non_container_child_field_names->push_back("");
-    non_container_child_fields->push_back(&order_by_item);
-  }
-}
-
-}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParseOrderBy.hpp
----------------------------------------------------------------------
diff --git a/parser/ParseOrderBy.hpp b/parser/ParseOrderBy.hpp
deleted file mode 100644
index 88e9679..0000000
--- a/parser/ParseOrderBy.hpp
+++ /dev/null
@@ -1,167 +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_PARSER_PARSE_ORDERBY_HPP_
-#define QUICKSTEP_PARSER_PARSE_ORDERBY_HPP_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "parser/ParseExpression.hpp"
-#include "parser/ParseTreeNode.hpp"
-#include "utility/Macros.hpp"
-#include "utility/PtrList.hpp"
-
-namespace quickstep {
-
-/** \addtogroup Parser
- *  @{
- */
-
-/**
- * @brief The parsed representation of an ORDER BY item consisting of
- *        an ordering expression and its ordering direction.
- */
-class ParseOrderByItem : public ParseTreeNode {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param line_number The line number of the first token of this ORDER BY item
-   *                    in the SQL statement.
-   * @param column_number The column number of the first token of this ORDER BY
-   *                      item in the SQL statement.
-   * @param ordering_expression The ordering expression.
-   * @param is_ascending The optional ordering direction. The default value is
-   *                     true.
-   * @param nulls_first True if nulls are sorted before non-nulls.
-   *                    The default value is true when is_ascending is false,
-   *                    false otherwise.
-   */
-  ParseOrderByItem(const int line_number,
-                   const int column_number,
-                   ParseExpression *ordering_expression,
-                   const bool *is_ascending,
-                   const bool *nulls_first)
-      : ParseTreeNode(line_number, column_number),
-        ordering_expression_(ordering_expression),
-        is_ascending_(is_ascending == nullptr ? true : *is_ascending),
-        nulls_first_(nulls_first == nullptr ? !is_ascending_ : *nulls_first) {
-  }
-
-  /**
-   * @brief Destructor.
-   */
-  ~ParseOrderByItem() override {}
-
-  std::string getName() const override {
-    return "OrderByItem";
-  }
-
-  /**
-   * @return Ordering expression.
-   */
-  const ParseExpression* ordering_expression() const {
-    return ordering_expression_.get();
-  }
-
-  /**
-   * @return True if the ordering direction is ascending.
-   */
-  bool is_ascending() const {
-    return is_ascending_;
-  }
-
-  /**
-   * @return True if nulls are sorted before other values.
-   */
-  bool nulls_first() const {
-    return nulls_first_;
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-                           std::vector<std::string> *container_child_field_names,
-                           std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override;
-
- private:
-  std::unique_ptr<ParseExpression> ordering_expression_;
-  bool is_ascending_;
-  bool nulls_first_;
-
-  DISALLOW_COPY_AND_ASSIGN(ParseOrderByItem);
-};
-
-/**
- * @brief The parsed representation of ORDER BY.
- */
-class ParseOrderBy : public ParseTreeNode {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param line_number The line number of "ORDER" in the SQL statement.
-   * @param column_number The column number of "ORDER" in the SQL statement.
-   * @param order_by_items The ORDER BY expression and the ordering direction.
-   */
-  ParseOrderBy(const int line_number, const int column_number, PtrList<ParseOrderByItem> *order_by_items)
-      : ParseTreeNode(line_number, column_number), order_by_items_(order_by_items) {
-  }
-
-  /**
-   * @brief Destructor.
-   */
-  ~ParseOrderBy() override {}
-
-  /**
-   * @brief Gets the ORDER BY expressions.
-   *
-   * @return ORDER BY expressions.
-   */
-  const PtrList<ParseOrderByItem>* order_by_items() const {
-    return order_by_items_.get();
-  }
-
-  std::string getName() const override {
-    return "OrderBy";
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-                           std::vector<std::string> *container_child_field_names,
-                           std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override;
-
- private:
-  std::unique_ptr<PtrList<ParseOrderByItem>> order_by_items_;
-
-  DISALLOW_COPY_AND_ASSIGN(ParseOrderBy);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif /* QUICKSTEP_PARSER_PARSEORDERBY_HPP_ */

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParsePartitionClause.hpp
----------------------------------------------------------------------
diff --git a/parser/ParsePartitionClause.hpp b/parser/ParsePartitionClause.hpp
deleted file mode 100644
index d2912e7..0000000
--- a/parser/ParsePartitionClause.hpp
+++ /dev/null
@@ -1,134 +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_PARSER_PARSE_PARTITION_CLAUSE_HPP_
-#define QUICKSTEP_PARSER_PARSE_PARTITION_CLAUSE_HPP_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "parser/ParseLiteralValue.hpp"
-#include "parser/ParseString.hpp"
-#include "parser/ParseTreeNode.hpp"
-#include "utility/Macros.hpp"
-#include "utility/PtrList.hpp"
-
-namespace quickstep {
-
-/** \addtogroup Parser
- *  @{
- */
-
-/**
- * @brief A parsed representation of partition clause.
- */
-class ParsePartitionClause : public ParseTreeNode {
- public:
-  /**
-   * @brief Constructor.
-   *
-   * @param line_number The line number of "PARTITION CLAUSE" in the SQL statement.
-   * @param column_number The column number of "PARTITION CLAUSE" in the SQL statement.
-   * @param partition_type The type of partitioning to be made - Hash or Range
-   * @param attribute_name_list A list of attributes of the relation based on which the partitioning has to be done.
-   * @param num_partitions The number of partitions to be created.
-   */
-  ParsePartitionClause(const int line_number,
-                       const int column_number,
-                       ParseString *partition_type,
-                       PtrList<ParseString> *attribute_name_list,
-                       NumericParseLiteralValue *num_partitions)
-      : ParseTreeNode(line_number, column_number),
-        partition_type_(partition_type),
-        attribute_name_list_(attribute_name_list),
-        num_partitions_(num_partitions) {
-  }
-
-  /**
-   * @brief Destructor.
-   */
-  ~ParsePartitionClause() override {}
-
-  std::string getName() const override {
-    return "PartitionClause";
-  }
-
-  /**
-   * @brief Get the type of the partitioning to be created.
-   *
-   * @return The type of partitioning.
-   **/
-  const ParseString* partition_type() const {
-    return partition_type_.get();
-  }
-
-  /**
-   * @brief Get the list of attributes on which partitioning is supposed to be defined.
-   *
-   * @return The list of attributes on which partitioning is to be based on.
-   **/
-  const PtrList<ParseString>& attribute_name_list() const {
-    return *attribute_name_list_;
-  }
-
-  /**
-   * @brief Get the number of partitions.
-   *
-   * @return The number of partitions.
-   */
-  const NumericParseLiteralValue* num_partitions() const {
-    return num_partitions_.get();
-  }
-
- 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<const ParseTreeNode*> *non_container_child_fields,
-                           std::vector<std::string> *container_child_field_names,
-                           std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override {
-    inline_field_names->push_back("partition_type");
-    inline_field_values->push_back(partition_type_->value());
-
-    if (attribute_name_list_.get() != nullptr) {
-      container_child_field_names->push_back("attribute_name_list");
-      container_child_fields->emplace_back();
-      for (const ParseString& attribute_name : *attribute_name_list_) {
-        container_child_fields->back().push_back(&attribute_name);
-      }
-    }
-
-    non_container_child_field_names->push_back("Number of Partitions");
-    non_container_child_fields->push_back(num_partitions_.get());
-  }
-
- private:
-  std::unique_ptr<ParseString> partition_type_;
-  std::unique_ptr<PtrList<ParseString>> attribute_name_list_;
-  std::unique_ptr<NumericParseLiteralValue> num_partitions_;
-
-  DISALLOW_COPY_AND_ASSIGN(ParsePartitionClause);
-};
-
-/** @} */
-
-}  // namespace quickstep
-
-#endif  // QUICKSTEP_PARSER_PARSE_PARTITION_CLAUSE_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/156290a4/parser/ParsePredicate.cpp
----------------------------------------------------------------------
diff --git a/parser/ParsePredicate.cpp b/parser/ParsePredicate.cpp
deleted file mode 100644
index 9747b08..0000000
--- a/parser/ParsePredicate.cpp
+++ /dev/null
@@ -1,106 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- **/
-
-#include "parser/ParsePredicate.hpp"
-
-#include <string>
-#include <vector>
-
-#include "parser/ParseExpression.hpp"
-#include "types/operations/comparisons/Comparison.hpp"
-
-namespace quickstep {
-
-std::string ParsePredicateComparison::getName() const {
-  return op_.getName();
-}
-
-void ParsePredicateComparison::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<const ParseTreeNode*> *non_container_child_fields,
-    std::vector<std::string> *container_child_field_names,
-    std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  non_container_child_field_names->push_back("left_operand");
-  non_container_child_field_names->push_back("right_operand");
-  non_container_child_fields->push_back(left_operand_.get());
-  non_container_child_fields->push_back(right_operand_.get());
-}
-
-void ParsePredicateNegation::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<const ParseTreeNode*> *non_container_child_fields,
-    std::vector<std::string> *container_child_field_names,
-    std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  non_container_child_field_names->push_back("");
-  non_container_child_fields->push_back(operand_.get());
-}
-
-void ParsePredicateBetween::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<const ParseTreeNode*> *non_container_child_fields,
-    std::vector<std::string> *container_child_field_names,
-    std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  non_container_child_field_names->push_back("check_operand");
-  non_container_child_fields->push_back(check_operand_.get());
-
-  non_container_child_field_names->push_back("lower_bound_operand");
-  non_container_child_fields->push_back(lower_bound_operand_.get());
-
-  non_container_child_field_names->push_back("upper_bound_operand");
-  non_container_child_fields->push_back(upper_bound_operand_.get());
-}
-
-void ParsePredicateWithList::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<const ParseTreeNode*> *non_container_child_fields,
-    std::vector<std::string> *container_child_field_names,
-    std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  container_child_field_names->push_back("");
-  container_child_fields->emplace_back();
-  for (const ParsePredicate &operand : operands_) {
-    container_child_fields->back().push_back(&operand);
-  }
-}
-
-void ParsePredicateInValueList::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<const ParseTreeNode*> *non_container_child_fields,
-    std::vector<std::string> *container_child_field_names,
-    std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const {
-  non_container_child_field_names->push_back("test_expression");
-  non_container_child_fields->push_back(test_expression_.get());
-
-  container_child_field_names->push_back("value_list");
-  container_child_fields->emplace_back();
-  for (const ParseExpression &value : *value_list_) {
-    container_child_fields->back().emplace_back(&value);
-  }
-}
-
-}  // namespace quickstep