diff --git a/build/catalog.pb.bin.orig b/build/catalog.pb.bin.orig
deleted file mode 100644
index 349a0a4..0000000
--- a/build/catalog.pb.bin.orig
+++ /dev/null
@@ -1,3 +0,0 @@
-
-	
-default
\ No newline at end of file
diff --git a/build/qsstor/.gitignore b/build/qsstor/.gitignore
deleted file mode 100644
index 1aabdb4..0000000
--- a/build/qsstor/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-# Empty .gitignore to force git to include this empty directory.
diff --git a/build/qsstor/catalog.pb.bin b/build/qsstor/catalog.pb.bin
deleted file mode 100644
index 349a0a4..0000000
--- a/build/qsstor/catalog.pb.bin
+++ /dev/null
@@ -1,3 +0,0 @@
-
-	
-default
\ No newline at end of file
diff --git a/catalog/CMakeLists.txt b/catalog/CMakeLists.txt
index ae3d88e..8c89d7e 100644
--- a/catalog/CMakeLists.txt
+++ b/catalog/CMakeLists.txt
@@ -179,13 +179,6 @@
                       quickstep_catalog_PartitionScheme
                       quickstep_catalog_PartitionSchemeHeader)
 
-# Catalog generator program.
-add_executable(quickstep_generate_initial_default_catalog GenerateInitialDefaultCatalog.cpp)
-target_link_libraries(quickstep_generate_initial_default_catalog
-                      quickstep_catalog_Catalog
-                      quickstep_catalog_CatalogDatabase
-                      quickstep_catalog_Catalog_proto)
-
 # Tests:
 add_executable(Catalog_unittest "${CMAKE_CURRENT_SOURCE_DIR}/tests/Catalog_unittest.cpp")
 target_link_libraries(Catalog_unittest
diff --git a/catalog/CatalogRelationSchema.cpp b/catalog/CatalogRelationSchema.cpp
index 35c8189..97c834f 100644
--- a/catalog/CatalogRelationSchema.cpp
+++ b/catalog/CatalogRelationSchema.cpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015-2016 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -25,6 +27,7 @@
 #include "catalog/Catalog.pb.h"
 #include "catalog/CatalogAttribute.hpp"
 #include "catalog/CatalogErrors.hpp"
+#include "catalog/CatalogTypedefs.hpp"
 #include "types/Type.hpp"
 #include "utility/PtrVector.hpp"
 #include "utility/StringUtil.hpp"
@@ -52,6 +55,7 @@
       min_variable_byte_length_(0),
       min_variable_byte_length_excluding_nullable_(0),
       estimated_variable_byte_length_(0),
+      max_byte_lengths_(proto.attributes_size()),
       current_nullable_attribute_index_(-1),
       current_variable_length_attribute_index_(-1) {
   DCHECK(ProtoIsValid(proto))
@@ -150,7 +154,7 @@
       }
       estimated_variable_byte_length_ += attr_type.estimateAverageByteLength();
     } else {
-      variable_length_attribute_indices_.push_back(-1);
+      variable_length_attribute_indices_.push_back(kInvalidCatalogId);
 
       fixed_length_attribute_offsets_.resize(new_attr->getID() + 1, fixed_byte_length_);
       fixed_byte_length_ += attr_type.maximumByteLength();
@@ -163,10 +167,16 @@
       ++num_nullable_attributes_;
       nullable_attribute_indices_.push_back(++current_nullable_attribute_index_);
     } else {
-      nullable_attribute_indices_.push_back(-1);
+      nullable_attribute_indices_.push_back(kInvalidCatalogId);
     }
 
-    return new_attr->getID();
+    const attribute_id attr_id = new_attr->getID();
+    // Ensure that we will not overrun the vector by resizing and initializing
+    // new entries to zero.
+    max_byte_lengths_.resize(attr_id + 1, 0);
+    max_byte_lengths_[attr_id] = attr_type.maximumByteLength();
+
+    return attr_id;
   }
 }
 
diff --git a/catalog/CatalogRelationSchema.hpp b/catalog/CatalogRelationSchema.hpp
index 054bd02..d773bc7 100644
--- a/catalog/CatalogRelationSchema.hpp
+++ b/catalog/CatalogRelationSchema.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015-2016 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -415,6 +417,16 @@
     return attr_vec_.end_skip();
   }
 
+  /**
+   * @brief Get a vector of the maximum byte lengths for each attribute.
+   * @details An index in the vector corresponds with the attribute's id.
+   *
+   * @return A vector of the maximum byte lengths for each attribute.
+   */
+  const std::vector<std::size_t>& getMaximumAttributeByteLengths() const {
+    return max_byte_lengths_;
+  }
+
  protected:
   /**
    * @brief Create a new relation.
@@ -511,6 +523,7 @@
               min_variable_byte_length_excluding_nullable_,
               estimated_variable_byte_length_;
   std::vector<std::size_t> fixed_length_attribute_offsets_;
+  std::vector<std::size_t> max_byte_lengths_;
 
   // Entries are -1 for non-nullable attributes.
   std::vector<int> nullable_attribute_indices_;
diff --git a/catalog/CatalogTypedefs.hpp b/catalog/CatalogTypedefs.hpp
index 233c6e8..213d91d 100644
--- a/catalog/CatalogTypedefs.hpp
+++ b/catalog/CatalogTypedefs.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -40,6 +42,10 @@
 // partition_id.
 const int kCatalogMaxID = INT_MAX;
 
+// Catalog ids use negative values as invalid ids. Mark -1 as constant invalid
+// id for the catalog ids.
+constexpr int kInvalidCatalogId = -1;
+
 /** @} */
 
 }  // namespace quickstep
diff --git a/catalog/GenerateInitialDefaultCatalog.cpp b/catalog/GenerateInitialDefaultCatalog.cpp
deleted file mode 100644
index 5fe99a5..0000000
--- a/catalog/GenerateInitialDefaultCatalog.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- *   Copyright 2011-2015 Quickstep Technologies LLC.
- *   Copyright 2015 Pivotal Software, Inc.
- *
- *   Licensed 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.
- **/
-
-// This small program generates an initial catalog.pb.bin with an empty
-// "default" database.
-
-#include <cstdio>
-#include <fstream>
-
-#include "catalog/Catalog.hpp"
-#include "catalog/Catalog.pb.h"
-#include "catalog/CatalogDatabase.hpp"
-
-int main() {
-  std::ofstream catalog_file("catalog.pb.bin");
-  if (!catalog_file.good()) {
-    std::fprintf(stderr, "ERROR: Unable to open catalog.pb.bin for writing.\n");
-    return 1;
-  }
-
-  quickstep::Catalog catalog;
-  catalog.addDatabase(new quickstep::CatalogDatabase(nullptr, "default"));
-
-  if (!catalog.getProto().SerializeToOstream(&catalog_file)) {
-    std::fprintf(stderr, "ERROR: Unable to serialize catalog proto to file catalog.pb.bin\n");
-    return 1;
-  }
-
-  catalog_file.close();
-  return 0;
-}
diff --git a/catalog/tests/Catalog_unittest.cpp b/catalog/tests/Catalog_unittest.cpp
index 135b013..65593dc 100644
--- a/catalog/tests/Catalog_unittest.cpp
+++ b/catalog/tests/Catalog_unittest.cpp
@@ -214,6 +214,17 @@
            ++cit_expected, ++cit_checked) {
         CompareCatalogAttribute(*cit_expected, *cit_checked);
       }
+      const std::vector<std::size_t>& expected_max_lengths =
+          expected.getMaximumAttributeByteLengths();
+      const std::vector<std::size_t>& checked_max_lengths =
+          checked.getMaximumAttributeByteLengths();
+      ASSERT_EQ(expected_max_lengths.size(), checked_max_lengths.size());
+      for (attribute_id len_index = 0;
+           static_cast<std::size_t>(len_index) < expected_max_lengths.size();
+           ++len_index) {
+        EXPECT_EQ(expected_max_lengths[len_index],
+                  checked_max_lengths[len_index]);
+      }
     }
   }
 
diff --git a/cli/QuickstepCli.cpp b/cli/QuickstepCli.cpp
index ad04a91..b549514 100644
--- a/cli/QuickstepCli.cpp
+++ b/cli/QuickstepCli.cpp
@@ -25,6 +25,14 @@
 #include <string>
 #include <utility>
 #include <vector>
+#include <fstream>
+
+// TODO(jmp): If filesystem shows up in C++-17, we can switch to just using that.
+#ifdef QUICKSTEP_OS_WINDOWS
+#include <filesystem>
+#else
+#include <stdlib.h>
+#endif
 
 #include "cli/CliConfig.h"  // For QUICKSTEP_USE_LINENOISE.
 #include "cli/DropRelation.hpp"
@@ -127,13 +135,14 @@
             "accepting queries (should also set --buffer_pool_slots to be "
             "large enough to accomodate the entire database).");
 DEFINE_string(storage_path, kDefaultStoragePath,
-              "Filesystem path for quickstep database storage.");
+              "Filesystem path to store the Quickstep database.");
 DEFINE_string(worker_affinities, "",
               "A comma-separated list of CPU IDs to pin worker threads to "
               "(leaving this empty will cause all worker threads to inherit "
               "the affinity mask of the Quickstep process, which typically "
               "means that they will all be runable on any CPU according to "
               "the kernel's own scheduling policy).");
+DEFINE_bool(initialize_db, false, "If true, initialize a database.");
 }  // namespace quickstep
 
 int main(int argc, char* argv[]) {
@@ -189,13 +198,53 @@
 
   string catalog_path(fixed_storage_path);
   catalog_path.append("catalog.pb.bin");
+  if (quickstep::FLAGS_initialize_db) {  // Initialize the database
+    // TODO(jmp): Refactor the code in this file!
+    LOG(INFO) << "Initializing the database, creating a new catalog file and storage directory\n";
+
+    // Create the directory
+    // TODO(jmp): At some point, likely in C++-17, we will just have the
+    //            filesystem path, and we can clean this up
+#ifdef QUICKSTEP_OS_WINDOWS
+    std::filesystem::create_directories(fixed_storage_path);
+    LOG(FATAL) << "Failed when attempting to create the directory: " << fixed_storage_path << "\n";
+    LOG(FATAL) << "Check if the directory already exists. If so, delete it or move it before initializing \n";
+#else
+    {
+      string path_name = "mkdir " + fixed_storage_path;
+      if (std::system(path_name.c_str())) {
+        LOG(FATAL) << "Failed when attempting to create the directory: " << fixed_storage_path << "\n";
+      }
+    }
+#endif
+
+    // Create the default catalog file.
+    std::ofstream catalog_file(catalog_path);
+    if (!catalog_file.good()) {
+      LOG(FATAL) << "ERROR: Unable to open catalog.pb.bin for writing.\n";
+    }
+
+    quickstep::Catalog catalog;
+    catalog.addDatabase(new quickstep::CatalogDatabase(nullptr, "default"));
+
+    if (!catalog.getProto().SerializeToOstream(&catalog_file)) {
+      LOG(FATAL) << "ERROR: Unable to serialize catalog proto to file catalog.pb.bin\n";
+      return 1;
+    }
+
+    // Close the catalog file - it will be reopened below by the QueryProcessor.
+    catalog_file.close();
+  }
 
   // Setup QueryProcessor, including CatalogDatabase and StorageManager.
   std::unique_ptr<QueryProcessor> query_processor;
   try {
     query_processor.reset(new QueryProcessor(catalog_path, fixed_storage_path));
   } catch (const std::exception &e) {
-    LOG(FATAL) << "FATAL ERROR DURING STARTUP: " << e.what();
+    LOG(FATAL) << "FATAL ERROR DURING STARTUP: "
+               << e.what()
+               << "\nIf you intended to create a new database, "
+               << "please use the \"-initialize_db=true\" command line option.";
   } catch (...) {
     LOG(FATAL) << "NON-STANDARD EXCEPTION DURING STARTUP";
   }
@@ -239,18 +288,18 @@
   // Initialize the worker threads.
   DCHECK_EQ(static_cast<std::size_t>(real_num_workers),
             worker_cpu_affinities.size());
-  for (std::size_t worker_idx = 0;
-       worker_idx < worker_cpu_affinities.size();
-       ++worker_idx) {
+  for (std::size_t worker_thread_index = 0;
+       worker_thread_index < worker_cpu_affinities.size();
+       ++worker_thread_index) {
     int numa_node_id = -1;
-    if (worker_cpu_affinities[worker_idx] >= 0) {
+    if (worker_cpu_affinities[worker_thread_index] >= 0) {
       // This worker can be NUMA affinitized.
-      numa_node_id = cpu_numa_nodes[worker_cpu_affinities[worker_idx]];
+      numa_node_id = cpu_numa_nodes[worker_cpu_affinities[worker_thread_index]];
     }
     worker_numa_nodes.push_back(numa_node_id);
 
     workers.push_back(
-        new Worker(worker_idx, &bus, worker_cpu_affinities[worker_idx]));
+        new Worker(worker_thread_index, &bus, worker_cpu_affinities[worker_thread_index]));
     worker_client_ids.push_back(workers.back().getBusClientID());
   }
 
diff --git a/expressions/aggregation/AggregationConcreteHandle.cpp b/expressions/aggregation/AggregationConcreteHandle.cpp
new file mode 100644
index 0000000..05ca58d
--- /dev/null
+++ b/expressions/aggregation/AggregationConcreteHandle.cpp
@@ -0,0 +1,71 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#include "expressions/aggregation/AggregationConcreteHandle.hpp"
+
+#include <cstddef>
+#include <vector>
+
+#include "catalog/CatalogTypedefs.hpp"
+#include "storage/HashTable.hpp"
+#include "storage/HashTableFactory.hpp"
+
+namespace quickstep {
+
+class StorageManager;
+class Type;
+class ValueAccessor;
+
+AggregationStateHashTableBase* AggregationConcreteHandle::createDistinctifyHashTable(
+    const HashTableImplType hash_table_impl,
+    const std::vector<const Type*> &key_types,
+    const std::size_t estimated_num_distinct_keys,
+    StorageManager *storage_manager) const {
+  // Create a hash table with key types as key_types and value type as bool.
+  return AggregationStateHashTableFactory<bool>::CreateResizable(
+      hash_table_impl,
+      key_types,
+      estimated_num_distinct_keys,
+      storage_manager);
+}
+
+void AggregationConcreteHandle::insertValueAccessorIntoDistinctifyHashTable(
+    ValueAccessor *accessor,
+    const std::vector<attribute_id> &key_ids,
+    AggregationStateHashTableBase *distinctify_hash_table) const {
+  // If the key-value pair is already there, we don't need to update the value,
+  // which should always be "true". I.e. the value is just a placeholder.
+  const auto noop_upserter = [](const auto &accessor, const bool *value) -> void {};
+
+  AggregationStateHashTable<bool> *hash_table =
+      static_cast<AggregationStateHashTable<bool>*>(distinctify_hash_table);
+  if (key_ids.size() == 1) {
+    hash_table->upsertValueAccessor(accessor,
+                                    key_ids[0],
+                                    true /* check_for_null_keys */,
+                                    true /* initial_value */,
+                                    &noop_upserter);
+  } else {
+    hash_table->upsertValueAccessorCompositeKey(accessor,
+                                                key_ids,
+                                                true /* check_for_null_keys */,
+                                                true /* initial_value */,
+                                                &noop_upserter);
+  }
+}
+
+}  // namespace quickstep
diff --git a/expressions/aggregation/AggregationConcreteHandle.hpp b/expressions/aggregation/AggregationConcreteHandle.hpp
new file mode 100644
index 0000000..52249f7
--- /dev/null
+++ b/expressions/aggregation/AggregationConcreteHandle.hpp
@@ -0,0 +1,378 @@
+/**
+ *   Copyright 2011-2015 Quickstep Technologies LLC.
+ *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#ifndef QUICKSTEP_EXPRESSIONS_AGGREGATION_AGGREGATION_CONCRETE_HANDLE_HPP_
+#define QUICKSTEP_EXPRESSIONS_AGGREGATION_AGGREGATION_CONCRETE_HANDLE_HPP_
+
+#include <cstddef>
+#include <vector>
+#include <utility>
+
+#include "catalog/CatalogTypedefs.hpp"
+#include "expressions/aggregation/AggregationHandle.hpp"
+#include "storage/HashTable.hpp"
+#include "storage/HashTableBase.hpp"
+#include "types/TypedValue.hpp"
+#include "types/containers/ColumnVector.hpp"
+#include "utility/Macros.hpp"
+
+#include "glog/logging.h"
+
+namespace quickstep {
+
+class StorageManager;
+class Type;
+class ValueAccessor;
+
+/** \addtogroup Expressions
+ *  @{
+ */
+
+
+/**
+ * @brief The helper intermediate subclass of AggregationHandle that provides
+ *        virtual method implementations as well as helper methods that are
+ *        shared among all its subclasses.
+ *
+ * @note The reason that we have this intermediate class instead of putting
+ *       everything inside AggregationHandle is to avoid cyclic dependency, e.g.
+ *       when HashTable has to be used.
+ **/
+class AggregationConcreteHandle : public AggregationHandle {
+ public:
+  /**
+   * @brief Default implementaion for AggregationHandle::accumulateNullary().
+   */
+  AggregationState* accumulateNullary(
+      const std::size_t num_tuples) const override {
+    LOG(FATAL) << "Called accumulateNullary on an AggregationHandle that "
+               << "takes at least one argument.";
+  }
+
+  /**
+   * @brief Implementaion for AggregationHandle::createDistinctifyHashTable()
+   *        that creates a new HashTable for the distinctify step for
+   *        DISTINCT aggregation.
+   */
+  AggregationStateHashTableBase* createDistinctifyHashTable(
+      const HashTableImplType hash_table_impl,
+      const std::vector<const Type*> &key_types,
+      const std::size_t estimated_num_distinct_keys,
+      StorageManager *storage_manager) const override;
+
+  /**
+   * @brief Implementaion for AggregationHandle::insertValueAccessorIntoDistinctifyHashTable()
+   *        that inserts the GROUP BY expressions and aggregation arguments together
+   *        as keys into the distinctify hash table.
+   */
+  void insertValueAccessorIntoDistinctifyHashTable(
+      ValueAccessor *accessor,
+      const std::vector<attribute_id> &key_ids,
+      AggregationStateHashTableBase *distinctify_hash_table) const override;
+
+ protected:
+  AggregationConcreteHandle() {
+  }
+
+  template <typename HandleT,
+            typename StateT,
+            typename HashTableT>
+  void aggregateValueAccessorIntoHashTableNullaryHelper(
+      ValueAccessor *accessor,
+      const std::vector<attribute_id> &group_by_key_ids,
+      const StateT &default_state,
+      AggregationStateHashTableBase *hash_table) const;
+
+  template <typename HandleT,
+            typename StateT,
+            typename HashTableT>
+  void aggregateValueAccessorIntoHashTableUnaryHelper(
+      ValueAccessor *accessor,
+      const attribute_id argument_id,
+      const std::vector<attribute_id> &group_by_key_ids,
+      const StateT &default_state,
+      AggregationStateHashTableBase *hash_table) const;
+
+  template <typename HandleT,
+            typename StateT>
+  StateT* aggregateOnDistinctifyHashTableForSingleUnaryHelper(
+      const AggregationStateHashTableBase &distinctify_hash_table) const;
+
+  template <typename HandleT,
+            typename StateT,
+            typename HashTableT>
+  void aggregateOnDistinctifyHashTableForGroupByUnaryHelper(
+      const AggregationStateHashTableBase &distinctify_hash_table,
+      const StateT &default_state,
+      AggregationStateHashTableBase *hash_table) const;
+
+  template <typename HandleT,
+            typename HashTableT>
+  ColumnVector* finalizeHashTableHelper(
+      const Type &result_type,
+      const AggregationStateHashTableBase &hash_table,
+      std::vector<std::vector<TypedValue>> *group_by_keys) const;
+
+  template <typename HandleT, typename HashTableT>
+  inline TypedValue finalizeGroupInHashTable(
+      const AggregationStateHashTableBase &hash_table,
+      const std::vector<TypedValue> &group_key) const {
+    const AggregationState *group_state
+        = static_cast<const HashTableT&>(hash_table).getSingleCompositeKey(group_key);
+    DCHECK(group_state != nullptr)
+        << "Could not find entry for specified group_key in HashTable";
+    return static_cast<const HandleT*>(this)->finalizeHashTableEntry(*group_state);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AggregationConcreteHandle);
+};
+
+/**
+ * @brief Templated class to implement value-accessor-based upserter for each
+ *        aggregation state payload type. This version is for nullary
+ *        aggregates (those that take no arguments).
+ **/
+template <typename HandleT, typename StateT>
+class NullaryAggregationStateValueAccessorUpserter {
+ public:
+  explicit NullaryAggregationStateValueAccessorUpserter(const HandleT &handle)
+      : handle_(handle) {
+  }
+
+  template <typename ValueAccessorT>
+  inline void operator()(const ValueAccessorT &accessor, StateT *state) {
+    handle_.iterateNullaryInl(state);
+  }
+
+ private:
+  const HandleT &handle_;
+};
+
+/**
+ * @brief Templated class to implement value-accessor-based upserter for each
+ *        aggregation state payload type. This version is for unary aggregates
+ *        (those that take a single argument).
+ **/
+template <typename HandleT, typename StateT>
+class UnaryAggregationStateValueAccessorUpserter {
+ public:
+  UnaryAggregationStateValueAccessorUpserter(const HandleT &handle,
+                                             attribute_id value_id)
+    : handle_(handle),
+      value_id_(value_id) {
+  }
+
+  template <typename ValueAccessorT>
+  inline void operator()(const ValueAccessorT &accessor, StateT *state) {
+    handle_.iterateUnaryInl(state, accessor.getTypedValue(value_id_));
+  }
+
+ private:
+  const HandleT &handle_;
+  const attribute_id value_id_;
+};
+
+/**
+ * @brief Templated helper class used to implement
+ *        AggregationHandle::finalizeHashTable() by visiting each entry (i.e.
+ *        GROUP) in a HashTable, finalizing the aggregation for the GROUP, and
+ *        collecting the GROUP BY key values and the final aggregate values in
+ *        a ColumnVector.
+ **/
+template <typename HandleT, typename ColumnVectorT>
+class HashTableAggregateFinalizer {
+ public:
+  HashTableAggregateFinalizer(const HandleT &handle,
+                              std::vector<std::vector<TypedValue>> *group_by_keys,
+                              ColumnVectorT *output_column_vector)
+      : handle_(handle),
+        group_by_keys_(group_by_keys),
+        output_column_vector_(output_column_vector) {
+  }
+
+  inline void operator()(const std::vector<TypedValue> &group_by_key,
+                         const AggregationState &group_state) {
+    group_by_keys_->emplace_back(group_by_key);
+    output_column_vector_->appendTypedValue(handle_.finalizeHashTableEntry(group_state));
+  }
+
+ private:
+  const HandleT &handle_;
+  std::vector<std::vector<TypedValue>> *group_by_keys_;
+  ColumnVectorT *output_column_vector_;
+};
+
+/** @} */
+
+// ----------------------------------------------------------------------------
+// Implementations of templated methods follow:
+
+template <typename HandleT,
+          typename StateT,
+          typename HashTableT>
+void AggregationConcreteHandle::aggregateValueAccessorIntoHashTableNullaryHelper(
+    ValueAccessor *accessor,
+    const std::vector<attribute_id> &group_by_key_ids,
+    const StateT &default_state,
+    AggregationStateHashTableBase *hash_table) const {
+  NullaryAggregationStateValueAccessorUpserter<HandleT, StateT>
+      upserter(static_cast<const HandleT&>(*this));
+  static_cast<HashTableT*>(hash_table)->upsertValueAccessorCompositeKey(
+      accessor,
+      group_by_key_ids,
+      true,
+      default_state,
+      &upserter);
+}
+
+template <typename HandleT,
+          typename StateT,
+          typename HashTableT>
+void AggregationConcreteHandle::aggregateValueAccessorIntoHashTableUnaryHelper(
+    ValueAccessor *accessor,
+    const attribute_id argument_id,
+    const std::vector<attribute_id> &group_by_key_ids,
+    const StateT &default_state,
+    AggregationStateHashTableBase *hash_table) const {
+  UnaryAggregationStateValueAccessorUpserter<HandleT, StateT>
+      upserter(static_cast<const HandleT&>(*this), argument_id);
+  static_cast<HashTableT*>(hash_table)->upsertValueAccessorCompositeKey(
+      accessor,
+      group_by_key_ids,
+      true,
+      default_state,
+      &upserter);
+}
+
+template <typename HandleT,
+          typename StateT>
+StateT* AggregationConcreteHandle::aggregateOnDistinctifyHashTableForSingleUnaryHelper(
+    const AggregationStateHashTableBase &distinctify_hash_table) const {
+  const HandleT& handle = static_cast<const HandleT&>(*this);
+  StateT *state = static_cast<StateT*>(createInitialState());
+
+  // A lambda function which will be called on each key from the distinctify
+  // hash table.
+  const auto aggregate_functor = [&handle, &state](const TypedValue &key,
+                                                   const bool &dumb_placeholder) {
+    // For each (unary) key in the distinctify hash table, aggregate the key
+    // into "state".
+    handle.iterateUnaryInl(state, key);
+  };
+
+  const AggregationStateHashTable<bool> &hash_table =
+      static_cast<const AggregationStateHashTable<bool>&>(distinctify_hash_table);
+  // Invoke the lambda function "aggregate_functor" on each key from the distinctify
+  // hash table.
+  hash_table.forEach(&aggregate_functor);
+
+  return state;
+}
+
+template <typename HandleT,
+          typename StateT,
+          typename HashTableT>
+void AggregationConcreteHandle::aggregateOnDistinctifyHashTableForGroupByUnaryHelper(
+    const AggregationStateHashTableBase &distinctify_hash_table,
+    const StateT &default_state,
+    AggregationStateHashTableBase *aggregation_hash_table) const {
+  const HandleT& handle = static_cast<const HandleT&>(*this);
+  HashTableT *target_hash_table = static_cast<HashTableT*>(aggregation_hash_table);
+
+  // A lambda function which will be called on each key-value pair from the
+  // distinctify hash table.
+  const auto aggregate_functor = [&handle, &target_hash_table, &default_state](
+      std::vector<TypedValue> &key,
+      const bool &dumb_placeholder) {
+    // For each (composite) key vector in the distinctify hash table with size N.
+    // The first N-1 entries are GROUP BY columns and the last entry is the argument
+    // to be aggregated on.
+    const TypedValue argument(std::move(key.back()));
+    key.pop_back();
+
+    // An upserter as lambda function for aggregating the argument into its
+    // GROUP BY group's entry inside aggregation_hash_table.
+    const auto upserter = [&handle, &argument](StateT *state) {
+      handle.iterateUnaryInl(state, argument);
+    };
+
+    target_hash_table->upsertCompositeKey(key, default_state, &upserter);
+  };
+
+  const AggregationStateHashTable<bool> &source_hash_table =
+      static_cast<const AggregationStateHashTable<bool>&>(distinctify_hash_table);
+  // Invoke the lambda function "aggregate_functor" on each composite key vector
+  // from the distinctify hash table.
+  source_hash_table.forEachCompositeKey(&aggregate_functor);
+}
+
+template <typename HandleT,
+          typename HashTableT>
+ColumnVector* AggregationConcreteHandle::finalizeHashTableHelper(
+    const Type &result_type,
+    const AggregationStateHashTableBase &hash_table,
+    std::vector<std::vector<TypedValue>> *group_by_keys) const {
+  const HandleT &handle = static_cast<const HandleT&>(*this);
+  const HashTableT &hash_table_concrete = static_cast<const HashTableT&>(hash_table);
+
+  if (group_by_keys->empty()) {
+    if (NativeColumnVector::UsableForType(result_type)) {
+      NativeColumnVector *result = new NativeColumnVector(result_type,
+                                                          hash_table_concrete.numEntries());
+      HashTableAggregateFinalizer<HandleT, NativeColumnVector> finalizer(
+          handle,
+          group_by_keys,
+          result);
+      hash_table_concrete.forEachCompositeKey(&finalizer);
+      return result;
+    } else {
+      IndirectColumnVector *result = new IndirectColumnVector(result_type,
+                                                              hash_table_concrete.numEntries());
+      HashTableAggregateFinalizer<HandleT, IndirectColumnVector> finalizer(
+          handle,
+          group_by_keys,
+          result);
+      hash_table_concrete.forEachCompositeKey(&finalizer);
+      return result;
+    }
+  } else {
+    if (NativeColumnVector::UsableForType(result_type)) {
+      NativeColumnVector *result = new NativeColumnVector(result_type,
+                                                          group_by_keys->size());
+      for (const std::vector<TypedValue> &group_by_key : *group_by_keys) {
+        result->appendTypedValue(finalizeGroupInHashTable<HandleT, HashTableT>(hash_table,
+                                                                               group_by_key));
+      }
+      return result;
+    } else {
+      IndirectColumnVector *result = new IndirectColumnVector(result_type,
+                                                              hash_table_concrete.numEntries());
+      for (const std::vector<TypedValue> &group_by_key : *group_by_keys) {
+        result->appendTypedValue(finalizeGroupInHashTable<HandleT, HashTableT>(hash_table,
+                                                                               group_by_key));
+      }
+      return result;
+    }
+  }
+}
+
+}  // namespace quickstep
+
+#endif  // QUICKSTEP_EXPRESSIONS_AGGREGATION_AGGREGATION_CONCRETE_HANDLE_HPP_
diff --git a/expressions/aggregation/AggregationHandle.hpp b/expressions/aggregation/AggregationHandle.hpp
index d2b667b..625f334 100644
--- a/expressions/aggregation/AggregationHandle.hpp
+++ b/expressions/aggregation/AggregationHandle.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -25,13 +27,11 @@
 #include "catalog/CatalogTypedefs.hpp"
 #include "storage/HashTableBase.hpp"
 #include "types/TypedValue.hpp"
-#include "types/containers/ColumnVector.hpp"
 #include "utility/Macros.hpp"
 
-#include "glog/logging.h"
-
 namespace quickstep {
 
+class ColumnVector;
 class StorageManager;
 class Type;
 class ValueAccessor;
@@ -72,7 +72,7 @@
  * methods that are used to actually compute the aggregate, storing
  * intermediate results in AggregationState objects.
  *
- * The work-flow for computing an aggregate without GROUP BY is as follows:
+ * I. The work-flow for computing an aggregate without GROUP BY is as follows:
  *     1. Create a global state for the aggregate with createInitialState().
  *     2. For each block in a relation (parallelizable):
  *        a. Call StorageBlock::aggregate() to accumulate results from the
@@ -83,7 +83,7 @@
  *           mergeStates() (this is threadsafe).
  *     3. Generate the final result by calling finalize() on the global state.
  *
- * The work-flow for computing an aggregate with GROUP BY is as follows:
+ * II. The work-flow for computing an aggregate with GROUP BY is as follows:
  *     1. Create a HashTable to hold per-group states by calling
  *        createGroupByHashTable().
  *     2. For each block in a relation (parallelizable):
@@ -152,10 +152,7 @@
    *         tuples.
    **/
   virtual AggregationState* accumulateNullary(
-      const std::size_t num_tuples) const {
-    LOG(FATAL) << "Called accumulateNullary on an AggregationHandle that "
-               << "takes at least one argument.";
-  }
+      const std::size_t num_tuples) const = 0;
 
   /**
    * @brief Accumulate (iterate over) all values in one or more ColumnVectors
@@ -270,218 +267,96 @@
       const AggregationStateHashTableBase &hash_table,
       std::vector<std::vector<TypedValue>> *group_by_keys) const = 0;
 
+  /**
+   * @brief Create a new HashTable for the distinctify step for DISTINCT aggregation.
+   *
+   * Distinctify is the first step for DISTINCT aggregation. This step inserts
+   * the GROUP BY expression values and aggregation arguments together as keys
+   * into the distinctify hash table, so that arguments are distinctified within
+   * each GROUP BY group. Later, a second-round aggregation on the distinctify
+   * hash table will be performed to actually compute the aggregated result for
+   * each GROUP BY group.
+   * 
+   * In the case of single aggregation where there is no GROUP BY expressions,
+   * we simply treat it as a special GROUP BY case that the GROUP BY expression
+   * vector is empty.
+   *
+   * @param hash_table_impl The choice of which concrete HashTable implementation
+   *        to use.
+   * @param key_types The types of the GROUP BY expressions together with the
+   *        types of the aggregation arguments.
+   * @param estimated_num_distinct_keys The estimated number of distinct keys
+   *        (i.e. GROUP BY expressions together with aggregation arguments) for
+   *        the distinctify step. This is used to size the initial HashTable.
+   *        This is an estimate only, and the HashTable will be resized if it
+   *        becomes over-full.
+   * @param storage_manager The StorageManager to use to create the HashTable.
+   *        A StorageBlob will be allocated to serve as the HashTable's in-memory
+   *        storage.
+   * @return A new HashTable instance with the appropriate state type for this
+   *         aggregate as the ValueT.
+   */
+  virtual AggregationStateHashTableBase* createDistinctifyHashTable(
+      const HashTableImplType hash_table_impl,
+      const std::vector<const Type*> &key_types,
+      const std::size_t estimated_num_distinct_keys,
+      StorageManager *storage_manager) const = 0;
+
+  /**
+   * @brief Inserts the GROUP BY expressions and aggregation arguments together
+   * as keys into the distinctify hash table.
+   *
+   * @param accessor The ValueAccessor that will be iterated over to read tuples.
+   * @param key_ids The attribute_ids of the GROUP BY expressions in accessor
+   *        together with the attribute_ids of the arguments to this aggregate
+   *        in accessor, in order.
+   * @param distinctify_hash_table The HashTable to store the GROUP BY expressions
+   *        and the aggregation arguments together as hash table keys and a bool
+   *        constant \c true as hash table value (So the hash table actually
+   *        serves as a hash set). This should have been created by calling
+   *        createDistinctifyHashTable();
+   */
+  virtual void insertValueAccessorIntoDistinctifyHashTable(
+      ValueAccessor *accessor,
+      const std::vector<attribute_id> &key_ids,
+      AggregationStateHashTableBase *distinctify_hash_table) const = 0;
+
+  /**
+   * @brief Perform single (i.e. without GROUP BY) aggregation on the keys from
+   * the distinctify hash table to actually compute the aggregated results.
+   *
+   * @param distinctify_hash_table Hash table which stores the distinctified
+   *        aggregation arguments as hash table keys. This should have been
+   *        created by calling createDistinctifyHashTable();
+   * @return A new AggregationState which contains the aggregated results from
+   *         applying the aggregate to the distinctify hash table.
+   *         Caller is responsible for deleting the returned AggregationState.
+   */
+  virtual AggregationState* aggregateOnDistinctifyHashTableForSingle(
+      const AggregationStateHashTableBase &distinctify_hash_table) const = 0;
+
+  /**
+   * @brief Perform GROUP BY aggregation on the keys from the distinctify hash
+   * table and upserts states into the aggregation hash table.
+   *
+   * @param distinctify_hash_table Hash table which stores the GROUP BY expression
+   *        values and aggregation arguments together as hash table keys.
+   * @param aggregation_hash_table The HashTable to upsert AggregationStates in.
+   *        This should have been created by calling createGroupByHashTable() on
+   *        this same AggregationHandle.
+   */
+  virtual void aggregateOnDistinctifyHashTableForGroupBy(
+      const AggregationStateHashTableBase &distinctify_hash_table,
+      AggregationStateHashTableBase *aggregation_hash_table) const = 0;
+
  protected:
   AggregationHandle() {
   }
 
-  template <typename HandleT,
-            typename StateT,
-            typename HashTableT>
-  void aggregateValueAccessorIntoHashTableNullaryHelper(
-      ValueAccessor *accessor,
-      const std::vector<attribute_id> &group_by_key_ids,
-      const StateT &default_state,
-      AggregationStateHashTableBase *hash_table) const;
-
-  template <typename HandleT,
-            typename StateT,
-            typename HashTableT>
-  void aggregateValueAccessorIntoHashTableUnaryHelper(
-      ValueAccessor *accessor,
-      const attribute_id argument_id,
-      const std::vector<attribute_id> &group_by_key_ids,
-      const StateT &default_state,
-      AggregationStateHashTableBase *hash_table) const;
-
-  template <typename HandleT,
-            typename HashTableT>
-  ColumnVector* finalizeHashTableHelper(
-      const Type &result_type,
-      const AggregationStateHashTableBase &hash_table,
-      std::vector<std::vector<TypedValue>> *group_by_keys) const;
-
-  template <typename HandleT, typename HashTableT>
-  inline TypedValue finalizeGroupInHashTable(
-      const AggregationStateHashTableBase &hash_table,
-      const std::vector<TypedValue> &group_key) const {
-    const AggregationState *group_state
-        = static_cast<const HashTableT&>(hash_table).getSingleCompositeKey(group_key);
-    DCHECK(group_state != nullptr)
-        << "Could not find entry for specified group_key in HashTable";
-    return static_cast<const HandleT*>(this)->finalizeHashTableEntry(*group_state);
-  }
-
  private:
   DISALLOW_COPY_AND_ASSIGN(AggregationHandle);
 };
 
-/**
- * @brief Templated class to implement value-accessor-based upserter for each
- *        aggregation state payload type. This version is for nullary
- *        aggregates (those that take no arguments).
- **/
-template <typename HandleT, typename StateT>
-class NullaryAggregationStateValueAccessorUpserter {
- public:
-  explicit NullaryAggregationStateValueAccessorUpserter(const HandleT &handle)
-      : handle_(handle) {
-  }
-
-  template <typename ValueAccessorT>
-  inline void operator()(const ValueAccessorT &accessor, StateT *state) {
-    handle_.iterateNullaryInl(state);
-  }
-
- private:
-  const HandleT &handle_;
-};
-
-/**
- * @brief Templated class to implement value-accessor-based upserter for each
- *        aggregation state payload type. This version is for unary aggregates
- *        (those that take a single argument).
- **/
-template <typename HandleT, typename StateT>
-class UnaryAggregationStateValueAccessorUpserter {
- public:
-  UnaryAggregationStateValueAccessorUpserter(const HandleT &handle,
-                                             attribute_id value_id)
-    : handle_(handle),
-      value_id_(value_id) {
-  }
-
-  template <typename ValueAccessorT>
-  inline void operator()(const ValueAccessorT &accessor, StateT *state) {
-    handle_.iterateUnaryInl(state, accessor.getTypedValue(value_id_));
-  }
-
- private:
-  const HandleT &handle_;
-  const attribute_id value_id_;
-};
-
-/**
- * @brief Templated helper class used to implement
- *        AggregationHandle::finalizeHashTable() by visiting each entry (i.e.
- *        GROUP) in a HashTable, finalizing the aggregation for the GROUP, and
- *        collecting the GROUP BY key values and the final aggregate values in
- *        a ColumnVector.
- **/
-template <typename HandleT, typename ColumnVectorT>
-class HashTableAggregateFinalizer {
- public:
-  HashTableAggregateFinalizer(const HandleT &handle,
-                              std::vector<std::vector<TypedValue>> *group_by_keys,
-                              ColumnVectorT *output_column_vector)
-      : handle_(handle),
-        group_by_keys_(group_by_keys),
-        output_column_vector_(output_column_vector) {
-  }
-
-  inline void operator()(const std::vector<TypedValue> &group_by_key,
-                         const AggregationState &group_state) {
-    group_by_keys_->emplace_back(group_by_key);
-    output_column_vector_->appendTypedValue(handle_.finalizeHashTableEntry(group_state));
-  }
-
- private:
-  const HandleT &handle_;
-  std::vector<std::vector<TypedValue>> *group_by_keys_;
-  ColumnVectorT *output_column_vector_;
-};
-
-/** @} */
-
-// ----------------------------------------------------------------------------
-// Implementations of templated methods follow:
-
-template <typename HandleT,
-          typename StateT,
-          typename HashTableT>
-void AggregationHandle::aggregateValueAccessorIntoHashTableNullaryHelper(
-    ValueAccessor *accessor,
-    const std::vector<attribute_id> &group_by_key_ids,
-    const StateT &default_state,
-    AggregationStateHashTableBase *hash_table) const {
-  NullaryAggregationStateValueAccessorUpserter<HandleT, StateT>
-      upserter(static_cast<const HandleT&>(*this));
-  static_cast<HashTableT*>(hash_table)->upsertValueAccessorCompositeKey(
-      accessor,
-      group_by_key_ids,
-      true,
-      default_state,
-      &upserter);
-}
-
-template <typename HandleT,
-          typename StateT,
-          typename HashTableT>
-void AggregationHandle::aggregateValueAccessorIntoHashTableUnaryHelper(
-    ValueAccessor *accessor,
-    const attribute_id argument_id,
-    const std::vector<attribute_id> &group_by_key_ids,
-    const StateT &default_state,
-    AggregationStateHashTableBase *hash_table) const {
-  UnaryAggregationStateValueAccessorUpserter<HandleT, StateT>
-      upserter(static_cast<const HandleT&>(*this), argument_id);
-  static_cast<HashTableT*>(hash_table)->upsertValueAccessorCompositeKey(
-      accessor,
-      group_by_key_ids,
-      true,
-      default_state,
-      &upserter);
-}
-
-template <typename HandleT,
-          typename HashTableT>
-ColumnVector* AggregationHandle::finalizeHashTableHelper(
-    const Type &result_type,
-    const AggregationStateHashTableBase &hash_table,
-    std::vector<std::vector<TypedValue>> *group_by_keys) const {
-  const HandleT &handle = static_cast<const HandleT&>(*this);
-  const HashTableT &hash_table_concrete = static_cast<const HashTableT&>(hash_table);
-
-  if (group_by_keys->empty()) {
-    if (NativeColumnVector::UsableForType(result_type)) {
-      NativeColumnVector *result = new NativeColumnVector(result_type,
-                                                          hash_table_concrete.numEntries());
-      HashTableAggregateFinalizer<HandleT, NativeColumnVector> finalizer(
-          handle,
-          group_by_keys,
-          result);
-      hash_table_concrete.forEachCompositeKey(&finalizer);
-      return result;
-    } else {
-      IndirectColumnVector *result = new IndirectColumnVector(result_type,
-                                                              hash_table_concrete.numEntries());
-      HashTableAggregateFinalizer<HandleT, IndirectColumnVector> finalizer(
-          handle,
-          group_by_keys,
-          result);
-      hash_table_concrete.forEachCompositeKey(&finalizer);
-      return result;
-    }
-  } else {
-    if (NativeColumnVector::UsableForType(result_type)) {
-      NativeColumnVector *result = new NativeColumnVector(result_type,
-                                                          group_by_keys->size());
-      for (const std::vector<TypedValue> &group_by_key : *group_by_keys) {
-        result->appendTypedValue(finalizeGroupInHashTable<HandleT, HashTableT>(hash_table,
-                                                                               group_by_key));
-      }
-      return result;
-    } else {
-      IndirectColumnVector *result = new IndirectColumnVector(result_type,
-                                                              hash_table_concrete.numEntries());
-      for (const std::vector<TypedValue> &group_by_key : *group_by_keys) {
-        result->appendTypedValue(finalizeGroupInHashTable<HandleT, HashTableT>(hash_table,
-                                                                               group_by_key));
-      }
-      return result;
-    }
-  }
-}
-
 }  // namespace quickstep
 
 #endif  // QUICKSTEP_EXPRESSIONS_AGGREGATION_AGGREGATION_HANDLE_HPP_
diff --git a/expressions/aggregation/AggregationHandleAvg.cpp b/expressions/aggregation/AggregationHandleAvg.cpp
index 9fc847d..cb0d63d 100644
--- a/expressions/aggregation/AggregationHandleAvg.cpp
+++ b/expressions/aggregation/AggregationHandleAvg.cpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -181,4 +183,24 @@
       group_by_keys);
 }
 
+AggregationState* AggregationHandleAvg::aggregateOnDistinctifyHashTableForSingle(
+    const AggregationStateHashTableBase &distinctify_hash_table) const {
+  return aggregateOnDistinctifyHashTableForSingleUnaryHelper<
+      AggregationHandleAvg,
+      AggregationStateAvg>(
+          distinctify_hash_table);
+}
+
+void AggregationHandleAvg::aggregateOnDistinctifyHashTableForGroupBy(
+    const AggregationStateHashTableBase &distinctify_hash_table,
+    AggregationStateHashTableBase *aggregation_hash_table) const {
+  aggregateOnDistinctifyHashTableForGroupByUnaryHelper<
+      AggregationHandleAvg,
+      AggregationStateAvg,
+      AggregationStateHashTable<AggregationStateAvg>>(
+          distinctify_hash_table,
+          blank_state_,
+          aggregation_hash_table);
+}
+
 }  // namespace quickstep
diff --git a/expressions/aggregation/AggregationHandleAvg.hpp b/expressions/aggregation/AggregationHandleAvg.hpp
index 105540c..6a94ee6 100644
--- a/expressions/aggregation/AggregationHandleAvg.hpp
+++ b/expressions/aggregation/AggregationHandleAvg.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -24,6 +26,7 @@
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
+#include "expressions/aggregation/AggregationConcreteHandle.hpp"
 #include "expressions/aggregation/AggregationHandle.hpp"
 #include "storage/HashTableBase.hpp"
 #include "threading/SpinMutex.hpp"
@@ -79,7 +82,7 @@
 /**
  * @brief An aggregationhandle for avg.
  **/
-class AggregationHandleAvg : public AggregationHandle {
+class AggregationHandleAvg : public AggregationConcreteHandle {
  public:
   ~AggregationHandleAvg() override {
   }
@@ -140,6 +143,21 @@
       const AggregationStateHashTableBase &hash_table,
       std::vector<std::vector<TypedValue>> *group_by_keys) const override;
 
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForSingle()
+   *        for AVG aggregation.
+   */
+  AggregationState* aggregateOnDistinctifyHashTableForSingle(
+      const AggregationStateHashTableBase &distinctify_hash_table) const override;
+
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForGroupBy()
+   *        for AVG aggregation.
+   */
+  void aggregateOnDistinctifyHashTableForGroupBy(
+      const AggregationStateHashTableBase &distinctify_hash_table,
+      AggregationStateHashTableBase *aggregation_hash_table) const override;
+
  private:
   friend class AggregateFunctionAvg;
 
diff --git a/expressions/aggregation/AggregationHandleCount.cpp b/expressions/aggregation/AggregationHandleCount.cpp
index ceb8e9f..9fb9fd4 100644
--- a/expressions/aggregation/AggregationHandleCount.cpp
+++ b/expressions/aggregation/AggregationHandleCount.cpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -178,6 +180,32 @@
       group_by_keys);
 }
 
+template <bool count_star, bool nullable_type>
+AggregationState* AggregationHandleCount<count_star, nullable_type>
+    ::aggregateOnDistinctifyHashTableForSingle(
+        const AggregationStateHashTableBase &distinctify_hash_table) const {
+  DCHECK_EQ(count_star, false);
+  return aggregateOnDistinctifyHashTableForSingleUnaryHelper<
+      AggregationHandleCount<count_star, nullable_type>,
+      AggregationStateCount>(
+          distinctify_hash_table);
+}
+
+template <bool count_star, bool nullable_type>
+void AggregationHandleCount<count_star, nullable_type>
+    ::aggregateOnDistinctifyHashTableForGroupBy(
+        const AggregationStateHashTableBase &distinctify_hash_table,
+        AggregationStateHashTableBase *aggregation_hash_table) const {
+  DCHECK_EQ(count_star, false);
+  aggregateOnDistinctifyHashTableForGroupByUnaryHelper<
+      AggregationHandleCount<count_star, nullable_type>,
+      AggregationStateCount,
+      AggregationStateHashTable<AggregationStateCount>>(
+          distinctify_hash_table,
+          AggregationStateCount(),
+          aggregation_hash_table);
+}
+
 // Explicitly instantiate and compile in the different versions of
 // AggregationHandleCount we need. Note that we do not compile a version with
 // 'count_star == true' and 'nullable_type == true', as that combination is
diff --git a/expressions/aggregation/AggregationHandleCount.hpp b/expressions/aggregation/AggregationHandleCount.hpp
index 28ea796..6bb4e65 100644
--- a/expressions/aggregation/AggregationHandleCount.hpp
+++ b/expressions/aggregation/AggregationHandleCount.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -25,6 +27,7 @@
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
+#include "expressions/aggregation/AggregationConcreteHandle.hpp"
 #include "expressions/aggregation/AggregationHandle.hpp"
 #include "storage/HashTableBase.hpp"
 #include "types/TypedValue.hpp"
@@ -86,7 +89,7 @@
  *        not nullable and NULL-checks can safely be skipped.
  **/
 template <bool count_star, bool nullable_type>
-class AggregationHandleCount : public AggregationHandle {
+class AggregationHandleCount : public AggregationConcreteHandle {
  public:
   ~AggregationHandleCount() override {
   }
@@ -148,6 +151,21 @@
       const AggregationStateHashTableBase &hash_table,
       std::vector<std::vector<TypedValue>> *group_by_keys) const override;
 
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForSingle()
+   *        for SUM aggregation.
+   */
+  AggregationState* aggregateOnDistinctifyHashTableForSingle(
+      const AggregationStateHashTableBase &distinctify_hash_table) const override;
+
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForGroupBy()
+   *        for SUM aggregation.
+   */
+  void aggregateOnDistinctifyHashTableForGroupBy(
+      const AggregationStateHashTableBase &distinctify_hash_table,
+      AggregationStateHashTableBase *aggregation_hash_table) const override;
+
  private:
   friend class AggregateFunctionCount;
 
diff --git a/expressions/aggregation/AggregationHandleDistinct.cpp b/expressions/aggregation/AggregationHandleDistinct.cpp
index a585c61..fe8ffcf 100644
--- a/expressions/aggregation/AggregationHandleDistinct.cpp
+++ b/expressions/aggregation/AggregationHandleDistinct.cpp
@@ -24,10 +24,11 @@
 
 #include "catalog/CatalogTypedefs.hpp"
 #include "storage/HashTable.hpp"
-#include "storage/HashTableFactory.hpp"
 
 #include "types/TypedValue.hpp"
 
+#include "glog/logging.h"
+
 namespace quickstep {
 
 class ColumnVector;
@@ -40,7 +41,7 @@
     const std::vector<const Type*> &group_by_types,
     const std::size_t estimated_num_groups,
     StorageManager *storage_manager) const {
-  return AggregationStateHashTableFactory<bool>::CreateResizable(
+  return createDistinctifyHashTable(
       hash_table_impl,
       group_by_types,
       estimated_num_groups,
@@ -54,13 +55,10 @@
     AggregationStateHashTableBase *hash_table) const {
   DCHECK_EQ(argument_ids.size(), 0u);
 
-  const auto noop_upserter = [](const auto &accessor, const bool *value) -> void {};
-  static_cast<AggregationStateHashTable<bool>*>(hash_table)->upsertValueAccessorCompositeKey(
+  insertValueAccessorIntoDistinctifyHashTable(
       accessor,
       group_by_key_ids,
-      true,
-      true, /* Initial value */
-      &noop_upserter);
+      hash_table);
 }
 
 ColumnVector* AggregationHandleDistinct::finalizeHashTable(
diff --git a/expressions/aggregation/AggregationHandleDistinct.hpp b/expressions/aggregation/AggregationHandleDistinct.hpp
index 7a3a6d0..918fdf8 100644
--- a/expressions/aggregation/AggregationHandleDistinct.hpp
+++ b/expressions/aggregation/AggregationHandleDistinct.hpp
@@ -23,7 +23,7 @@
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
-#include "expressions/aggregation/AggregationHandle.hpp"
+#include "expressions/aggregation/AggregationConcreteHandle.hpp"
 #include "storage/HashTableBase.hpp"
 #include "types/TypedValue.hpp"
 #include "utility/Macros.hpp"
@@ -32,6 +32,7 @@
 
 namespace quickstep {
 
+class AggregationState;
 class ColumnVector;
 class StorageManager;
 class Type;
@@ -41,7 +42,7 @@
  *  @{
  */
 
-class AggregationHandleDistinct : public AggregationHandle{
+class AggregationHandleDistinct : public AggregationConcreteHandle {
  public:
   /**
    * @brief Constructor.
@@ -79,6 +80,19 @@
     LOG(FATAL) << "AggregationHandleDistinct does not support finalize().";
   }
 
+  AggregationState* aggregateOnDistinctifyHashTableForSingle(
+      const AggregationStateHashTableBase &distinctify_hash_table) const override {
+    LOG(FATAL) << "AggregationHandleDistinct does not support "
+               << "aggregateOnDistinctifyHashTableForSingle().";
+  }
+
+  void aggregateOnDistinctifyHashTableForGroupBy(
+      const AggregationStateHashTableBase &distinctify_hash_table,
+      AggregationStateHashTableBase *groupby_hash_table) const override {
+    LOG(FATAL) << "AggregationHandleDistinct does not support "
+               << "aggregateOnDistinctifyHashTableForGroupBy().";
+  }
+
   AggregationStateHashTableBase* createGroupByHashTable(
       const HashTableImplType hash_table_impl,
       const std::vector<const Type*> &group_by_types,
diff --git a/expressions/aggregation/AggregationHandleMax.cpp b/expressions/aggregation/AggregationHandleMax.cpp
index 156142e..4703657 100644
--- a/expressions/aggregation/AggregationHandleMax.cpp
+++ b/expressions/aggregation/AggregationHandleMax.cpp
@@ -1,6 +1,6 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
- *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2015-2016 Pivotal Software, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -119,4 +119,24 @@
       group_by_keys);
 }
 
+AggregationState* AggregationHandleMax::aggregateOnDistinctifyHashTableForSingle(
+    const AggregationStateHashTableBase &distinctify_hash_table) const {
+  return aggregateOnDistinctifyHashTableForSingleUnaryHelper<
+      AggregationHandleMax,
+      AggregationStateMax>(
+          distinctify_hash_table);
+}
+
+void AggregationHandleMax::aggregateOnDistinctifyHashTableForGroupBy(
+    const AggregationStateHashTableBase &distinctify_hash_table,
+    AggregationStateHashTableBase *aggregation_hash_table) const {
+  aggregateOnDistinctifyHashTableForGroupByUnaryHelper<
+      AggregationHandleMax,
+      AggregationStateMax,
+      AggregationStateHashTable<AggregationStateMax>>(
+          distinctify_hash_table,
+          AggregationStateMax(type_),
+          aggregation_hash_table);
+}
+
 }  // namespace quickstep
diff --git a/expressions/aggregation/AggregationHandleMax.hpp b/expressions/aggregation/AggregationHandleMax.hpp
index d803332..8932ef8 100644
--- a/expressions/aggregation/AggregationHandleMax.hpp
+++ b/expressions/aggregation/AggregationHandleMax.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -24,6 +26,7 @@
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
+#include "expressions/aggregation/AggregationConcreteHandle.hpp"
 #include "expressions/aggregation/AggregationHandle.hpp"
 #include "storage/HashTableBase.hpp"
 #include "threading/SpinMutex.hpp"
@@ -79,7 +82,7 @@
 /**
  * @brief An aggregationhandle for max.
  **/
-class AggregationHandleMax : public AggregationHandle {
+class AggregationHandleMax : public AggregationConcreteHandle {
  public:
   ~AggregationHandleMax() override {
   }
@@ -132,6 +135,22 @@
       const AggregationStateHashTableBase &hash_table,
       std::vector<std::vector<TypedValue>> *group_by_keys) const override;
 
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForSingle()
+   *        for MAX aggregation.
+   */
+  AggregationState* aggregateOnDistinctifyHashTableForSingle(
+      const AggregationStateHashTableBase &distinctify_hash_table) const override;
+
+
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForGroupBy()
+   *        for MAX aggregation.
+   */
+  void aggregateOnDistinctifyHashTableForGroupBy(
+      const AggregationStateHashTableBase &distinctify_hash_table,
+      AggregationStateHashTableBase *aggregation_hash_table) const override;
+
  private:
   friend class AggregateFunctionMax;
 
diff --git a/expressions/aggregation/AggregationHandleMin.cpp b/expressions/aggregation/AggregationHandleMin.cpp
index dbedddc..de2709a 100644
--- a/expressions/aggregation/AggregationHandleMin.cpp
+++ b/expressions/aggregation/AggregationHandleMin.cpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -119,4 +121,24 @@
       group_by_keys);
 }
 
+AggregationState* AggregationHandleMin::aggregateOnDistinctifyHashTableForSingle(
+    const AggregationStateHashTableBase &distinctify_hash_table) const {
+  return aggregateOnDistinctifyHashTableForSingleUnaryHelper<
+      AggregationHandleMin,
+      AggregationStateMin>(
+          distinctify_hash_table);
+}
+
+void AggregationHandleMin::aggregateOnDistinctifyHashTableForGroupBy(
+    const AggregationStateHashTableBase &distinctify_hash_table,
+    AggregationStateHashTableBase *aggregation_hash_table) const {
+  aggregateOnDistinctifyHashTableForGroupByUnaryHelper<
+      AggregationHandleMin,
+      AggregationStateMin,
+      AggregationStateHashTable<AggregationStateMin>>(
+          distinctify_hash_table,
+          AggregationStateMin(type_),
+          aggregation_hash_table);
+}
+
 }  // namespace quickstep
diff --git a/expressions/aggregation/AggregationHandleMin.hpp b/expressions/aggregation/AggregationHandleMin.hpp
index 30a5ecb..4e4c05d 100644
--- a/expressions/aggregation/AggregationHandleMin.hpp
+++ b/expressions/aggregation/AggregationHandleMin.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -24,6 +26,7 @@
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
+#include "expressions/aggregation/AggregationConcreteHandle.hpp"
 #include "expressions/aggregation/AggregationHandle.hpp"
 #include "storage/HashTableBase.hpp"
 #include "threading/SpinMutex.hpp"
@@ -78,7 +81,7 @@
 /**
  * @brief An aggregationhandle for min.
  **/
-class AggregationHandleMin : public AggregationHandle {
+class AggregationHandleMin : public AggregationConcreteHandle {
  public:
   ~AggregationHandleMin() override {
   }
@@ -131,6 +134,21 @@
       const AggregationStateHashTableBase &hash_table,
       std::vector<std::vector<TypedValue>> *group_by_keys) const override;
 
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForSingle()
+   *        for MIN aggregation.
+   */
+  AggregationState* aggregateOnDistinctifyHashTableForSingle(
+      const AggregationStateHashTableBase &distinctify_hash_table) const override;
+
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForGroupBy()
+   *        for MIN aggregation.
+   */
+  void aggregateOnDistinctifyHashTableForGroupBy(
+      const AggregationStateHashTableBase &distinctify_hash_table,
+      AggregationStateHashTableBase *aggregation_hash_table) const override;
+
  private:
   friend class AggregateFunctionMin;
 
diff --git a/expressions/aggregation/AggregationHandleSum.cpp b/expressions/aggregation/AggregationHandleSum.cpp
index 171445f..410fecb 100644
--- a/expressions/aggregation/AggregationHandleSum.cpp
+++ b/expressions/aggregation/AggregationHandleSum.cpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -168,4 +170,24 @@
       group_by_keys);
 }
 
+AggregationState* AggregationHandleSum::aggregateOnDistinctifyHashTableForSingle(
+    const AggregationStateHashTableBase &distinctify_hash_table) const {
+  return aggregateOnDistinctifyHashTableForSingleUnaryHelper<
+      AggregationHandleSum,
+      AggregationStateSum>(
+          distinctify_hash_table);
+}
+
+void AggregationHandleSum::aggregateOnDistinctifyHashTableForGroupBy(
+    const AggregationStateHashTableBase &distinctify_hash_table,
+    AggregationStateHashTableBase *aggregation_hash_table) const {
+  aggregateOnDistinctifyHashTableForGroupByUnaryHelper<
+      AggregationHandleSum,
+      AggregationStateSum,
+      AggregationStateHashTable<AggregationStateSum>>(
+          distinctify_hash_table,
+          blank_state_,
+          aggregation_hash_table);
+}
+
 }  // namespace quickstep
diff --git a/expressions/aggregation/AggregationHandleSum.hpp b/expressions/aggregation/AggregationHandleSum.hpp
index 58fd54e..b765243 100644
--- a/expressions/aggregation/AggregationHandleSum.hpp
+++ b/expressions/aggregation/AggregationHandleSum.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -24,6 +26,7 @@
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
+#include "expressions/aggregation/AggregationConcreteHandle.hpp"
 #include "expressions/aggregation/AggregationHandle.hpp"
 #include "storage/HashTableBase.hpp"
 #include "threading/SpinMutex.hpp"
@@ -78,7 +81,7 @@
 /**
  * @brief An aggregationhandle for sum.
  **/
-class AggregationHandleSum : public AggregationHandle {
+class AggregationHandleSum : public AggregationConcreteHandle {
  public:
   ~AggregationHandleSum() override {
   }
@@ -130,6 +133,21 @@
       const AggregationStateHashTableBase &hash_table,
       std::vector<std::vector<TypedValue>> *group_by_keys) const override;
 
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForSingle()
+   *        for SUM aggregation.
+   */
+  AggregationState* aggregateOnDistinctifyHashTableForSingle(
+      const AggregationStateHashTableBase &distinctify_hash_table) const override;
+
+  /**
+   * @brief Implementation of AggregationHandle::aggregateOnDistinctifyHashTableForGroupBy()
+   *        for SUM aggregation.
+   */
+  void aggregateOnDistinctifyHashTableForGroupBy(
+      const AggregationStateHashTableBase &distinctify_hash_table,
+      AggregationStateHashTableBase *aggregation_hash_table) const override;
+
  private:
   friend class AggregateFunctionSum;
 
diff --git a/expressions/aggregation/CMakeLists.txt b/expressions/aggregation/CMakeLists.txt
index 4d92b45..26cec7f 100644
--- a/expressions/aggregation/CMakeLists.txt
+++ b/expressions/aggregation/CMakeLists.txt
@@ -1,5 +1,5 @@
 #   Copyright 2011-2015 Quickstep Technologies LLC.
-#   Copyright 2015 Pivotal Software, Inc.
+#   Copyright 2015-2016 Pivotal Software, Inc.
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -41,6 +41,9 @@
 add_library(quickstep_expressions_aggregation_AggregateFunctionSum
             AggregateFunctionSum.cpp
             AggregateFunctionSum.hpp)
+add_library(quickstep_expressions_aggregation_AggregationConcreteHandle
+            AggregationConcreteHandle.cpp
+            AggregationConcreteHandle.hpp)
 add_library(quickstep_expressions_aggregation_AggregationHandle
             ../../empty_src.cpp
             AggregationHandle.hpp)
@@ -137,16 +140,26 @@
                       quickstep_types_operations_binaryoperations_BinaryOperationFactory
                       quickstep_types_operations_binaryoperations_BinaryOperationID
                       quickstep_utility_Macros)
+target_link_libraries(quickstep_expressions_aggregation_AggregationConcreteHandle
+                      glog
+                      quickstep_catalog_CatalogTypedefs
+                      quickstep_expressions_aggregation_AggregationHandle
+                      quickstep_storage_HashTable
+                      quickstep_storage_HashTableBase
+                      quickstep_storage_HashTableFactory
+                      quickstep_types_TypedValue
+                      quickstep_types_containers_ColumnVector
+                      quickstep_utility_Macros)
 target_link_libraries(quickstep_expressions_aggregation_AggregationHandle
                       glog
                       quickstep_catalog_CatalogTypedefs
                       quickstep_storage_HashTableBase
                       quickstep_types_TypedValue
-                      quickstep_types_containers_ColumnVector
                       quickstep_utility_Macros)
 target_link_libraries(quickstep_expressions_aggregation_AggregationHandleAvg
                       glog
                       quickstep_catalog_CatalogTypedefs
+                      quickstep_expressions_aggregation_AggregationConcreteHandle
                       quickstep_expressions_aggregation_AggregationHandle
                       quickstep_storage_HashTable
                       quickstep_storage_HashTableBase
@@ -163,6 +176,7 @@
 target_link_libraries(quickstep_expressions_aggregation_AggregationHandleCount
                       glog
                       quickstep_catalog_CatalogTypedefs
+                      quickstep_expressions_aggregation_AggregationConcreteHandle
                       quickstep_expressions_aggregation_AggregationHandle
                       quickstep_storage_HashTable
                       quickstep_storage_HashTableBase
@@ -178,15 +192,15 @@
 target_link_libraries(quickstep_expressions_aggregation_AggregationHandleDistinct
                       glog
                       quickstep_catalog_CatalogTypedefs
-                      quickstep_expressions_aggregation_AggregationHandle
+                      quickstep_expressions_aggregation_AggregationConcreteHandle
                       quickstep_storage_HashTable
                       quickstep_storage_HashTableBase
-                      quickstep_storage_HashTableFactory
                       quickstep_types_TypedValue
                       quickstep_utility_Macros)
 target_link_libraries(quickstep_expressions_aggregation_AggregationHandleMax
                       glog
                       quickstep_catalog_CatalogTypedefs
+                      quickstep_expressions_aggregation_AggregationConcreteHandle
                       quickstep_expressions_aggregation_AggregationHandle
                       quickstep_storage_HashTable
                       quickstep_storage_HashTableBase
@@ -202,6 +216,7 @@
 target_link_libraries(quickstep_expressions_aggregation_AggregationHandleMin
                       glog
                       quickstep_catalog_CatalogTypedefs
+                      quickstep_expressions_aggregation_AggregationConcreteHandle
                       quickstep_expressions_aggregation_AggregationHandle
                       quickstep_storage_HashTable
                       quickstep_storage_HashTableBase
@@ -217,6 +232,7 @@
 target_link_libraries(quickstep_expressions_aggregation_AggregationHandleSum
                       glog
                       quickstep_catalog_CatalogTypedefs
+                      quickstep_expressions_aggregation_AggregationConcreteHandle
                       quickstep_expressions_aggregation_AggregationHandle
                       quickstep_storage_HashTable
                       quickstep_storage_HashTableBase
@@ -242,6 +258,7 @@
                       quickstep_expressions_aggregation_AggregateFunctionMax
                       quickstep_expressions_aggregation_AggregateFunctionMin
                       quickstep_expressions_aggregation_AggregateFunctionSum
+                      quickstep_expressions_aggregation_AggregationConcreteHandle
                       quickstep_expressions_aggregation_AggregationHandle
                       quickstep_expressions_aggregation_AggregationHandleAvg
                       quickstep_expressions_aggregation_AggregationHandleCount
diff --git a/parser/CMakeLists.txt b/parser/CMakeLists.txt
index 3d9f726..ccce7b3 100644
--- a/parser/CMakeLists.txt
+++ b/parser/CMakeLists.txt
@@ -95,6 +95,7 @@
 add_library(quickstep_parser_ParseLimit ParseLimit.cpp ParseLimit.hpp)
 add_library(quickstep_parser_ParseLiteralValue ParseLiteralValue.cpp ParseLiteralValue.hpp)
 add_library(quickstep_parser_ParseOrderBy ParseOrderBy.cpp ParseOrderBy.hpp)
+add_library(quickstep_parser_ParsePartitionClause ../empty_src.cpp ParsePartitionClause.hpp)
 add_library(quickstep_parser_ParsePredicate ParsePredicate.cpp ParsePredicate.hpp)
 add_library(quickstep_parser_ParseSample ParseSample.cpp ParseSample.hpp)
 add_library(quickstep_parser_ParseSelect ../empty_src.cpp ParseSelect.hpp)
@@ -188,13 +189,18 @@
                       quickstep_parser_ParseTreeNode
                       quickstep_utility_Macros
                       quickstep_utility_PtrList)
+target_link_libraries(quickstep_parser_ParsePartitionClause
+                      quickstep_parser_ParseLiteralValue
+                      quickstep_parser_ParseString
+                      quickstep_parser_ParseTreeNode
+                      quickstep_utility_Macros
+                      quickstep_utility_PtrList)
 target_link_libraries(quickstep_parser_ParsePredicate
                       quickstep_parser_ParseExpression
                       quickstep_parser_ParseTreeNode
                       quickstep_types_operations_comparisons_Comparison
                       quickstep_utility_Macros
                       quickstep_utility_PtrList)
-
 target_link_libraries(quickstep_parser_ParseSample
                       quickstep_parser_ParseLiteralValue
                       quickstep_parser_ParseTreeNode
@@ -230,6 +236,7 @@
                       quickstep_parser_ParseBlockProperties
                       quickstep_parser_ParseIndexProperties
                       quickstep_parser_ParseKeyValue
+                      quickstep_parser_ParsePartitionClause
                       quickstep_parser_ParsePredicate
                       quickstep_parser_ParseSelect
                       quickstep_parser_ParseString
@@ -275,6 +282,7 @@
                       quickstep_utility_PtrList
                       quickstep_utility_PtrVector)
 target_link_libraries(quickstep_parser_SqlParser
+                      quickstep_catalog_PartitionSchemeHeader
                       quickstep_parser_ParseAssignment
                       quickstep_parser_ParseAttributeDefinition
                       quickstep_parser_ParseBasicExpressions
@@ -287,6 +295,7 @@
                       quickstep_parser_ParseLimit
                       quickstep_parser_ParseLiteralValue
                       quickstep_parser_ParseOrderBy
+                      quickstep_parser_ParsePartitionClause
                       quickstep_parser_ParsePredicate
                       quickstep_parser_ParseSample
                       quickstep_parser_ParseSelect
@@ -357,6 +366,7 @@
                       quickstep_parser_ParseLimit
                       quickstep_parser_ParseLiteralValue
                       quickstep_parser_ParseOrderBy
+                      quickstep_parser_ParsePartitionClause
                       quickstep_parser_ParsePredicate
                       quickstep_parser_ParserUtil
                       quickstep_parser_ParseSample
diff --git a/parser/ParseBasicExpressions.cpp b/parser/ParseBasicExpressions.cpp
index dd80abd..2b1d7e0 100644
--- a/parser/ParseBasicExpressions.cpp
+++ b/parser/ParseBasicExpressions.cpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -120,6 +122,9 @@
   if (star_ != nullptr) {
     name.push_back('*');
   } else {
+    if (is_distinct_) {
+      name.append("DISTINCT ");
+    }
     bool first = true;
     for (const ParseExpression &argument : *arguments_) {
       if (!first) {
@@ -144,6 +149,11 @@
   inline_field_names->push_back("name");
   inline_field_values->push_back(name_->value());
 
+  if (is_distinct_) {
+    inline_field_names->push_back("is_distinct");
+    inline_field_values->push_back("true");
+  }
+
   if (star_ != nullptr) {
     inline_field_names->push_back("is_star");
     inline_field_values->push_back("true");
@@ -155,4 +165,28 @@
   }
 }
 
+std::string ParseExtractFunction::generateName() const {
+  std::string name;
+  name.append("EXTRACT(");
+  name.append(extract_field_->value());
+  name.append(" FROM ");
+  name.append(date_expression_->generateName());
+  name.push_back(')');
+  return name;
+}
+
+void ParseExtractFunction::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("unit");
+  inline_field_values->push_back(extract_field_->value());
+
+  non_container_child_field_names->push_back("date_expression");
+  non_container_child_fields->push_back(date_expression_.get());
+}
+
 }  // namespace quickstep
diff --git a/parser/ParseBasicExpressions.hpp b/parser/ParseBasicExpressions.hpp
index 2668489..1886c8b 100644
--- a/parser/ParseBasicExpressions.hpp
+++ b/parser/ParseBasicExpressions.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -352,14 +354,19 @@
    *
    * @param line_number The line number of the first token of the function call.
    * @param column_number The column number of the first token of the first call.
+   * @param is_distinct Whether this function call contains the DISTINCT keyword.
    * @param name The function name.
    * @param arguments The function argument list.
    */
   ParseFunctionCall(const int line_number,
                     const int column_number,
+                    const bool is_distinct,
                     ParseString *name,
                     PtrList<ParseExpression> *arguments)
-      : ParseExpression(line_number, column_number), name_(name), arguments_(arguments) {
+      : ParseExpression(line_number, column_number),
+        is_distinct_(is_distinct),
+        name_(name),
+        arguments_(arguments) {
   }
 
   /**
@@ -373,6 +380,7 @@
    */
   ParseFunctionCall(const int line_number, const int column_number, ParseString *name, ParseStar *star)
       : ParseExpression(line_number, column_number),
+        is_distinct_(false),
         name_(name),
         star_(star) {
   }
@@ -392,6 +400,13 @@
   }
 
   /**
+   * @return Whether this function call contains the DISTINCT keyword.
+   */
+  bool is_distinct() const {
+    return is_distinct_;
+  }
+
+  /**
    * @return The function name.
    */
   const ParseString* name() const {
@@ -424,6 +439,7 @@
       std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override;
 
  private:
+  const bool is_distinct_;
   std::unique_ptr<ParseString> name_;
   // Either <arguments_> or <star_> is NULL.
   std::unique_ptr<PtrList<ParseExpression>> arguments_;
@@ -432,6 +448,69 @@
   DISALLOW_COPY_AND_ASSIGN(ParseFunctionCall);
 };
 
+
+/**
+ * @brief Parsed representation of EXTRACT(unit FROM date).
+ */
+class ParseExtractFunction : public ParseExpression {
+ public:
+  /**
+   * @brief Constructor.
+   *
+   * @param line_number The line number of the token "extract" in the statement.
+   * @param column_number The column number of the token "extract in the statement.
+   * @param extract_field The field to extract.
+   * @param source_expression The expression to extract a field from.
+   */
+  ParseExtractFunction(const int line_number,
+                       const int column_number,
+                       ParseString *extract_field,
+                       ParseExpression *date_expression)
+      : ParseExpression(line_number, column_number),
+        extract_field_(extract_field),
+        date_expression_(date_expression) {
+  }
+
+  ExpressionType getExpressionType() const override {
+    return kExtract;
+  }
+
+  std::string getName() const override {
+    return "Extract";
+  }
+
+  /**
+   * @return The field to extract.
+   */
+  const ParseString* extract_field() const {
+    return extract_field_.get();
+  }
+
+  /**
+   * @return The expression to extract a field from.
+   */
+  const ParseExpression* date_expression() const {
+    return date_expression_.get();
+  }
+
+  std::string generateName() const override;
+
+ 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> extract_field_;
+  std::unique_ptr<ParseExpression> date_expression_;
+
+  DISALLOW_COPY_AND_ASSIGN(ParseExtractFunction);
+};
+
 /** @} */
 
 }  // namespace quickstep
diff --git a/parser/ParseExpression.hpp b/parser/ParseExpression.hpp
index accad01..8e4efee 100644
--- a/parser/ParseExpression.hpp
+++ b/parser/ParseExpression.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -37,6 +39,7 @@
   enum ExpressionType {
     kAttribute,
     kBinaryExpression,
+    kExtract,
     kFunctionCall,
     kScalarLiteral,
     kSubqueryExpression,
diff --git a/parser/ParsePartitionClause.hpp b/parser/ParsePartitionClause.hpp
new file mode 100644
index 0000000..1b7096f
--- /dev/null
+++ b/parser/ParsePartitionClause.hpp
@@ -0,0 +1,132 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *   University of Wisconsin—Madison.
+ *
+ *   Licensed 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_
diff --git a/parser/ParseStatement.hpp b/parser/ParseStatement.hpp
index 2400002..9807e0a 100644
--- a/parser/ParseStatement.hpp
+++ b/parser/ParseStatement.hpp
@@ -30,6 +30,7 @@
 #include "parser/ParseBlockProperties.hpp"
 #include "parser/ParseIndexProperties.hpp"
 #include "parser/ParseKeyValue.hpp"
+#include "parser/ParsePartitionClause.hpp"
 #include "parser/ParsePredicate.hpp"
 #include "parser/ParseSelect.hpp"
 #include "parser/ParseString.hpp"
@@ -109,11 +110,13 @@
                             const int column_number,
                             ParseString *relation_name,
                             PtrList<ParseAttributeDefinition> *attribute_definition_list,
-                            ParseBlockProperties *opt_block_properties)
+                            ParseBlockProperties *opt_block_properties,
+                            ParsePartitionClause *opt_partition_clause)
       : ParseStatement(line_number, column_number),
         relation_name_(relation_name),
         attribute_definition_list_(attribute_definition_list),
-        opt_block_properties_(opt_block_properties) {
+        opt_block_properties_(opt_block_properties),
+        opt_partition_clause_(opt_partition_clause) {
   }
 
   ~ParseStatementCreateTable() override {
@@ -152,6 +155,15 @@
     return opt_block_properties_.get();
   }
 
+  /**
+   * @brief Get a pointer to the PartitionClause.
+   *
+   * @return The PartitionClause or nullptr if not specified.
+   **/
+  const ParsePartitionClause* opt_partition_clause() const {
+    return opt_partition_clause_.get();
+  }
+
  protected:
   void getFieldStringItems(
       std::vector<std::string> *inline_field_names,
@@ -174,12 +186,19 @@
       container_child_fields->emplace_back();
       container_child_fields->back().push_back(opt_block_properties_.get());
     }
+
+    if (opt_partition_clause_) {
+      container_child_field_names->push_back("partition_clause");
+      container_child_fields->emplace_back();
+      container_child_fields->back().push_back(opt_partition_clause_.get());
+    }
   }
 
  private:
   std::unique_ptr<ParseString> relation_name_;
   std::unique_ptr<PtrList<ParseAttributeDefinition> > attribute_definition_list_;
   std::unique_ptr<ParseBlockProperties> opt_block_properties_;
+  std::unique_ptr<ParsePartitionClause> opt_partition_clause_;
 
   DISALLOW_COPY_AND_ASSIGN(ParseStatementCreateTable);
 };
@@ -519,33 +538,37 @@
 
 /**
  * @brief The parsed representation of an INSERT statement.
+ *
+ * This is an abstract class where each of its subclass represents a concrete
+ * type of insert operation.
  **/
 class ParseStatementInsert : public ParseStatement {
  public:
+  enum class InsertType {
+    kTuple = 0,
+    kSelection
+  };
+
   /**
    * @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 relation_name The name of the relation to insert into.
-   * @param literal_values A list of literal values (in attribute-definition
-   *        order) to insert into the specified relation as a new tuple.
-   *        Becomes owned by this ParseStatementInsert.
    **/
   ParseStatementInsert(const int line_number,
                        const int column_number,
-                       ParseString *relation_name,
-                       PtrList<ParseScalarLiteral> *literal_values)
+                       const ParseString *relation_name)
       : ParseStatement(line_number, column_number),
-        relation_name_(relation_name),
-        literal_values_(literal_values) {
+        relation_name_(relation_name) {
   }
 
   /**
-   * @brief Destructor.
+   * @brief Get the insert type of this insert statement.
+   *
+   * @return The insert type of this insert statement.
    */
-  ~ParseStatementInsert() override {
-  }
+  virtual InsertType getInsertType() const = 0;
 
   std::string getName() const override { return "InsertStatement"; }
 
@@ -562,6 +585,43 @@
     return relation_name_.get();
   }
 
+ private:
+  std::unique_ptr<const ParseString> relation_name_;
+
+  DISALLOW_COPY_AND_ASSIGN(ParseStatementInsert);
+};
+
+
+/**
+ * @brief The parsed representation of an INSERT ... VALUES ... statement.
+ **/
+class ParseStatementInsertTuple : public ParseStatementInsert {
+ 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 relation_name The name of the relation to insert into.
+   * @param literal_values A list of literal values (in attribute-definition
+   *        order) to insert into the specified relation as a new tuple.
+   *        Becomes owned by this ParseStatementInsert.
+   **/
+  ParseStatementInsertTuple(const int line_number,
+                            const int column_number,
+                            const ParseString *relation_name,
+                            PtrList<ParseScalarLiteral> *literal_values)
+      : ParseStatementInsert(line_number, column_number, relation_name),
+        literal_values_(literal_values) {
+  }
+
+  ~ParseStatementInsertTuple() override {
+  }
+
+  InsertType getInsertType() const override {
+    return InsertType::kTuple;
+  }
+
   /**
    * @brief Get the parsed literal attribute values to insert.
    *
@@ -580,7 +640,7 @@
       std::vector<std::string> *container_child_field_names,
       std::vector<std::vector<const ParseTreeNode*>> *container_child_fields) const override {
     inline_field_names->push_back("relation_name");
-    inline_field_values->push_back(relation_name_->value());
+    inline_field_values->push_back(relation_name()->value());
 
     container_child_field_names->push_back("tuple");
     container_child_fields->emplace_back();
@@ -590,10 +650,86 @@
   }
 
  private:
-  std::unique_ptr<ParseString> relation_name_;
   std::unique_ptr<PtrList<ParseScalarLiteral> > literal_values_;
 
-  DISALLOW_COPY_AND_ASSIGN(ParseStatementInsert);
+  DISALLOW_COPY_AND_ASSIGN(ParseStatementInsertTuple);
+};
+
+/**
+ * @brief The parsed representation of an INSERT ... SELECT ... statement.
+ **/
+class ParseStatementInsertSelection : public ParseStatementInsert {
+ 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 relation_name The name of the relation to insert into.
+   * @param select_query The SELECT query for generating insertion tuples.
+   * @param with_clause The WITH clause of common table query expressions.
+   **/
+  ParseStatementInsertSelection(const int line_number,
+                                const int column_number,
+                                const ParseString *relation_name,
+                                ParseSelect *select_query,
+                                PtrVector<ParseSubqueryTableReference> *with_clause)
+      : ParseStatementInsert(line_number, column_number, relation_name),
+        select_query_(select_query),
+        with_clause_(with_clause) {
+  }
+
+  ~ParseStatementInsertSelection() override {
+  }
+
+  InsertType getInsertType() const override {
+    return InsertType::kSelection;
+  }
+
+  /**
+   * @return Gets the SELECT query.
+   */
+  const ParseSelect* select_query() const {
+    return select_query_.get();
+  }
+
+  /**
+   * @brief Gets the WITH table queries.
+   *
+   * @return The parsed WITH table list.
+   */
+  const PtrVector<ParseSubqueryTableReference>* with_clause() const {
+    return with_clause_.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("relation_name");
+    inline_field_values->push_back(relation_name()->value());
+
+    non_container_child_field_names->push_back("select_query");
+    non_container_child_fields->push_back(select_query_.get());
+
+    if (with_clause_ != nullptr && !with_clause_->empty()) {
+      container_child_field_names->push_back("with_clause");
+      container_child_fields->emplace_back();
+      for (const ParseSubqueryTableReference &common_subquery : *with_clause_) {
+        container_child_fields->back().push_back(&common_subquery);
+      }
+    }
+  }
+
+ private:
+  std::unique_ptr<ParseSelect> select_query_;
+  std::unique_ptr<PtrVector<ParseSubqueryTableReference>> with_clause_;
+
+  DISALLOW_COPY_AND_ASSIGN(ParseStatementInsertSelection);
 };
 
 /**
diff --git a/parser/SqlLexer.lpp b/parser/SqlLexer.lpp
index 4c13c28..e5708a0 100644
--- a/parser/SqlLexer.lpp
+++ b/parser/SqlLexer.lpp
@@ -55,6 +55,7 @@
 class ParseLimit;
 class ParseOrderBy;
 class ParseOrderByItem;
+class ParsePartitionClause;
 class ParsePredicate;
 class ParseSample;
 class ParseScalarLiteral;
@@ -71,6 +72,8 @@
 class ParseStatementDelete;
 class ParseStatementDropTable;
 class ParseStatementInsert;
+class ParseStatementInsertTuple;
+class ParseStatementInsertSelection;
 class ParseStatementSelect;
 class ParseStatementQuit;
 class ParseStatementUpdate;
@@ -191,6 +194,7 @@
   "double"           return TOKEN_DOUBLE;
   "drop"             return TOKEN_DROP;
   "escape_strings"   return TOKEN_ESCAPE_STRINGS;
+  "extract"          return TOKEN_EXTRACT;
   "false"            return TOKEN_FALSE;
   "first"            return TOKEN_FIRST;
   "float"            return TOKEN_FLOAT;
@@ -198,6 +202,7 @@
   "from"             return TOKEN_FROM;
   "full"             return TOKEN_FULL;
   "group"            return TOKEN_GROUP;
+  "hash"             return TOKEN_HASH;
   "having"           return TOKEN_HAVING;
   "index"            return TOKEN_INDEX;
   "inner"            return TOKEN_INNER;
@@ -222,9 +227,12 @@
   "or"               return TOKEN_OR;
   "order"            return TOKEN_ORDER;
   "outer"            return TOKEN_OUTER;
+  "partition"        return TOKEN_PARTITION;
+  "partitions"       return TOKEN_PARTITIONS;
   "percent"          return TOKEN_PERCENT;
   "primary"          return TOKEN_PRIMARY;
   "quit"             return TOKEN_QUIT;
+  "range"            return TOKEN_RANGE;
   "real"             return TOKEN_REAL;
   "references"       return TOKEN_REFERENCES;
   "regexp"           return TOKEN_REGEXP;
diff --git a/parser/SqlParser.ypp b/parser/SqlParser.ypp
index eada5e1..0673ae3 100644
--- a/parser/SqlParser.ypp
+++ b/parser/SqlParser.ypp
@@ -66,6 +66,7 @@
 #include <string>
 #include <utility>
 
+#include "catalog/PartitionSchemeHeader.hpp"
 #include "parser/ParseAssignment.hpp"
 #include "parser/ParseAttributeDefinition.hpp"
 #include "parser/ParseBasicExpressions.hpp"
@@ -78,6 +79,7 @@
 #include "parser/ParseLimit.hpp"
 #include "parser/ParseLiteralValue.hpp"
 #include "parser/ParseOrderBy.hpp"
+#include "parser/ParsePartitionClause.hpp"
 #include "parser/ParsePredicate.hpp"
 #include "parser/ParserUtil.hpp"
 #include "parser/ParseSample.hpp"
@@ -165,6 +167,7 @@
   quickstep::ParseStatementDelete *delete_statement_;
   quickstep::ParseStatementCopyFrom *copy_from_statement_;
   quickstep::ParseStatementCreateTable *create_table_statement_;
+  quickstep::ParsePartitionClause *partition_clause_;
   quickstep::ParseBlockProperties *block_properties_;
   quickstep::ParseStatementDropTable *drop_table_statement_;
   quickstep::ParseStatementQuit *quit_statement_;
@@ -248,6 +251,7 @@
 %token TOKEN_DOUBLE;
 %token TOKEN_DROP;
 %token TOKEN_ESCAPE_STRINGS;
+%token TOKEN_EXTRACT;
 %token TOKEN_FALSE;
 %token TOKEN_FIRST;
 %token TOKEN_FLOAT;
@@ -255,6 +259,7 @@
 %token TOKEN_FROM;
 %token TOKEN_FULL;
 %token TOKEN_GROUP;
+%token TOKEN_HASH;
 %token TOKEN_HAVING;
 %token TOKEN_INDEX;
 %token TOKEN_INNER;
@@ -276,9 +281,12 @@
 %token TOKEN_OR;
 %token TOKEN_ORDER;
 %token TOKEN_OUTER;
+%token TOKEN_PARTITION;
+%token TOKEN_PARTITIONS;
 %token TOKEN_PERCENT;
 %token TOKEN_PRIMARY;
 %token TOKEN_QUIT;
+%token TOKEN_RANGE;
 %token TOKEN_REAL;
 %token TOKEN_REFERENCES;
 %token TOKEN_REGEXP;
@@ -306,6 +314,7 @@
 %type <string_value_>
   any_name
   index_type
+  partition_type
 
 %type <boolean_value_>
   boolean_value
@@ -321,6 +330,7 @@
   unary_expression
   multiply_expression
   add_expression
+  extract_function
 
 %type <attribute_>
   attribute_ref
@@ -430,6 +440,9 @@
 %type <block_properties_>
   opt_block_properties
 
+%type <partition_clause_>
+  opt_partition_clause
+
 %type <statement_>
   create_index_statement
 
@@ -485,7 +498,7 @@
   opt_sample_clause
 
 %type <with_list_>
-  opt_with_clause
+  with_clause
   with_list
 
 %type <with_list_element_>
@@ -616,8 +629,8 @@
   };
 
 create_table_statement:
-  TOKEN_CREATE TOKEN_TABLE any_name '(' column_def_commalist ')' opt_table_constraint_def_commalist opt_block_properties {
-    $$ = new quickstep::ParseStatementCreateTable(@1.first_line, @1.first_column, $3, $5, $8);
+  TOKEN_CREATE TOKEN_TABLE any_name '(' column_def_commalist ')' opt_table_constraint_def_commalist opt_block_properties opt_partition_clause {
+    $$ = new quickstep::ParseStatementCreateTable(@1.first_line, @1.first_column, $3, $5, $8, $9);
   };
 
 create_index_statement:
@@ -861,6 +874,38 @@
     $$ = new quickstep::ParseBlockProperties(@2.first_line, @2.first_column, $4);
   }
 
+opt_partition_clause:
+  {
+    $$ = nullptr;
+  }
+  | TOKEN_PARTITION TOKEN_BY partition_type '(' name_commalist ')' TOKEN_PARTITIONS TOKEN_UNSIGNED_NUMVAL {
+    if ($8->float_like()) {
+      delete $8;
+      $$ = NULL;
+      quickstep_yyerror(&@8, yyscanner, NULL, "NUMBER OF PARTITIONS must be an integer");
+      YYERROR;
+    } else {
+      if ($8->long_value() <= 0 || $8->long_value() > 64) {
+        delete $8;
+        $$ = NULL;
+        quickstep_yyerror(&@8, yyscanner, NULL, "NUMBER OF PARITIONS must be between 1 and 64");
+        YYERROR;
+      } else {
+        $$ = new quickstep::ParsePartitionClause(@1.first_line, @1.first_column, $3, $5, $8);
+      }
+    }
+  }
+
+partition_type:
+  TOKEN_HASH {
+    $$ = new quickstep::ParseString(@1.first_line, @1.first_column,
+           std::to_string(quickstep::PartitionSchemeHeader::PartitionType::kHash));
+  }
+  | TOKEN_RANGE{
+    $$ = new quickstep::ParseString(@1.first_line, @1.first_column,
+           std::to_string(quickstep::PartitionSchemeHeader::PartitionType::kRange));
+  };
+
 key_value_list:
   key_value {
     $$ = new quickstep::PtrList<quickstep::ParseKeyValue>();
@@ -937,8 +982,15 @@
     YYERROR;
   }
   | TOKEN_INSERT TOKEN_INTO any_name TOKEN_VALUES '(' literal_value_commalist ')' {
-    $$ = new quickstep::ParseStatementInsert(@1.first_line, @1.first_column, $3, $6);
-  };
+    $$ = new quickstep::ParseStatementInsertTuple(@1.first_line, @1.first_column, $3, $6);
+  }
+  | TOKEN_INSERT TOKEN_INTO any_name select_query {
+    $$ = new quickstep::ParseStatementInsertSelection(@1.first_line, @2.first_column, $3, $4, nullptr);
+  }
+  | with_clause TOKEN_INSERT TOKEN_INTO any_name select_query {
+    $$ = new quickstep::ParseStatementInsertSelection(@1.first_line, @2.first_column, $4, $5, $1);
+  }
+  ;
 
 copy_from_statement:
   TOKEN_COPY any_name TOKEN_FROM TOKEN_STRING_SINGLE_QUOTED opt_copy_from_params {
@@ -998,15 +1050,15 @@
 
 /* Select Queries */
 select_statement:
-  opt_with_clause select_query {
+  select_query {
+    $$ = new quickstep::ParseStatementSelect(@1.first_line, @1.first_column, $1, nullptr);
+  }
+  | with_clause select_query {
     $$ = new quickstep::ParseStatementSelect(@1.first_line, @1.first_column, $2, $1);
   };
 
-opt_with_clause:
-  {
-    $$ = nullptr;
-  }
-  | TOKEN_WITH with_list {
+with_clause:
+  TOKEN_WITH with_list {
     $$ = $2;
   }
 
@@ -1408,6 +1460,9 @@
   | function_call {
     $$ = $1;
   }
+  | extract_function {
+    $$ = $1;
+  }
   | '(' add_expression ')' {
     $$ = $2;
   };
@@ -1415,14 +1470,22 @@
 function_call:
   any_name '(' ')' {
     $$ = new quickstep::ParseFunctionCall(
-        @1.first_line, @1.first_column, $1, new quickstep::PtrList<quickstep::ParseExpression>());
+        @1.first_line, @1.first_column, false, $1, new quickstep::PtrList<quickstep::ParseExpression>());
   }
   | any_name '(' '*' ')' {
     $$ = new quickstep::ParseFunctionCall(
         @1.first_line, @1.first_column, $1, new quickstep::ParseStar(@3.first_line, @3.first_column));
   }
   | any_name '(' expression_list ')' {
-    $$ = new quickstep::ParseFunctionCall(@1.first_line, @1.first_column, $1, $3);
+    $$ = new quickstep::ParseFunctionCall(@1.first_line, @1.first_column, false, $1, $3);
+  };
+  | any_name '(' TOKEN_DISTINCT expression_list ')' {
+    $$ = new quickstep::ParseFunctionCall(@1.first_line, @1.first_column, true, $1, $4);
+  };
+
+extract_function:
+  TOKEN_EXTRACT '(' any_name TOKEN_FROM add_expression ')' {
+    $$ = new quickstep::ParseExtractFunction(@1.first_line, @1.first_column, $3, $5);
   };
 
 expression_list:
diff --git a/parser/SqlParserWrapper.cpp b/parser/SqlParserWrapper.cpp
index 41abdec..e590291 100644
--- a/parser/SqlParserWrapper.cpp
+++ b/parser/SqlParserWrapper.cpp
@@ -43,6 +43,7 @@
 class ParseKeyStringList;
 class ParseKeyLiteralValue;
 class ParseLiteralValue;
+class ParsePartitionClause;
 class ParsePredicate;
 class ParseSample;
 class ParseScalarLiteral;
diff --git a/parser/preprocessed/SqlLexer_gen.cpp b/parser/preprocessed/SqlLexer_gen.cpp
index d8c6382..454ed0f 100644
--- a/parser/preprocessed/SqlLexer_gen.cpp
+++ b/parser/preprocessed/SqlLexer_gen.cpp
@@ -381,8 +381,8 @@
 	*yy_cp = '\0'; \
 	yyg->yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 130
-#define YY_END_OF_BUFFER 131
+#define YY_NUM_RULES 135
+#define YY_END_OF_BUFFER 136
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -390,61 +390,64 @@
 	flex_int32_t yy_verify;
 	flex_int32_t yy_nxt;
 	};
-static yyconst flex_int16_t yy_accept[483] =
+static yyconst flex_int16_t yy_accept[504] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,  131,    2,    2,  129,  129,  128,  127,  129,
-      106,  102,  105,  102,  102,  125,   98,   95,   99,  124,
-      124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
-      124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
-      124,  124,  124,  103,    4,    5,    5,    3,  121,  121,
-      118,  122,  122,  116,  123,  123,  120,    1,  128,   96,
-      126,  125,  125,  125,    0,  100,   97,  101,  124,  124,
-      124,  124,   10,  124,  124,  124,   20,  124,  124,  124,
-      124,  124,  124,  124,  124,  124,  104,  124,  124,  124,
+        0,    0,  136,    2,    2,  134,  134,  133,  132,  134,
+      111,  107,  110,  107,  107,  130,  103,  100,  104,  129,
+      129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+      129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+      129,  129,  129,  108,    4,    5,    5,    3,  126,  126,
+      123,  127,  127,  121,  128,  128,  125,    1,  133,  101,
+      131,  130,  130,  130,    0,  105,  102,  106,  129,  129,
+      129,  129,   10,  129,  129,  129,   20,  129,  129,  129,
+      129,  129,  129,  129,  129,  129,  109,  129,  129,  129,
 
-      124,  124,  124,  124,  124,  124,  124,   55,  124,  124,
-      124,  124,  124,  124,  124,  124,  124,   67,   68,  124,
-      124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
-      124,  124,  124,  124,  124,  124,  124,  124,  124,    4,
-        5,    3,  121,  117,  122,  115,  115,  107,  109,  110,
-      111,  112,  113,  114,  115,  123,  119,  126,  125,    0,
-      125,    6,    7,  124,    9,   11,  124,  124,   15,  124,
-      124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
-      124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
-      124,  124,  124,  124,  124,  124,  124,   51,  124,   57,
+      129,  129,  129,  129,  129,  129,  129,  129,   57,  129,
+      129,  129,  129,  129,  129,  129,  129,  129,   69,   70,
+      129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+      129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+      129,  129,    4,    5,    3,  126,  122,  127,  120,  120,
+      112,  114,  115,  116,  117,  118,  119,  120,  128,  124,
+      131,  130,    0,  130,    6,    7,  129,    9,   11,  129,
+      129,   15,  129,  129,  129,  129,  129,  129,  129,  129,
+      129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+      129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
 
-      124,  124,  124,  124,  124,   63,  124,   66,  124,  124,
-      124,  124,  124,  124,  124,  124,  124,  124,  124,   80,
-      124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
-      124,  124,  124,  107,  109,  108,  124,  124,  124,  124,
-      124,  124,   21,  124,  124,  124,   26,  124,  124,   28,
-      124,  124,  124,  124,   34,  124,  124,   38,  124,  124,
-      124,  124,  124,   44,   45,  124,  124,  124,  124,  124,
-      124,   54,   56,   58,   59,   60,  124,   62,   64,  124,
-      124,  124,  124,   73,   74,  124,  124,  124,  124,  124,
-      124,  124,   83,   85,  124,  124,  124,  124,  124,  124,
+      129,  129,   53,  129,   59,  129,  129,  129,  129,  129,
+       65,  129,   68,  129,  129,  129,  129,  129,  129,  129,
+      129,  129,  129,  129,  129,  129,   85,  129,  129,  129,
+      129,  129,  129,  129,  129,  129,  129,  129,  129,  129,
+      112,  114,  113,  129,  129,  129,  129,  129,  129,   21,
+      129,  129,  129,   26,  129,  129,   28,  129,  129,  129,
+      129,   34,  129,  129,   38,  129,  129,  129,  129,  129,
+      129,   45,   46,  129,   48,  129,  129,  129,  129,  129,
+       56,   58,   60,   61,   62,  129,   64,   66,  129,  129,
+      129,  129,  129,   77,  129,   79,  129,  129,  129,  129,
 
-      124,   93,  124,  107,  108,    8,  124,  124,  124,  124,
-      124,  124,   23,  124,  124,  124,  124,  124,  124,  124,
-      124,  124,  124,  124,  124,  124,   40,   41,   42,  124,
-       46,  124,   48,   49,  124,  124,  124,   61,   65,   69,
-       70,  124,  124,  124,  124,   77,  124,  124,  124,   82,
-      124,  124,  124,  124,   89,  124,  124,   92,  124,  124,
-      124,   14,  124,  124,  124,  124,   24,  124,   27,  124,
-      124,  124,  124,   32,  124,  124,  124,   37,  124,  124,
-       47,   50,  124,  124,  124,  124,  124,   76,  124,   79,
-      124,  124,  124,   87,   88,   90,  124,  124,  124,   13,
+      129,  129,  129,   88,   90,  129,  129,  129,  129,  129,
+      129,  129,   98,  129,  112,  113,    8,  129,  129,  129,
+      129,  129,  129,   23,  129,  129,  129,  129,  129,  129,
+      129,  129,  129,  129,  129,  129,  129,  129,   41,   42,
+       43,  129,   47,  129,   50,   51,  129,  129,  129,   63,
+       67,   71,   72,  129,  129,  129,   78,  129,  129,   82,
+      129,  129,  129,   87,  129,  129,  129,  129,   94,  129,
+      129,   97,  129,  129,  129,   14,  129,  129,  129,  129,
+       24,  129,   27,  129,  129,  129,  129,   32,  129,  129,
+      129,   37,  129,  129,  129,   49,   52,  129,  129,  129,
 
-      124,  124,  124,  124,  124,   19,  124,   30,   31,  124,
-      124,  124,  124,   43,   52,  124,   71,   72,  124,  124,
-      124,  124,  124,   91,  124,  124,  124,  124,  124,  124,
-      124,   29,  124,  124,   36,  124,   53,  124,  124,   81,
-      124,  124,  124,   12,  124,  124,  124,   22,  124,   33,
-      124,  124,  124,  124,   84,  124,   94,  124,  124,  124,
-       25,   35,  124,   75,  124,  124,  124,   17,   18,  124,
-      124,   86,  124,  124,  124,  124,  124,   78,  124,   39,
-       16,    0
+      129,  129,  129,   81,  129,   84,  129,  129,  129,   92,
+       93,   95,  129,  129,  129,   13,  129,  129,  129,  129,
+      129,   19,  129,   30,   31,  129,  129,  129,  129,   40,
+       44,   54,  129,  129,   75,   76,  129,  129,  129,  129,
+      129,   96,  129,  129,  129,  129,  129,  129,  129,   29,
+      129,  129,   36,  129,   55,  129,  129,  129,   86,  129,
+      129,  129,   12,  129,  129,  129,   22,  129,   33,  129,
+      129,   73,  129,  129,   89,  129,   99,  129,  129,  129,
+       25,   35,  129,   74,   80,  129,  129,  129,   17,   18,
+      129,  129,   91,  129,  129,  129,  129,  129,   83,  129,
+
+       39,   16,    0
     } ;
 
 static yyconst YY_CHAR yy_ec[256] =
@@ -491,131 +494,135 @@
         8
     } ;
 
-static yyconst flex_uint16_t yy_base[498] =
+static yyconst flex_uint16_t yy_base[519] =
     {   0,
         0,    1,   46,    0,  117,  163,    2,    3,  128,  132,
-        6,   10,  198, 1090, 1090,    0, 1090,   13, 1090,  181,
-     1090, 1090, 1090,  183,    6,  130,    4, 1090,  142,  124,
-      161,  160,  204,  121,  251,   92,  112,  163,  114,  125,
-      209,    0,  173,  214,  169,  150,  221,  216,  253,  254,
-      182,  267,  191, 1090,  152,    4,   19,    0,    0,    0,
-      143,    0,    0,  319,    0,    0,  144,    0,   22, 1090,
-        0,  282,  289,  313,   18, 1090, 1090, 1090,    0,  194,
-      270,  263,  285,  273,  306,  297,    0,  319,  315,  323,
-      328,  312,  332,  315,  315,  325, 1090,  342,  334,  330,
+        6,   10,  198, 1136, 1136,    0, 1136,   13, 1136,  181,
+     1136, 1136, 1136,  183,    6,  130,    4, 1136,  172,  124,
+      161,  160,  204,  150,  251,   92,  110,  163,   98,  124,
+      209,    0,  173,  214,  182,  109,  253,  231,  258,  261,
+      195,  218,  196, 1136,  152,    4,   19,    0,    0,    0,
+      143,    0,    0,  323,    0,    0,  144,    0,   22, 1136,
+        0,  289,  316,  319,   18, 1136, 1136, 1136,    0,  217,
+      258,  241,  268,  273,  296,  287,    0,  325,  322,  312,
+      318,  307,  345,  314,  318,  325, 1136,  339,  324,  340,
 
-      337,  352,  356,  364,  363,  357,  378,    0,  374,  359,
-      366,  380,  376,  374,  370,  379,  387,    0,  390,  375,
-      378,  392,  393,  403,  396,  383,  416,  428,  432,  424,
-      419,  425,  433,  439,  435,  433,  441,  427,  447,  142,
-       29,    0,    0, 1090,    0, 1090, 1090,   22,   24, 1090,
-     1090, 1090, 1090, 1090,    0,    0, 1090,    0,  454,   26,
-       28,    0,    0,  447,    0,  448,  431,  446,    0,  453,
-      442,  458,  441,  445,  442,  477,  459,  481,  478,  491,
-      489,  492,  479,  498,  485,  501,  484,  485,  504,  501,
-      496,  498,  490,  503,  508,  509,  512,  521,  504,    0,
+      342,  346,  356,  360,  366,  364,  363,  380,    0,  374,
+      362,  369,  385,  384,  378,  376,  386,  395,    0,  398,
+      385,  388,  391,  401,  406,  404,  435,  412,  399,  420,
+      432,  435,  430,  424,  430,  440,  446,  443,  441,  449,
+      435,  455,  142,   29,    0,    0, 1136,    0, 1136, 1136,
+       22,   24, 1136, 1136, 1136, 1136, 1136,    0,    0, 1136,
+        0,  462,   26,   28,    0,    0,  455,    0,  458,  441,
+      459,    0,  483,  455,  473,  456,  461,  462,  489,  471,
+      489,  486,  498,  495,  498,  483,  505,  492,  509,  493,
+      493,  494,  513,  512,  505,  509,  501,  517,  517,  526,
 
-      499,  500,  517,  516,  530,    0,  532,    0,  540,  545,
-      549,  540,  536,  545,  553,  554,  552,   93,  556,    0,
-      550,  551,  559,  562,  556,  552,  569,  557,  551,  572,
-      558,  569,  560,   30,  125,    0,  562,  569,  579,  580,
-      584,  589,  602,  597,  597,  591,    0,  594,  597,  596,
-      604,  597,  599,  607,  616,  613,  613,    0,  610,  622,
-      608,  609,  621,    0,    0,  617,  620,  611,  618,  620,
-      634,    0,    0,    0,    0,    0,  622,    0,  634,  642,
-      643,  661,  667,    0,    0,  651,  648,  653,  670,  672,
-      664,  672,  659,    0,  674,  659,  663,  677,  680,  678,
+      529,  530,  533,  530,    0,  525,  529,  547,  544,  549,
+        0,  545,    0,  553,  554,  541,  559,  552,  546,  561,
+      557,  565,  566,  564,   93,  570,    0,  564,  567,  575,
+      578,  572,  572,  591,  579,  575,  599,  585,  598,  589,
+       30,  125,    0,  592,  597,  609,  601,  605,  604,  618,
+      609,  610,  604,    0,  606,  609,  608,  616,  609,  613,
+      621,  632,  629,  629,    0,  626,  646,  645,  631,  634,
+      651,    0,    0,  645,    0,  650,  641,  650,  651,  666,
+        0,    0,    0,    0,    0,  652,    0,  655,  657,  659,
+      669,  676,  681,    0,  680,    0,  668,  663,  668,  687,
 
-      682,    0,  675,  136, 1090,    0,  687,  687,  673,  680,
-      688,  697,    0,  696,  693,  713,  714,  715,  725,  715,
-      725,  722,  718,  719,  729,  730,    0,    0,    0,  729,
-        0,  730,    0,    0,  718,  736,  720,    0,    0,    0,
-        0,  729,  726,  740,  730,    0,  744,  730,  742,    0,
-      732,  735,  752,  753,    0,  749,  768,    0,  761,  768,
-      768,    0,  766,  784,  779,  769,    0,  789,    0,  786,
-      779,  781,  774,    0,  775,  792,  796,    0,   82,  786,
-        0,    0,  783,  801,  783,  779,  793,    0,  796,    0,
-      795,  809,  811,    0,    0,    0,  797,  802,  812,    0,
+      689,  683,  691,  680,    0,  695,  684,  688,  702,  707,
+      710,  714,    0,  709,  136, 1136,    0,  719,  721,  707,
+      714,  725,  729,    0,  721,  718,  734,  735,  733,  742,
+      732,  740,  737,  735,  736,  748,  749,  754,    0,    0,
+        0,  751,    0,  756,    0,    0,  746,  762,  748,    0,
+        0,    0,    0,  756,  763,  762,    0,  776,  768,    0,
+      780,  768,  780,    0,  770,  772,  788,  789,    0,  778,
+      797,    0,  785,  792,  788,    0,  785,  803,  798,  788,
+        0,  810,    0,  807,  802,  804,  801,    0,  804,  821,
+      825,    0,   83,  814,  821,    0,    0,  820,  838,  833,
 
-      812,  821,  823,  835,  833,    0,  838,    0,    0,  841,
-      838,  828,  830,    0,    0,  838,    0,    0,  848,  843,
-      833,  841,  844,    0,  838,  852,  844,  845,  842,  847,
-      852,    0,  849,  854,    0,  850,    0,  868,  861,    0,
-      868,  869,  884,    0,  888,  886,  895,    0,  881,    0,
-      897,  887,  887,  898,    0,  896,    0,  891,  905,  893,
-        0,    0,  903,    0,  895,  911,  897,    0,    0,  904,
-      914,    0,  911,  916,  906,  920,  907,    0,  909,    0,
-        0, 1090,  974,  984,  994, 1004, 1014, 1018, 1021, 1027,
-     1035, 1045, 1055, 1065, 1075, 1080, 1082
+      823,  821,  833,    0,  836,    0,  835,  850,  851,    0,
+        0,    0,  837,  842,  844,    0,  844,  847,  849,  857,
+      856,    0,  861,    0,    0,  864,  861,  853,  855,    0,
+        0,    0,  867,  867,    0,    0,  880,  877,  872,  880,
+      883,    0,  877,  893,  885,  888,  885,  888,  893,    0,
+      891,  896,    0,  893,    0,  900,  911,  904,    0,  902,
+      903,  912,    0,  918,  912,  922,    0,  908,    0,  924,
+      914,  918,  921,  932,    0,  932,    0,  932,  946,  936,
+        0,    0,  946,    0,    0,  938,  954,  942,    0,    0,
+      949,  959,    0,  956,  960,  950,  966,  953,    0,  955,
 
+        0,    0, 1136, 1020, 1030, 1040, 1050, 1060, 1064, 1067,
+     1073, 1081, 1091, 1101, 1111, 1121, 1126, 1128
     } ;
 
-static yyconst flex_int16_t yy_def[498] =
+static yyconst flex_int16_t yy_def[519] =
     {   0,
-      483,  483,  482,    3,  484,  484,  485,  485,  486,  486,
-      487,  487,  482,  482,  482,  488,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  482,  482,  482,  482,  490,  491,  491,
-      482,  492,  492,  493,  494,  494,  482,  488,  482,  482,
-      495,  482,  482,  482,  482,  482,  482,  482,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  482,  489,  489,  489,
+      504,  504,  503,    3,  505,  505,  506,  506,  507,  507,
+      508,  508,  503,  503,  503,  509,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  503,  503,  503,  503,  511,  512,  512,
+      503,  513,  513,  514,  515,  515,  503,  509,  503,  503,
+      516,  503,  503,  503,  503,  503,  503,  503,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  503,  510,  510,  510,
 
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  482,
-      482,  490,  491,  482,  492,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  496,  494,  482,  495,  482,  482,
-      482,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  503,  503,  511,  512,  503,  513,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  517,  515,  503,
+      516,  503,  503,  503,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
 
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  482,  482,  497,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      503,  503,  518,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
 
-      489,  489,  489,  482,  482,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  503,  503,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
 
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,  489,  489,  489,  489,  489,  489,  489,  489,  489,
-      489,    0,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+      510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
 
+      510,  510,    0,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503
     } ;
 
-static yyconst flex_uint16_t yy_nxt[1162] =
+static yyconst flex_uint16_t yy_nxt[1208] =
     {   0,
-      482,  482,   15,   15,   60,   60,  141,  141,   66,   61,
-       61,   67,   66,  482,   69,   67,   69,   72,   72,   76,
-       77,  141,  141,   69,  482,   69,  160,  160,  482,  161,
-      161,  141,  141,  234,  235,  235,  235,  161,  161,  161,
-      161,  304,  235,  482,   16,   16,   17,   18,   19,   18,
+      503,  503,   15,   15,   60,   60,  144,  144,   66,   61,
+       61,   67,   66,  503,   69,   67,   69,   72,   72,   76,
+       77,  144,  144,   69,  503,   69,  163,  163,  503,  164,
+      164,  144,  144,  241,  242,  242,  242,  164,  164,  164,
+      164,  315,  242,  503,   16,   16,   17,   18,   19,   18,
        20,   21,   22,   23,   22,   24,   25,   26,   26,   17,
        27,   28,   29,   30,   31,   32,   33,   34,   35,   36,
        37,   38,   39,   40,   41,   42,   43,   44,   45,   46,
@@ -624,130 +631,135 @@
 
        38,   39,   40,   41,   42,   43,   44,   45,   46,   47,
        48,   49,   50,   51,   52,   42,   53,   17,   55,   56,
-       57,   17,   17,   17,   17,   17,  105,  413,   97,  106,
-       63,   17,   17,   17,   63,   61,  235,  235,  289,   61,
-       73,   74,   74,  140,   80,  109,  110,  235,  235,  157,
-      144,   75,   81,  140,   82,  105,   98,   78,  106,   83,
+       57,   17,   17,   17,   17,   17,  106,  107,  429,  110,
+       63,   17,   17,   17,   63,   61,  242,  242,  300,   61,
+       73,   74,   74,  143,   80,  111,  125,  242,  242,  160,
+      147,   75,   81,  143,   82,  106,  107,   97,  110,   83,
        17,   17,   17,   17,   55,   56,   57,   17,   17,   17,
-       17,   17,   64,   80,  109,  110,   64,   17,   17,   17,
-       75,   81,   84,   82,   88,   98,   85,  123,   83,   86,
-      121,   89,   71,  107,   90,   91,   70,  482,  108,  136,
+       17,   17,   64,   80,  111,  125,   64,   17,   17,   17,
+       75,   81,   84,   82,   88,   98,   85,   78,   83,   86,
+       99,   89,   71,  108,   90,   91,   70,  503,  109,  122,
 
-      482,  482,   87,  122,  115,  482,   17,   17,   17,  482,
-      116,   84,  139,   88,  162,   85,  123,  482,   86,  121,
-       89,   92,  107,   90,   91,   93,  111,  108,  136,   94,
-      112,   87,  122,  115,  113,   95,  117,  127,   96,  116,
-      114,  139,  124,  162,  118,  128,  125,  482,  119,  482,
-       92,  120,  126,  482,   93,  111,  482,  482,   94,  112,
-      482,  482,  482,  113,   95,  117,  127,   96,   99,  114,
-      129,  124,  482,  118,  128,  125,  100,  119,  130,  101,
-      120,  126,  102,  165,  133,  103,  134,  131,  104,  135,
-      132,  137,  138,   72,   72,  482,  482,   99,  163,  129,
+      503,  503,   87,  123,  116,  503,   17,   17,   17,  503,
+      117,   84,  139,   88,   98,   85,  124,  142,   86,   99,
+       89,   92,  108,   90,   91,   93,  112,  109,  122,   94,
+      113,   87,  123,  116,  114,   95,  118,  165,   96,  117,
+      115,  139,  140,  141,  119,  124,  142,  503,  120,  503,
+       92,  121,  130,  503,   93,  112,  503,  503,   94,  113,
+      131,  168,  503,  114,   95,  118,  165,   96,  100,  115,
+      126,  140,  141,  119,  127,  132,  101,  120,  128,  102,
+      121,  130,  103,  133,  129,  104,  166,  169,  105,  131,
+      168,  136,  134,  137,  167,  135,  138,  100,  503,  126,
 
-      159,  159,  482,   75,  166,  100,  164,  130,  101,  167,
-       75,  102,  165,  133,  103,  134,  131,  104,  135,  132,
-      137,  138,  147,   73,   74,   74,  482,  163,  170,  168,
-      148,  149,   75,  166,   75,  164,  171,  150,  167,   75,
-      172,  151,  169,  173,  176,  174,  177,  175,  178,  152,
-      183,  179,  184,  153,  180,  154,  185,  170,  168,  155,
-      181,  186,  187,   75,  188,  171,  150,  182,  189,  172,
-      151,  169,  173,  176,  174,  177,  175,  178,  152,  183,
-      179,  184,  153,  180,  154,  185,  190,  191,  155,  181,
-      186,  187,  192,  188,  193,  194,  182,  189,  195,  199,
+       72,   72,  503,  127,  132,  101,  503,  128,  102,  170,
+       75,  103,  133,  129,  104,  166,  169,  105,  173,  171,
+      136,  134,  137,  167,  135,  138,  150,  162,  162,   73,
+       74,   74,  172,  179,  151,  152,  180,   75,  170,   75,
+       75,  153,  174,  181,  503,  154,  175,  173,  171,  186,
+      176,  503,  177,  155,  178,  187,  188,  156,  189,  157,
+      190,  172,  179,  158,  182,  180,   75,  183,  191,   75,
+      153,  174,  181,  184,  154,  175,  192,  193,  186,  176,
+      185,  177,  155,  178,  187,  188,  156,  189,  157,  190,
+      194,  195,  158,  182,  196,  197,  183,  191,  198,  204,
 
-      200,  201,  202,  203,  205,  204,  206,  207,  196,  208,
-      209,  210,  211,  197,  198,  190,  191,  212,  213,  217,
-      214,  192,  218,  193,  194,  215,  216,  195,  199,  200,
-      201,  202,  203,  205,  204,  206,  207,  196,  208,  209,
-      210,  211,  197,  198,  219,  221,  212,  213,  217,  214,
-      222,  218,  220,  223,  215,  216,  224,  225,  226,  227,
-      228,  229,  231,  232,  233,  159,  159,  230,  237,  238,
-      239,  240,  241,  219,  221,   75,  243,  244,  245,  222,
-      246,  220,  223,  247,  242,  224,  225,  226,  227,  228,
-      229,  231,  232,  233,  248,  249,  230,  237,  238,  239,
+      200,  199,  184,  205,  206,  192,  193,  207,  210,  185,
+      201,  208,  211,  209,  212,  202,  203,  213,  214,  194,
+      195,  215,  216,  196,  197,  217,  218,  198,  204,  200,
+      199,  219,  205,  206,  220,  224,  207,  210,  225,  201,
+      208,  211,  209,  212,  202,  203,  213,  214,  226,  228,
+      215,  216,  221,  229,  217,  218,  227,  222,  223,  230,
+      219,  231,  232,  220,  224,  233,  234,  225,  235,  236,
+      238,  239,  240,  162,  162,  237,  244,  226,  228,  245,
+      246,  221,  229,   75,  247,  227,  222,  223,  230,  250,
+      231,  232,  251,  252,  233,  234,  253,  235,  236,  238,
 
-      240,  241,  250,  251,   75,  243,  244,  245,  252,  246,
-      253,  255,  247,  242,  254,  256,  257,  258,  259,  260,
-      261,  262,  263,  248,  249,  264,  265,  266,  267,  268,
-      269,  250,  251,  270,  273,  274,  275,  252,  276,  253,
-      255,  277,  271,  254,  256,  257,  258,  259,  260,  261,
-      262,  263,  272,  278,  264,  265,  266,  267,  268,  269,
-      279,  280,  270,  273,  274,  275,  281,  276,  282,  283,
-      277,  271,  284,  285,  286,  287,  288,  290,  291,  292,
-      293,  272,  278,  294,  295,  296,  297,  298,  299,  279,
-      280,  300,  301,  302,  303,  281,  306,  282,  283,  307,
+      239,  240,  248,  254,  237,  244,  255,  256,  245,  246,
+      257,  258,   75,  247,  249,  259,  260,  262,  250,  263,
+      261,  251,  252,  264,  265,  253,  266,  267,  268,  269,
+      270,  248,  254,  271,  272,  255,  256,  273,  274,  257,
+      258,  275,  276,  249,  259,  260,  262,  277,  263,  261,
+      278,  279,  264,  265,  280,  266,  267,  268,  269,  270,
+      282,  283,  271,  272,  281,  284,  273,  274,  285,  286,
+      275,  276,  287,  288,  289,  290,  277,  291,  292,  278,
+      279,  293,  294,  280,  295,  296,  297,  298,  299,  282,
+      283,  301,  302,  281,  284,  303,  304,  285,  286,  305,
 
-      308,  284,  285,  286,  287,  288,  290,  291,  292,  293,
-      309,  310,  294,  295,  296,  297,  298,  299,  311,  312,
-      300,  301,  302,  303,  313,  306,  314,  315,  307,  308,
-      316,  317,  318,  319,  320,  321,  322,  323,  324,  309,
-      310,  325,  326,  327,  328,  329,  330,  311,  312,  331,
-      332,  333,  334,  313,  335,  314,  315,  336,  338,  316,
-      317,  318,  319,  320,  321,  322,  323,  324,  337,  339,
-      325,  326,  327,  328,  329,  330,  340,  341,  331,  332,
-      333,  334,  342,  335,  343,  344,  336,  338,  345,  346,
-      347,  348,  349,  350,  351,  352,  353,  337,  339,  354,
+      306,  287,  288,  289,  290,  307,  291,  292,  308,  309,
+      293,  294,  310,  295,  296,  297,  298,  299,  311,  312,
+      301,  302,  313,  314,  303,  304,  317,  318,  305,  306,
+      319,  320,  321,  322,  307,  323,  324,  308,  309,  325,
+      326,  310,  327,  328,  329,  330,  331,  311,  312,  332,
+      333,  313,  314,  334,  335,  317,  318,  336,  337,  319,
+      320,  321,  322,  338,  323,  324,  339,  340,  325,  326,
+      341,  327,  328,  329,  330,  331,  342,  343,  332,  333,
+      344,  345,  334,  335,  346,  347,  336,  337,  350,  348,
+      351,  352,  338,  353,  354,  339,  340,  355,  356,  341,
 
-      355,  356,  357,  358,  359,  340,  341,  360,  361,  362,
-      365,  342,  363,  343,  344,  364,  366,  345,  346,  347,
-      348,  349,  350,  351,  352,  353,  367,  368,  354,  355,
-      356,  357,  358,  359,  369,  370,  360,  361,  362,  365,
-      371,  363,  372,  373,  364,  366,  374,  375,  376,  377,
-      378,  379,  380,  381,  382,  367,  368,  383,  384,  385,
-      386,  387,  388,  369,  370,  389,  390,  391,  392,  371,
-      393,  372,  373,  394,  395,  374,  375,  376,  377,  378,
-      379,  380,  381,  382,  396,  397,  383,  384,  385,  386,
-      387,  388,  398,  399,  389,  390,  391,  392,  400,  393,
+      349,  357,  358,  359,  360,  342,  343,  361,  362,  344,
+      345,  363,  364,  346,  347,  365,  366,  350,  348,  351,
+      352,  367,  353,  354,  368,  369,  355,  356,  370,  349,
+      357,  358,  359,  360,  371,  372,  361,  362,  373,  374,
+      363,  364,  375,  376,  365,  366,  377,  379,  380,  378,
+      367,  381,  382,  368,  369,  383,  384,  370,  385,  386,
+      387,  388,  389,  371,  372,  390,  391,  373,  374,  392,
+      393,  375,  376,  394,  395,  377,  379,  380,  378,  396,
+      381,  382,  397,  398,  383,  384,  399,  385,  386,  387,
+      388,  389,  400,  401,  390,  391,  402,  403,  392,  393,
 
-      401,  402,  394,  395,  403,  404,  405,  406,  407,  408,
-      409,  410,  411,  396,  397,  412,  414,  415,  416,  417,
-      418,  398,  399,  419,  420,  421,  422,  400,  423,  401,
-      402,  424,  425,  403,  404,  405,  406,  407,  408,  409,
-      410,  411,  426,  427,  412,  414,  415,  416,  417,  418,
-      428,  429,  419,  420,  421,  422,  430,  423,  431,  432,
-      424,  425,  433,  434,  435,  436,  437,  438,  439,  440,
-      441,  426,  427,  442,  443,  444,  445,  446,  447,  428,
-      429,  448,  449,  450,  451,  430,  452,  431,  432,  453,
-      454,  433,  434,  435,  436,  437,  438,  439,  440,  441,
+      404,  405,  394,  395,  406,  407,  408,  409,  396,  410,
+      411,  397,  398,  412,  413,  399,  414,  415,  416,  417,
+      418,  400,  401,  419,  420,  402,  403,  421,  422,  404,
+      405,  423,  424,  406,  407,  408,  409,  425,  410,  411,
+      426,  427,  412,  413,  428,  414,  415,  416,  417,  418,
+      430,  431,  419,  420,  432,  433,  421,  422,  434,  435,
+      423,  424,  436,  437,  438,  439,  425,  440,  441,  426,
+      427,  442,  443,  428,  444,  445,  446,  447,  448,  430,
+      431,  449,  450,  432,  433,  451,  452,  434,  435,  453,
+      454,  436,  437,  438,  439,  455,  440,  441,  456,  457,
 
-      455,  456,  442,  443,  444,  445,  446,  447,  457,  458,
-      448,  449,  450,  451,  459,  452,  460,  461,  453,  454,
-      462,  463,  464,  465,  466,  467,  468,  469,  470,  455,
-      456,  471,  472,  473,  474,  475,  476,  457,  458,  477,
-      478,  479,  480,  459,  481,  460,  461,  482,  482,  462,
-      463,  464,  465,  466,  467,  468,  469,  470,  482,  482,
-      471,  472,  473,  474,  475,  476,  482,  482,  477,  478,
-      479,  480,  482,  481,   14,   14,   14,   14,   14,   14,
-       14,   14,   14,   14,   58,   58,   58,   58,   58,   58,
-       58,   58,   58,   58,   59,   59,   59,   59,   59,   59,
+      442,  443,  458,  444,  445,  446,  447,  448,  459,  460,
+      449,  450,  461,  462,  451,  452,  463,  464,  453,  454,
+      465,  466,  467,  468,  455,  469,  470,  456,  457,  471,
+      472,  458,  473,  474,  475,  476,  477,  459,  460,  478,
+      479,  461,  462,  480,  481,  463,  464,  482,  483,  465,
+      466,  467,  468,  484,  469,  470,  485,  486,  471,  472,
+      487,  473,  474,  475,  476,  477,  488,  489,  478,  479,
+      490,  491,  480,  481,  492,  493,  482,  483,  494,  495,
+      496,  497,  484,  498,  499,  485,  486,  500,  501,  487,
+      502,  503,  503,  503,  503,  488,  489,  503,  503,  490,
 
-       59,   59,   59,   59,   62,   62,   62,   62,   62,   62,
-       62,   62,   62,   62,   65,   65,   65,   65,   65,   65,
-       65,   65,   65,   65,   68,   68,   79,   79,   79,  482,
-       79,  142,  142,  142,  142,  143,  143,  143,  482,  143,
-      143,  143,  143,  143,  143,  145,  145,  145,  482,  145,
-      145,  145,  145,  482,  145,  146,  146,  146,  146,  146,
-      146,  146,  146,  146,  146,  156,  156,  482,  156,  156,
-      156,  156,  156,  156,  156,  158,  482,  158,  158,  158,
-      158,  158,  158,  158,  158,  236,  236,  305,  305,   13,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
+      491,  503,  503,  492,  493,  503,  503,  494,  495,  496,
+      497,  503,  498,  499,  503,  503,  500,  501,  503,  502,
+       14,   14,   14,   14,   14,   14,   14,   14,   14,   14,
+       58,   58,   58,   58,   58,   58,   58,   58,   58,   58,
+       59,   59,   59,   59,   59,   59,   59,   59,   59,   59,
+       62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
+       65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
+       68,   68,   79,   79,   79,  503,   79,  145,  145,  145,
+      145,  146,  146,  146,  503,  146,  146,  146,  146,  146,
+      146,  148,  148,  148,  503,  148,  148,  148,  148,  503,
 
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482
+      148,  149,  149,  149,  149,  149,  149,  149,  149,  149,
+      149,  159,  159,  503,  159,  159,  159,  159,  159,  159,
+      159,  161,  503,  161,  161,  161,  161,  161,  161,  161,
+      161,  243,  243,  316,  316,   13,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+
+      503,  503,  503,  503,  503,  503,  503
     } ;
 
-static yyconst flex_int16_t yy_chk[1162] =
+static yyconst flex_int16_t yy_chk[1208] =
     {   0,
         0,    0,    1,    2,    7,    8,   56,   56,   11,    7,
         8,   11,   12,    0,   18,   12,   18,   25,   25,   27,
        27,   57,   57,   69,    0,   69,   75,   75,    0,   75,
-       75,  141,  141,  148,  148,  149,  149,  160,  160,  161,
-      161,  234,  234,    0,    1,    2,    3,    3,    3,    3,
+       75,  144,  144,  151,  151,  152,  152,  163,  163,  164,
+      164,  241,  241,    0,    1,    2,    3,    3,    3,    3,
         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
@@ -756,133 +768,138 @@
 
         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
         3,    3,    3,    3,    3,    3,    3,    5,    5,    5,
-        5,    5,    5,    5,    5,    5,   36,  379,   34,   37,
-        9,    5,    5,    5,   10,    9,  235,  235,  218,   10,
-       26,   26,   26,  140,   30,   39,   40,  304,  304,   67,
-       61,   26,   30,   55,   30,   36,   34,   29,   37,   30,
+        5,    5,    5,    5,    5,    5,   36,   37,  393,   39,
+        9,    5,    5,    5,   10,    9,  242,  242,  225,   10,
+       26,   26,   26,  143,   30,   40,   46,  315,  315,   67,
+       61,   26,   30,   55,   30,   36,   37,   34,   39,   30,
         5,    5,    5,    6,    6,    6,    6,    6,    6,    6,
-        6,    6,    9,   30,   39,   40,   10,    6,    6,    6,
-       26,   30,   31,   30,   32,   34,   31,   46,   30,   31,
-       45,   32,   24,   38,   32,   32,   20,   13,   38,   51,
+        6,    6,    9,   30,   40,   46,   10,    6,    6,    6,
+       26,   30,   31,   30,   32,   34,   31,   29,   30,   31,
+       34,   32,   24,   38,   32,   32,   20,   13,   38,   45,
 
         0,    0,   31,   45,   43,    0,    6,    6,    6,    0,
-       43,   31,   53,   32,   80,   31,   46,    0,   31,   45,
-       32,   33,   38,   32,   32,   33,   41,   38,   51,   33,
-       41,   31,   45,   43,   41,   33,   44,   48,   33,   43,
-       41,   53,   47,   80,   44,   48,   47,    0,   44,    0,
-       33,   44,   47,    0,   33,   41,    0,    0,   33,   41,
-        0,    0,    0,   41,   33,   44,   48,   33,   35,   41,
-       49,   47,    0,   44,   48,   47,   35,   44,   49,   35,
-       44,   47,   35,   82,   50,   35,   50,   49,   35,   50,
-       49,   52,   52,   72,   72,    0,    0,   35,   81,   49,
+       43,   31,   51,   32,   34,   31,   45,   53,   31,   34,
+       32,   33,   38,   32,   32,   33,   41,   38,   45,   33,
+       41,   31,   45,   43,   41,   33,   44,   80,   33,   43,
+       41,   51,   52,   52,   44,   45,   53,    0,   44,    0,
+       33,   44,   48,    0,   33,   41,    0,    0,   33,   41,
+       48,   82,    0,   41,   33,   44,   80,   33,   35,   41,
+       47,   52,   52,   44,   47,   49,   35,   44,   47,   35,
+       44,   48,   35,   49,   47,   35,   81,   83,   35,   48,
+       82,   50,   49,   50,   81,   49,   50,   35,    0,   47,
 
-       73,   73,    0,   72,   83,   35,   81,   49,   35,   84,
-       73,   35,   82,   50,   35,   50,   49,   35,   50,   49,
-       52,   52,   64,   74,   74,   74,    0,   81,   86,   85,
-       64,   64,   72,   83,   74,   81,   88,   64,   84,   73,
-       88,   64,   85,   89,   90,   89,   91,   89,   92,   64,
-       94,   93,   95,   64,   93,   64,   96,   86,   85,   64,
-       93,   98,   99,   74,  100,   88,   64,   93,  101,   88,
-       64,   85,   89,   90,   89,   91,   89,   92,   64,   94,
-       93,   95,   64,   93,   64,   96,  102,  103,   64,   93,
-       98,   99,  104,  100,  105,  106,   93,  101,  107,  109,
+       72,   72,    0,   47,   49,   35,    0,   47,   35,   84,
+       72,   35,   49,   47,   35,   81,   83,   35,   86,   85,
+       50,   49,   50,   81,   49,   50,   64,   73,   73,   74,
+       74,   74,   85,   90,   64,   64,   91,   73,   84,   72,
+       74,   64,   88,   92,    0,   64,   88,   86,   85,   94,
+       89,    0,   89,   64,   89,   95,   96,   64,   98,   64,
+       99,   85,   90,   64,   93,   91,   73,   93,  100,   74,
+       64,   88,   92,   93,   64,   88,  101,  102,   94,   89,
+       93,   89,   64,   89,   95,   96,   64,   98,   64,   99,
+      103,  104,   64,   93,  105,  106,   93,  100,  107,  110,
 
-      110,  111,  112,  113,  114,  113,  115,  116,  107,  117,
-      119,  120,  121,  107,  107,  102,  103,  122,  123,  125,
-      124,  104,  126,  105,  106,  124,  124,  107,  109,  110,
-      111,  112,  113,  114,  113,  115,  116,  107,  117,  119,
-      120,  121,  107,  107,  127,  128,  122,  123,  125,  124,
-      129,  126,  127,  130,  124,  124,  131,  132,  133,  134,
-      135,  136,  137,  138,  139,  159,  159,  136,  164,  166,
-      167,  168,  170,  127,  128,  159,  171,  172,  173,  129,
-      174,  127,  130,  175,  170,  131,  132,  133,  134,  135,
-      136,  137,  138,  139,  176,  177,  136,  164,  166,  167,
+      108,  107,   93,  111,  112,  101,  102,  113,  115,   93,
+      108,  114,  116,  114,  117,  108,  108,  118,  120,  103,
+      104,  121,  122,  105,  106,  123,  124,  107,  110,  108,
+      107,  125,  111,  112,  126,  128,  113,  115,  129,  108,
+      114,  116,  114,  117,  108,  108,  118,  120,  130,  131,
+      121,  122,  127,  132,  123,  124,  130,  127,  127,  133,
+      125,  134,  135,  126,  128,  136,  137,  129,  138,  139,
+      140,  141,  142,  162,  162,  139,  167,  130,  131,  169,
+      170,  127,  132,  162,  171,  130,  127,  127,  133,  174,
+      134,  135,  175,  176,  136,  137,  177,  138,  139,  140,
 
-      168,  170,  178,  179,  159,  171,  172,  173,  180,  174,
-      181,  182,  175,  170,  181,  183,  184,  185,  186,  187,
-      188,  189,  190,  176,  177,  191,  192,  193,  194,  195,
-      196,  178,  179,  197,  199,  201,  202,  180,  203,  181,
-      182,  204,  198,  181,  183,  184,  185,  186,  187,  188,
-      189,  190,  198,  205,  191,  192,  193,  194,  195,  196,
-      207,  209,  197,  199,  201,  202,  210,  203,  211,  212,
-      204,  198,  213,  214,  215,  216,  217,  219,  221,  222,
-      223,  198,  205,  224,  225,  226,  227,  228,  229,  207,
-      209,  230,  231,  232,  233,  210,  237,  211,  212,  238,
+      141,  142,  173,  178,  139,  167,  179,  180,  169,  170,
+      181,  182,  162,  171,  173,  183,  184,  185,  174,  186,
+      184,  175,  176,  187,  188,  177,  189,  190,  191,  192,
+      193,  173,  178,  194,  195,  179,  180,  196,  197,  181,
+      182,  198,  199,  173,  183,  184,  185,  200,  186,  184,
+      201,  202,  187,  188,  203,  189,  190,  191,  192,  193,
+      204,  206,  194,  195,  203,  207,  196,  197,  208,  209,
+      198,  199,  210,  212,  214,  215,  200,  216,  217,  201,
+      202,  218,  219,  203,  220,  221,  222,  223,  224,  204,
+      206,  226,  228,  203,  207,  229,  230,  208,  209,  231,
 
-      239,  213,  214,  215,  216,  217,  219,  221,  222,  223,
-      240,  241,  224,  225,  226,  227,  228,  229,  242,  243,
-      230,  231,  232,  233,  244,  237,  245,  246,  238,  239,
-      248,  249,  250,  251,  252,  253,  254,  255,  256,  240,
-      241,  257,  259,  260,  261,  262,  263,  242,  243,  266,
-      267,  268,  269,  244,  270,  245,  246,  271,  277,  248,
-      249,  250,  251,  252,  253,  254,  255,  256,  271,  279,
-      257,  259,  260,  261,  262,  263,  280,  281,  266,  267,
-      268,  269,  282,  270,  283,  286,  271,  277,  287,  288,
-      289,  290,  291,  292,  293,  295,  296,  271,  279,  297,
+      232,  210,  212,  214,  215,  233,  216,  217,  234,  235,
+      218,  219,  236,  220,  221,  222,  223,  224,  237,  238,
+      226,  228,  239,  240,  229,  230,  244,  245,  231,  232,
+      246,  247,  248,  249,  233,  250,  251,  234,  235,  252,
+      253,  236,  255,  256,  257,  258,  259,  237,  238,  260,
+      261,  239,  240,  262,  263,  244,  245,  264,  266,  246,
+      247,  248,  249,  267,  250,  251,  268,  269,  252,  253,
+      270,  255,  256,  257,  258,  259,  271,  274,  260,  261,
+      276,  277,  262,  263,  278,  279,  264,  266,  286,  280,
+      288,  289,  267,  290,  291,  268,  269,  292,  293,  270,
 
-      298,  299,  300,  301,  303,  280,  281,  307,  308,  309,
-      311,  282,  310,  283,  286,  310,  312,  287,  288,  289,
-      290,  291,  292,  293,  295,  296,  314,  315,  297,  298,
-      299,  300,  301,  303,  316,  317,  307,  308,  309,  311,
-      318,  310,  319,  320,  310,  312,  321,  322,  323,  324,
-      325,  326,  330,  332,  335,  314,  315,  336,  337,  342,
-      343,  344,  345,  316,  317,  347,  348,  349,  351,  318,
-      352,  319,  320,  353,  354,  321,  322,  323,  324,  325,
-      326,  330,  332,  335,  356,  357,  336,  337,  342,  343,
-      344,  345,  359,  360,  347,  348,  349,  351,  361,  352,
+      280,  295,  297,  298,  299,  271,  274,  300,  301,  276,
+      277,  302,  303,  278,  279,  304,  306,  286,  280,  288,
+      289,  307,  290,  291,  308,  309,  292,  293,  310,  280,
+      295,  297,  298,  299,  311,  312,  300,  301,  314,  318,
+      302,  303,  319,  320,  304,  306,  321,  322,  323,  321,
+      307,  325,  326,  308,  309,  327,  328,  310,  329,  330,
+      331,  332,  333,  311,  312,  334,  335,  314,  318,  336,
+      337,  319,  320,  338,  342,  321,  322,  323,  321,  344,
+      325,  326,  347,  348,  327,  328,  349,  329,  330,  331,
+      332,  333,  354,  355,  334,  335,  356,  358,  336,  337,
 
-      363,  364,  353,  354,  365,  366,  368,  370,  371,  372,
-      373,  375,  376,  356,  357,  377,  380,  383,  384,  385,
-      386,  359,  360,  387,  389,  391,  392,  361,  393,  363,
-      364,  397,  398,  365,  366,  368,  370,  371,  372,  373,
-      375,  376,  399,  401,  377,  380,  383,  384,  385,  386,
-      402,  403,  387,  389,  391,  392,  404,  393,  405,  407,
-      397,  398,  410,  411,  412,  413,  416,  419,  420,  421,
-      422,  399,  401,  423,  425,  426,  427,  428,  429,  402,
-      403,  430,  431,  433,  434,  404,  436,  405,  407,  438,
-      439,  410,  411,  412,  413,  416,  419,  420,  421,  422,
+      359,  361,  338,  342,  362,  363,  365,  366,  344,  367,
+      368,  347,  348,  370,  371,  349,  373,  374,  375,  377,
+      378,  354,  355,  379,  380,  356,  358,  382,  384,  359,
+      361,  385,  386,  362,  363,  365,  366,  387,  367,  368,
+      389,  390,  370,  371,  391,  373,  374,  375,  377,  378,
+      394,  395,  379,  380,  398,  399,  382,  384,  400,  401,
+      385,  386,  402,  403,  405,  407,  387,  408,  409,  389,
+      390,  413,  414,  391,  415,  417,  418,  419,  420,  394,
+      395,  421,  423,  398,  399,  426,  427,  400,  401,  428,
+      429,  402,  403,  405,  407,  433,  408,  409,  434,  437,
 
-      441,  442,  423,  425,  426,  427,  428,  429,  443,  445,
-      430,  431,  433,  434,  446,  436,  447,  449,  438,  439,
-      451,  452,  453,  454,  456,  458,  459,  460,  463,  441,
-      442,  465,  466,  467,  470,  471,  473,  443,  445,  474,
-      475,  476,  477,  446,  479,  447,  449,    0,    0,  451,
-      452,  453,  454,  456,  458,  459,  460,  463,    0,    0,
-      465,  466,  467,  470,  471,  473,    0,    0,  474,  475,
-      476,  477,    0,  479,  483,  483,  483,  483,  483,  483,
-      483,  483,  483,  483,  484,  484,  484,  484,  484,  484,
-      484,  484,  484,  484,  485,  485,  485,  485,  485,  485,
+      413,  414,  438,  415,  417,  418,  419,  420,  439,  440,
+      421,  423,  441,  443,  426,  427,  444,  445,  428,  429,
+      446,  447,  448,  449,  433,  451,  452,  434,  437,  454,
+      456,  438,  457,  458,  460,  461,  462,  439,  440,  464,
+      465,  441,  443,  466,  468,  444,  445,  470,  471,  446,
+      447,  448,  449,  472,  451,  452,  473,  474,  454,  456,
+      476,  457,  458,  460,  461,  462,  478,  479,  464,  465,
+      480,  483,  466,  468,  486,  487,  470,  471,  488,  491,
+      492,  494,  472,  495,  496,  473,  474,  497,  498,  476,
+      500,    0,    0,    0,    0,  478,  479,    0,    0,  480,
 
-      485,  485,  485,  485,  486,  486,  486,  486,  486,  486,
-      486,  486,  486,  486,  487,  487,  487,  487,  487,  487,
-      487,  487,  487,  487,  488,  488,  489,  489,  489,    0,
-      489,  490,  490,  490,  490,  491,  491,  491,    0,  491,
-      491,  491,  491,  491,  491,  492,  492,  492,    0,  492,
-      492,  492,  492,    0,  492,  493,  493,  493,  493,  493,
-      493,  493,  493,  493,  493,  494,  494,    0,  494,  494,
-      494,  494,  494,  494,  494,  495,    0,  495,  495,  495,
-      495,  495,  495,  495,  495,  496,  496,  497,  497,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
+      483,    0,    0,  486,  487,    0,    0,  488,  491,  492,
+      494,    0,  495,  496,    0,    0,  497,  498,    0,  500,
+      504,  504,  504,  504,  504,  504,  504,  504,  504,  504,
+      505,  505,  505,  505,  505,  505,  505,  505,  505,  505,
+      506,  506,  506,  506,  506,  506,  506,  506,  506,  506,
+      507,  507,  507,  507,  507,  507,  507,  507,  507,  507,
+      508,  508,  508,  508,  508,  508,  508,  508,  508,  508,
+      509,  509,  510,  510,  510,    0,  510,  511,  511,  511,
+      511,  512,  512,  512,    0,  512,  512,  512,  512,  512,
+      512,  513,  513,  513,    0,  513,  513,  513,  513,    0,
 
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482,  482,  482,  482,  482,  482,  482,  482,  482,  482,
-      482
+      513,  514,  514,  514,  514,  514,  514,  514,  514,  514,
+      514,  515,  515,    0,  515,  515,  515,  515,  515,  515,
+      515,  516,    0,  516,  516,  516,  516,  516,  516,  516,
+      516,  517,  517,  518,  518,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+      503,  503,  503,  503,  503,  503,  503,  503,  503,  503,
+
+      503,  503,  503,  503,  503,  503,  503
     } ;
 
 /* Table of booleans, true if rule could match eol. */
-static yyconst flex_int32_t yy_rule_can_match_eol[131] =
+static yyconst flex_int32_t yy_rule_can_match_eol[136] =
     {   0,
 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 
-    0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0,     };
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0,     };
 
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
@@ -942,6 +959,7 @@
 class ParseLimit;
 class ParseOrderBy;
 class ParseOrderByItem;
+class ParsePartitionClause;
 class ParsePredicate;
 class ParseSample;
 class ParseScalarLiteral;
@@ -958,6 +976,8 @@
 class ParseStatementDelete;
 class ParseStatementDropTable;
 class ParseStatementInsert;
+class ParseStatementInsertTuple;
+class ParseStatementInsertSelection;
 class ParseStatementSelect;
 class ParseStatementQuit;
 class ParseStatementUpdate;
@@ -991,7 +1011,7 @@
 
 
 
-#line 995 "SqlLexer_gen.cpp"
+#line 1015 "SqlLexer_gen.cpp"
 
 #define INITIAL 0
 #define CONDITION_SQL 1
@@ -1279,10 +1299,10 @@
 		}
 
 	{
-#line 120 "../SqlLexer.lpp"
+#line 123 "../SqlLexer.lpp"
 
 
-#line 1286 "SqlLexer_gen.cpp"
+#line 1306 "SqlLexer_gen.cpp"
 
 	while ( /*CONSTCOND*/1 )		/* loops until end-of-file is reached */
 		{
@@ -1309,13 +1329,13 @@
 			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 				{
 				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 483 )
+				if ( yy_current_state >= 504 )
 					yy_c = yy_meta[(unsigned int) yy_c];
 				}
 			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 			++yy_cp;
 			}
-		while ( yy_current_state != 482 );
+		while ( yy_current_state != 503 );
 		yy_cp = yyg->yy_last_accepting_cpos;
 		yy_current_state = yyg->yy_last_accepting_state;
 
@@ -1349,7 +1369,7 @@
 
 case 1:
 YY_RULE_SETUP
-#line 123 "../SqlLexer.lpp"
+#line 126 "../SqlLexer.lpp"
 {
     /* A forward slash character represents a system command. */
     BEGIN(CONDITION_COMMAND);
@@ -1361,7 +1381,7 @@
 case 2:
 /* rule 2 can match eol */
 YY_RULE_SETUP
-#line 131 "../SqlLexer.lpp"
+#line 134 "../SqlLexer.lpp"
 {
     /* This is a SQL command. Place the char back and process normally. */
     yyless(0);
@@ -1373,7 +1393,7 @@
 
 case 3:
 YY_RULE_SETUP
-#line 140 "../SqlLexer.lpp"
+#line 143 "../SqlLexer.lpp"
 {
     /* This is a command argument. */
     yylval->string_value_ = new quickstep::ParseString(
@@ -1383,7 +1403,7 @@
 	YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 147 "../SqlLexer.lpp"
+#line 150 "../SqlLexer.lpp"
 {
     /* Ignore whitespace. */
   }
@@ -1391,7 +1411,7 @@
 case 5:
 /* rule 5 can match eol */
 YY_RULE_SETUP
-#line 151 "../SqlLexer.lpp"
+#line 154 "../SqlLexer.lpp"
 {
     /* Newline reverts the lexer to the initial state. */
     yycolumn = 0;
@@ -1403,517 +1423,542 @@
 
 case 6:
 YY_RULE_SETUP
-#line 160 "../SqlLexer.lpp"
+#line 163 "../SqlLexer.lpp"
 return TOKEN_ADD;
 	YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 161 "../SqlLexer.lpp"
+#line 164 "../SqlLexer.lpp"
 return TOKEN_ALL;
 	YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 162 "../SqlLexer.lpp"
+#line 165 "../SqlLexer.lpp"
 return TOKEN_ALTER;
 	YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 163 "../SqlLexer.lpp"
+#line 166 "../SqlLexer.lpp"
 return TOKEN_AND;
 	YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 164 "../SqlLexer.lpp"
+#line 167 "../SqlLexer.lpp"
 return TOKEN_AS;
 	YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 165 "../SqlLexer.lpp"
+#line 168 "../SqlLexer.lpp"
 return TOKEN_ASC;
 	YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 166 "../SqlLexer.lpp"
+#line 169 "../SqlLexer.lpp"
 return TOKEN_ASC;
 	YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 167 "../SqlLexer.lpp"
+#line 170 "../SqlLexer.lpp"
 return TOKEN_BETWEEN;
 	YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 168 "../SqlLexer.lpp"
+#line 171 "../SqlLexer.lpp"
 return TOKEN_BIGINT;
 	YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 169 "../SqlLexer.lpp"
+#line 172 "../SqlLexer.lpp"
 return TOKEN_BIT;
 	YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 170 "../SqlLexer.lpp"
+#line 173 "../SqlLexer.lpp"
 return TOKEN_BLOCKPROPERTIES;
 	YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 171 "../SqlLexer.lpp"
+#line 174 "../SqlLexer.lpp"
 return TOKEN_BLOCKSAMPLE;
 	YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 172 "../SqlLexer.lpp"
+#line 175 "../SqlLexer.lpp"
 return TOKEN_BLOOM_FILTER;
 	YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 173 "../SqlLexer.lpp"
+#line 176 "../SqlLexer.lpp"
 return TOKEN_CSB_TREE;
 	YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 174 "../SqlLexer.lpp"
+#line 177 "../SqlLexer.lpp"
 return TOKEN_BY;
 	YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 175 "../SqlLexer.lpp"
+#line 178 "../SqlLexer.lpp"
 return TOKEN_CHARACTER;
 	YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 176 "../SqlLexer.lpp"
+#line 179 "../SqlLexer.lpp"
 return TOKEN_CHARACTER;
 	YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 177 "../SqlLexer.lpp"
+#line 180 "../SqlLexer.lpp"
 return TOKEN_CHECK;
 	YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 178 "../SqlLexer.lpp"
+#line 181 "../SqlLexer.lpp"
 return TOKEN_COLUMN;
 	YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 179 "../SqlLexer.lpp"
+#line 182 "../SqlLexer.lpp"
 return TOKEN_CONSTRAINT;
 	YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 180 "../SqlLexer.lpp"
+#line 183 "../SqlLexer.lpp"
 return TOKEN_COPY;
 	YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 181 "../SqlLexer.lpp"
+#line 184 "../SqlLexer.lpp"
 return TOKEN_CREATE;
 	YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 182 "../SqlLexer.lpp"
+#line 185 "../SqlLexer.lpp"
 return TOKEN_DATE;
 	YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 183 "../SqlLexer.lpp"
+#line 186 "../SqlLexer.lpp"
 return TOKEN_DATETIME;
 	YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 184 "../SqlLexer.lpp"
+#line 187 "../SqlLexer.lpp"
 return TOKEN_DECIMAL;
 	YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 185 "../SqlLexer.lpp"
+#line 188 "../SqlLexer.lpp"
 return TOKEN_DEFAULT;
 	YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 186 "../SqlLexer.lpp"
+#line 189 "../SqlLexer.lpp"
 return TOKEN_DELETE;
 	YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 187 "../SqlLexer.lpp"
+#line 190 "../SqlLexer.lpp"
 return TOKEN_DELIMITER;
 	YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 188 "../SqlLexer.lpp"
+#line 191 "../SqlLexer.lpp"
 return TOKEN_DESC;
 	YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 189 "../SqlLexer.lpp"
+#line 192 "../SqlLexer.lpp"
 return TOKEN_DESC;
 	YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 190 "../SqlLexer.lpp"
+#line 193 "../SqlLexer.lpp"
 return TOKEN_DISTINCT;
 	YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 191 "../SqlLexer.lpp"
+#line 194 "../SqlLexer.lpp"
 return TOKEN_DOUBLE;
 	YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 192 "../SqlLexer.lpp"
+#line 195 "../SqlLexer.lpp"
 return TOKEN_DROP;
 	YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 193 "../SqlLexer.lpp"
+#line 196 "../SqlLexer.lpp"
 return TOKEN_ESCAPE_STRINGS;
 	YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 194 "../SqlLexer.lpp"
-return TOKEN_FALSE;
+#line 197 "../SqlLexer.lpp"
+return TOKEN_EXTRACT;
 	YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 195 "../SqlLexer.lpp"
-return TOKEN_FIRST;
+#line 198 "../SqlLexer.lpp"
+return TOKEN_FALSE;
 	YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 196 "../SqlLexer.lpp"
-return TOKEN_FLOAT;
+#line 199 "../SqlLexer.lpp"
+return TOKEN_FIRST;
 	YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 197 "../SqlLexer.lpp"
-return TOKEN_FOREIGN;
+#line 200 "../SqlLexer.lpp"
+return TOKEN_FLOAT;
 	YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 198 "../SqlLexer.lpp"
-return TOKEN_FROM;
+#line 201 "../SqlLexer.lpp"
+return TOKEN_FOREIGN;
 	YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 199 "../SqlLexer.lpp"
-return TOKEN_FULL;
+#line 202 "../SqlLexer.lpp"
+return TOKEN_FROM;
 	YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 200 "../SqlLexer.lpp"
-return TOKEN_GROUP;
+#line 203 "../SqlLexer.lpp"
+return TOKEN_FULL;
 	YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 201 "../SqlLexer.lpp"
-return TOKEN_HAVING;
+#line 204 "../SqlLexer.lpp"
+return TOKEN_GROUP;
 	YY_BREAK
 case 48:
 YY_RULE_SETUP
-#line 202 "../SqlLexer.lpp"
-return TOKEN_INDEX;
+#line 205 "../SqlLexer.lpp"
+return TOKEN_HASH;
 	YY_BREAK
 case 49:
 YY_RULE_SETUP
-#line 203 "../SqlLexer.lpp"
-return TOKEN_INNER;
+#line 206 "../SqlLexer.lpp"
+return TOKEN_HAVING;
 	YY_BREAK
 case 50:
 YY_RULE_SETUP
-#line 204 "../SqlLexer.lpp"
-return TOKEN_INSERT;
+#line 207 "../SqlLexer.lpp"
+return TOKEN_INDEX;
 	YY_BREAK
 case 51:
 YY_RULE_SETUP
-#line 205 "../SqlLexer.lpp"
-return TOKEN_INTEGER;
+#line 208 "../SqlLexer.lpp"
+return TOKEN_INNER;
 	YY_BREAK
 case 52:
 YY_RULE_SETUP
-#line 206 "../SqlLexer.lpp"
-return TOKEN_INTEGER;
+#line 209 "../SqlLexer.lpp"
+return TOKEN_INSERT;
 	YY_BREAK
 case 53:
 YY_RULE_SETUP
-#line 207 "../SqlLexer.lpp"
-return TOKEN_INTERVAL;
+#line 210 "../SqlLexer.lpp"
+return TOKEN_INTEGER;
 	YY_BREAK
 case 54:
 YY_RULE_SETUP
-#line 208 "../SqlLexer.lpp"
-return TOKEN_INTO;
+#line 211 "../SqlLexer.lpp"
+return TOKEN_INTEGER;
 	YY_BREAK
 case 55:
 YY_RULE_SETUP
-#line 209 "../SqlLexer.lpp"
-return TOKEN_IS;
+#line 212 "../SqlLexer.lpp"
+return TOKEN_INTERVAL;
 	YY_BREAK
 case 56:
 YY_RULE_SETUP
-#line 210 "../SqlLexer.lpp"
-return TOKEN_JOIN;
+#line 213 "../SqlLexer.lpp"
+return TOKEN_INTO;
 	YY_BREAK
 case 57:
 YY_RULE_SETUP
-#line 211 "../SqlLexer.lpp"
-return TOKEN_KEY;
+#line 214 "../SqlLexer.lpp"
+return TOKEN_IS;
 	YY_BREAK
 case 58:
 YY_RULE_SETUP
-#line 212 "../SqlLexer.lpp"
-return TOKEN_LAST;
+#line 215 "../SqlLexer.lpp"
+return TOKEN_JOIN;
 	YY_BREAK
 case 59:
 YY_RULE_SETUP
-#line 213 "../SqlLexer.lpp"
-return TOKEN_LEFT;
+#line 216 "../SqlLexer.lpp"
+return TOKEN_KEY;
 	YY_BREAK
 case 60:
 YY_RULE_SETUP
-#line 214 "../SqlLexer.lpp"
-return TOKEN_LIKE;
+#line 217 "../SqlLexer.lpp"
+return TOKEN_LAST;
 	YY_BREAK
 case 61:
 YY_RULE_SETUP
-#line 215 "../SqlLexer.lpp"
-return TOKEN_LIMIT;
+#line 218 "../SqlLexer.lpp"
+return TOKEN_LEFT;
 	YY_BREAK
 case 62:
 YY_RULE_SETUP
-#line 216 "../SqlLexer.lpp"
-return TOKEN_LONG;
+#line 219 "../SqlLexer.lpp"
+return TOKEN_LIKE;
 	YY_BREAK
 case 63:
 YY_RULE_SETUP
-#line 217 "../SqlLexer.lpp"
-return TOKEN_NOT;
+#line 220 "../SqlLexer.lpp"
+return TOKEN_LIMIT;
 	YY_BREAK
 case 64:
 YY_RULE_SETUP
-#line 218 "../SqlLexer.lpp"
-return TOKEN_NULL;
+#line 221 "../SqlLexer.lpp"
+return TOKEN_LONG;
 	YY_BREAK
 case 65:
 YY_RULE_SETUP
-#line 219 "../SqlLexer.lpp"
-return TOKEN_NULLS;
+#line 222 "../SqlLexer.lpp"
+return TOKEN_NOT;
 	YY_BREAK
 case 66:
 YY_RULE_SETUP
-#line 220 "../SqlLexer.lpp"
-return TOKEN_OFF;
+#line 223 "../SqlLexer.lpp"
+return TOKEN_NULL;
 	YY_BREAK
 case 67:
 YY_RULE_SETUP
-#line 221 "../SqlLexer.lpp"
-return TOKEN_ON;
+#line 224 "../SqlLexer.lpp"
+return TOKEN_NULLS;
 	YY_BREAK
 case 68:
 YY_RULE_SETUP
-#line 222 "../SqlLexer.lpp"
-return TOKEN_OR;
+#line 225 "../SqlLexer.lpp"
+return TOKEN_OFF;
 	YY_BREAK
 case 69:
 YY_RULE_SETUP
-#line 223 "../SqlLexer.lpp"
-return TOKEN_ORDER;
+#line 226 "../SqlLexer.lpp"
+return TOKEN_ON;
 	YY_BREAK
 case 70:
 YY_RULE_SETUP
-#line 224 "../SqlLexer.lpp"
-return TOKEN_OUTER;
+#line 227 "../SqlLexer.lpp"
+return TOKEN_OR;
 	YY_BREAK
 case 71:
 YY_RULE_SETUP
-#line 225 "../SqlLexer.lpp"
-return TOKEN_PERCENT;
+#line 228 "../SqlLexer.lpp"
+return TOKEN_ORDER;
 	YY_BREAK
 case 72:
 YY_RULE_SETUP
-#line 226 "../SqlLexer.lpp"
-return TOKEN_PRIMARY;
+#line 229 "../SqlLexer.lpp"
+return TOKEN_OUTER;
 	YY_BREAK
 case 73:
 YY_RULE_SETUP
-#line 227 "../SqlLexer.lpp"
-return TOKEN_QUIT;
+#line 230 "../SqlLexer.lpp"
+return TOKEN_PARTITION;
 	YY_BREAK
 case 74:
 YY_RULE_SETUP
-#line 228 "../SqlLexer.lpp"
-return TOKEN_REAL;
+#line 231 "../SqlLexer.lpp"
+return TOKEN_PARTITIONS;
 	YY_BREAK
 case 75:
 YY_RULE_SETUP
-#line 229 "../SqlLexer.lpp"
-return TOKEN_REFERENCES;
+#line 232 "../SqlLexer.lpp"
+return TOKEN_PERCENT;
 	YY_BREAK
 case 76:
 YY_RULE_SETUP
-#line 230 "../SqlLexer.lpp"
-return TOKEN_REGEXP;
+#line 233 "../SqlLexer.lpp"
+return TOKEN_PRIMARY;
 	YY_BREAK
 case 77:
 YY_RULE_SETUP
-#line 231 "../SqlLexer.lpp"
-return TOKEN_RIGHT;
+#line 234 "../SqlLexer.lpp"
+return TOKEN_QUIT;
 	YY_BREAK
 case 78:
 YY_RULE_SETUP
-#line 232 "../SqlLexer.lpp"
-return TOKEN_ROW_DELIMITER;
+#line 235 "../SqlLexer.lpp"
+return TOKEN_RANGE;
 	YY_BREAK
 case 79:
 YY_RULE_SETUP
-#line 233 "../SqlLexer.lpp"
-return TOKEN_SELECT;
+#line 236 "../SqlLexer.lpp"
+return TOKEN_REAL;
 	YY_BREAK
 case 80:
 YY_RULE_SETUP
-#line 234 "../SqlLexer.lpp"
-return TOKEN_SET;
+#line 237 "../SqlLexer.lpp"
+return TOKEN_REFERENCES;
 	YY_BREAK
 case 81:
 YY_RULE_SETUP
-#line 235 "../SqlLexer.lpp"
-return TOKEN_SMALLINT;
+#line 238 "../SqlLexer.lpp"
+return TOKEN_REGEXP;
 	YY_BREAK
 case 82:
 YY_RULE_SETUP
-#line 236 "../SqlLexer.lpp"
-return TOKEN_TABLE;
+#line 239 "../SqlLexer.lpp"
+return TOKEN_RIGHT;
 	YY_BREAK
 case 83:
 YY_RULE_SETUP
-#line 237 "../SqlLexer.lpp"
-return TOKEN_TIME;
+#line 240 "../SqlLexer.lpp"
+return TOKEN_ROW_DELIMITER;
 	YY_BREAK
 case 84:
 YY_RULE_SETUP
-#line 238 "../SqlLexer.lpp"
-return TOKEN_TIMESTAMP;
+#line 241 "../SqlLexer.lpp"
+return TOKEN_SELECT;
 	YY_BREAK
 case 85:
 YY_RULE_SETUP
-#line 239 "../SqlLexer.lpp"
-return TOKEN_TRUE;
+#line 242 "../SqlLexer.lpp"
+return TOKEN_SET;
 	YY_BREAK
 case 86:
 YY_RULE_SETUP
-#line 240 "../SqlLexer.lpp"
-return TOKEN_TUPLESAMPLE;
+#line 243 "../SqlLexer.lpp"
+return TOKEN_SMALLINT;
 	YY_BREAK
 case 87:
 YY_RULE_SETUP
-#line 241 "../SqlLexer.lpp"
-return TOKEN_UNIQUE;
+#line 244 "../SqlLexer.lpp"
+return TOKEN_TABLE;
 	YY_BREAK
 case 88:
 YY_RULE_SETUP
-#line 242 "../SqlLexer.lpp"
-return TOKEN_UPDATE;
+#line 245 "../SqlLexer.lpp"
+return TOKEN_TIME;
 	YY_BREAK
 case 89:
 YY_RULE_SETUP
-#line 243 "../SqlLexer.lpp"
-return TOKEN_USING;
+#line 246 "../SqlLexer.lpp"
+return TOKEN_TIMESTAMP;
 	YY_BREAK
 case 90:
 YY_RULE_SETUP
-#line 244 "../SqlLexer.lpp"
-return TOKEN_VALUES;
+#line 247 "../SqlLexer.lpp"
+return TOKEN_TRUE;
 	YY_BREAK
 case 91:
 YY_RULE_SETUP
-#line 245 "../SqlLexer.lpp"
-return TOKEN_VARCHAR;
+#line 248 "../SqlLexer.lpp"
+return TOKEN_TUPLESAMPLE;
 	YY_BREAK
 case 92:
 YY_RULE_SETUP
-#line 246 "../SqlLexer.lpp"
-return TOKEN_WHERE;
+#line 249 "../SqlLexer.lpp"
+return TOKEN_UNIQUE;
 	YY_BREAK
 case 93:
 YY_RULE_SETUP
-#line 247 "../SqlLexer.lpp"
-return TOKEN_WITH;
+#line 250 "../SqlLexer.lpp"
+return TOKEN_UPDATE;
 	YY_BREAK
 case 94:
 YY_RULE_SETUP
-#line 248 "../SqlLexer.lpp"
-return TOKEN_YEARMONTH;
+#line 251 "../SqlLexer.lpp"
+return TOKEN_USING;
 	YY_BREAK
 case 95:
 YY_RULE_SETUP
-#line 250 "../SqlLexer.lpp"
-return TOKEN_EQ;
+#line 252 "../SqlLexer.lpp"
+return TOKEN_VALUES;
 	YY_BREAK
 case 96:
 YY_RULE_SETUP
-#line 251 "../SqlLexer.lpp"
-return TOKEN_NEQ;
+#line 253 "../SqlLexer.lpp"
+return TOKEN_VARCHAR;
 	YY_BREAK
 case 97:
 YY_RULE_SETUP
-#line 252 "../SqlLexer.lpp"
-return TOKEN_NEQ;
+#line 254 "../SqlLexer.lpp"
+return TOKEN_WHERE;
 	YY_BREAK
 case 98:
 YY_RULE_SETUP
-#line 253 "../SqlLexer.lpp"
-return TOKEN_LT;
+#line 255 "../SqlLexer.lpp"
+return TOKEN_WITH;
 	YY_BREAK
 case 99:
 YY_RULE_SETUP
-#line 254 "../SqlLexer.lpp"
-return TOKEN_GT;
+#line 256 "../SqlLexer.lpp"
+return TOKEN_YEARMONTH;
 	YY_BREAK
 case 100:
 YY_RULE_SETUP
-#line 255 "../SqlLexer.lpp"
-return TOKEN_LEQ;
+#line 258 "../SqlLexer.lpp"
+return TOKEN_EQ;
 	YY_BREAK
 case 101:
 YY_RULE_SETUP
-#line 256 "../SqlLexer.lpp"
-return TOKEN_GEQ;
+#line 259 "../SqlLexer.lpp"
+return TOKEN_NEQ;
 	YY_BREAK
 case 102:
 YY_RULE_SETUP
-#line 258 "../SqlLexer.lpp"
-return yytext[0];
+#line 260 "../SqlLexer.lpp"
+return TOKEN_NEQ;
 	YY_BREAK
 case 103:
 YY_RULE_SETUP
-#line 259 "../SqlLexer.lpp"
+#line 261 "../SqlLexer.lpp"
+return TOKEN_LT;
+	YY_BREAK
+case 104:
+YY_RULE_SETUP
+#line 262 "../SqlLexer.lpp"
+return TOKEN_GT;
+	YY_BREAK
+case 105:
+YY_RULE_SETUP
+#line 263 "../SqlLexer.lpp"
+return TOKEN_LEQ;
+	YY_BREAK
+case 106:
+YY_RULE_SETUP
+#line 264 "../SqlLexer.lpp"
+return TOKEN_GEQ;
+	YY_BREAK
+case 107:
+YY_RULE_SETUP
+#line 266 "../SqlLexer.lpp"
+return yytext[0];
+	YY_BREAK
+case 108:
+YY_RULE_SETUP
+#line 267 "../SqlLexer.lpp"
 return yytext[0];
 	YY_BREAK
 /**
     * Quoted strings. Prefacing a string with an 'e' or 'E' causes escape
     * sequences to be processed (as in PostgreSQL).
     **/
-case 104:
+case 109:
 YY_RULE_SETUP
-#line 265 "../SqlLexer.lpp"
+#line 273 "../SqlLexer.lpp"
 {
     yylval->string_value_ = new quickstep::ParseString(yylloc->first_line, yylloc->first_column);
     BEGIN(CONDITION_STRING_SINGLE_QUOTED_ESCAPED);
   }
 	YY_BREAK
-case 105:
+case 110:
 YY_RULE_SETUP
-#line 270 "../SqlLexer.lpp"
+#line 278 "../SqlLexer.lpp"
 {
     yylval->string_value_ = new quickstep::ParseString(yylloc->first_line, yylloc->first_column);
     BEGIN(CONDITION_STRING_SINGLE_QUOTED);
   }
 	YY_BREAK
-case 106:
+case 111:
 YY_RULE_SETUP
-#line 275 "../SqlLexer.lpp"
+#line 283 "../SqlLexer.lpp"
 {
     yylval->string_value_ = new quickstep::ParseString(yylloc->first_line, yylloc->first_column);
     BEGIN(CONDITION_STRING_DOUBLE_QUOTED);
@@ -1925,7 +1970,7 @@
 case YY_STATE_EOF(CONDITION_STRING_SINGLE_QUOTED):
 case YY_STATE_EOF(CONDITION_STRING_SINGLE_QUOTED_ESCAPED):
 case YY_STATE_EOF(CONDITION_STRING_DOUBLE_QUOTED):
-#line 284 "../SqlLexer.lpp"
+#line 292 "../SqlLexer.lpp"
 {
     delete yylval->string_value_;
     BEGIN(INITIAL);
@@ -1936,9 +1981,9 @@
 
 /* Process escape sequences. */
 
-case 107:
+case 112:
 YY_RULE_SETUP
-#line 294 "../SqlLexer.lpp"
+#line 302 "../SqlLexer.lpp"
 {
     /* Octal code */
     unsigned int code;
@@ -1952,9 +1997,9 @@
     yylval->string_value_->push_back(code);
   }
 	YY_BREAK
-case 108:
+case 113:
 YY_RULE_SETUP
-#line 306 "../SqlLexer.lpp"
+#line 314 "../SqlLexer.lpp"
 {
     /* Hexadecimal code */
     unsigned int code;
@@ -1962,9 +2007,9 @@
     yylval->string_value_->push_back(code);
   }
 	YY_BREAK
-case 109:
+case 114:
 YY_RULE_SETUP
-#line 312 "../SqlLexer.lpp"
+#line 320 "../SqlLexer.lpp"
 {
     /* A numeric escape sequence that isn't correctly specified. */
     delete yylval->string_value_;
@@ -1973,58 +2018,58 @@
     return TOKEN_LEX_ERROR;
   }
 	YY_BREAK
-case 110:
+case 115:
 YY_RULE_SETUP
-#line 319 "../SqlLexer.lpp"
+#line 327 "../SqlLexer.lpp"
 {
     /* Backspace */
     yylval->string_value_->push_back('\b');
   }
 	YY_BREAK
-case 111:
+case 116:
 YY_RULE_SETUP
-#line 323 "../SqlLexer.lpp"
+#line 331 "../SqlLexer.lpp"
 {
     /* Form-feed */
     yylval->string_value_->push_back('\f');
   }
 	YY_BREAK
-case 112:
+case 117:
 YY_RULE_SETUP
-#line 327 "../SqlLexer.lpp"
+#line 335 "../SqlLexer.lpp"
 {
     /* Newline */
     yylval->string_value_->push_back('\n');
   }
 	YY_BREAK
-case 113:
+case 118:
 YY_RULE_SETUP
-#line 331 "../SqlLexer.lpp"
+#line 339 "../SqlLexer.lpp"
 {
     /* Carriage-return */
     yylval->string_value_->push_back('\r');
   }
 	YY_BREAK
-case 114:
+case 119:
 YY_RULE_SETUP
-#line 335 "../SqlLexer.lpp"
+#line 343 "../SqlLexer.lpp"
 {
     /* Horizontal Tab */
     yylval->string_value_->push_back('\t');
   }
 	YY_BREAK
-case 115:
-/* rule 115 can match eol */
+case 120:
+/* rule 120 can match eol */
 YY_RULE_SETUP
-#line 339 "../SqlLexer.lpp"
+#line 347 "../SqlLexer.lpp"
 {
     /* Any other character (including actual newline or carriage return) */
     yylval->string_value_->push_back(yytext[1]);
   }
 	YY_BREAK
-case 116:
+case 121:
 YY_RULE_SETUP
-#line 343 "../SqlLexer.lpp"
+#line 351 "../SqlLexer.lpp"
 {
     /* This should only be encountered right before an EOF. */
     delete yylval->string_value_;
@@ -2035,17 +2080,17 @@
 	YY_BREAK
 
 
-case 117:
+case 122:
 YY_RULE_SETUP
-#line 353 "../SqlLexer.lpp"
+#line 361 "../SqlLexer.lpp"
 {
     /* Two quotes in a row become a single quote (this is specified by the SQL standard). */
     yylval->string_value_->push_back('\'');
   }
 	YY_BREAK
-case 118:
+case 123:
 YY_RULE_SETUP
-#line 357 "../SqlLexer.lpp"
+#line 365 "../SqlLexer.lpp"
 {
     /* End string */
     BEGIN(CONDITION_SQL);
@@ -2054,17 +2099,17 @@
 	YY_BREAK
 
 
-case 119:
+case 124:
 YY_RULE_SETUP
-#line 365 "../SqlLexer.lpp"
+#line 373 "../SqlLexer.lpp"
 {
     /* Two quotes in a row become a single quote (this is specified by the SQL standard). */
     yylval->string_value_->push_back('"');
   }
 	YY_BREAK
-case 120:
+case 125:
 YY_RULE_SETUP
-#line 369 "../SqlLexer.lpp"
+#line 377 "../SqlLexer.lpp"
 {
     /* End string */
     BEGIN(CONDITION_SQL);
@@ -2072,94 +2117,94 @@
   }
 	YY_BREAK
 
-case 121:
-/* rule 121 can match eol */
+case 126:
+/* rule 126 can match eol */
 YY_RULE_SETUP
-#line 376 "../SqlLexer.lpp"
+#line 384 "../SqlLexer.lpp"
 {
   /* Scan up to a quote. */
   yylval->string_value_->append(yytext, yyleng);
 }
 	YY_BREAK
-case 122:
-/* rule 122 can match eol */
+case 127:
+/* rule 127 can match eol */
 YY_RULE_SETUP
-#line 381 "../SqlLexer.lpp"
+#line 389 "../SqlLexer.lpp"
 {
   /* Scan up to a quote or escape sequence. */
   yylval->string_value_->append(yytext, yyleng);
 }
 	YY_BREAK
-case 123:
-/* rule 123 can match eol */
+case 128:
+/* rule 128 can match eol */
 YY_RULE_SETUP
-#line 386 "../SqlLexer.lpp"
+#line 394 "../SqlLexer.lpp"
 {
   /* Scan up to a quote. */
   yylval->string_value_->append(yytext, yyleng);
 }
 	YY_BREAK
 
-case 124:
+case 129:
 YY_RULE_SETUP
-#line 392 "../SqlLexer.lpp"
+#line 400 "../SqlLexer.lpp"
 {
     yylval->string_value_ = new quickstep::ParseString(
         yylloc->first_line, yylloc->first_column, std::string(yytext, yyleng));
     return TOKEN_NAME;
   }
 	YY_BREAK
-case 125:
+case 130:
 YY_RULE_SETUP
-#line 398 "../SqlLexer.lpp"
+#line 406 "../SqlLexer.lpp"
 {
     yylval->numeric_literal_value_ = new quickstep::NumericParseLiteralValue(
         yylloc->first_line, yylloc->first_column, yytext);
     return TOKEN_UNSIGNED_NUMVAL;
   }
 	YY_BREAK
-case 126:
+case 131:
 YY_RULE_SETUP
-#line 404 "../SqlLexer.lpp"
+#line 412 "../SqlLexer.lpp"
 /* comment */
 	YY_BREAK
-case 127:
-/* rule 127 can match eol */
+case 132:
+/* rule 132 can match eol */
 YY_RULE_SETUP
-#line 406 "../SqlLexer.lpp"
+#line 414 "../SqlLexer.lpp"
 { yycolumn = 0; }
 	YY_BREAK
-case 128:
+case 133:
 YY_RULE_SETUP
-#line 408 "../SqlLexer.lpp"
+#line 416 "../SqlLexer.lpp"
 ; /* ignore white space */
 	YY_BREAK
 /* CONDITION_SQL */
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(CONDITION_COMMAND):
 case YY_STATE_EOF(CONDITION_SQL):
-#line 412 "../SqlLexer.lpp"
+#line 420 "../SqlLexer.lpp"
 {
   /* All conditions except for mutli-state string extracting conditions. */
   BEGIN(INITIAL);
   return TOKEN_EOF;
 }
 	YY_BREAK
-case 129:
+case 134:
 YY_RULE_SETUP
-#line 418 "../SqlLexer.lpp"
+#line 426 "../SqlLexer.lpp"
 {
   BEGIN(INITIAL);
   quickstep_yyerror(NULL, yyscanner, NULL, "illegal character");
   return TOKEN_LEX_ERROR;
 }
 	YY_BREAK
-case 130:
+case 135:
 YY_RULE_SETUP
-#line 424 "../SqlLexer.lpp"
+#line 432 "../SqlLexer.lpp"
 YY_FATAL_ERROR( "flex scanner jammed" );
 	YY_BREAK
-#line 2163 "SqlLexer_gen.cpp"
+#line 2208 "SqlLexer_gen.cpp"
 
 	case YY_END_OF_BUFFER:
 		{
@@ -2453,7 +2498,7 @@
 		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 			{
 			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 483 )
+			if ( yy_current_state >= 504 )
 				yy_c = yy_meta[(unsigned int) yy_c];
 			}
 		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -2482,11 +2527,11 @@
 	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 		{
 		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 483 )
+		if ( yy_current_state >= 504 )
 			yy_c = yy_meta[(unsigned int) yy_c];
 		}
 	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 482);
+	yy_is_jam = (yy_current_state == 503);
 
 	(void)yyg;
 	return yy_is_jam ? 0 : yy_current_state;
@@ -3320,7 +3365,7 @@
 
 #define YYTABLES_NAME "yytables"
 
-#line 424 "../SqlLexer.lpp"
+#line 432 "../SqlLexer.lpp"
 
 
 
diff --git a/parser/preprocessed/SqlLexer_gen.hpp b/parser/preprocessed/SqlLexer_gen.hpp
index dccb471..aa184f3 100644
--- a/parser/preprocessed/SqlLexer_gen.hpp
+++ b/parser/preprocessed/SqlLexer_gen.hpp
@@ -360,7 +360,7 @@
 #undef YY_DECL
 #endif
 
-#line 424 "../SqlLexer.lpp"
+#line 432 "../SqlLexer.lpp"
 
 
 #line 367 "SqlLexer_gen.hpp"
diff --git a/parser/preprocessed/SqlParser_gen.cpp b/parser/preprocessed/SqlParser_gen.cpp
index 3de3d51..f7a5765 100644
--- a/parser/preprocessed/SqlParser_gen.cpp
+++ b/parser/preprocessed/SqlParser_gen.cpp
@@ -68,7 +68,7 @@
 
 
 /* Copy the first part of user declarations.  */
-#line 33 "../SqlParser.ypp" /* yacc.c:339  */
+#line 35 "../SqlParser.ypp" /* yacc.c:339  */
 
 
 /* Override the default definition, as we only need <first_line> and <first_column>. */
@@ -96,12 +96,13 @@
     }                                                           \
   } while (0)
 
-#line 62 "../SqlParser.ypp" /* yacc.c:339  */
+#line 64 "../SqlParser.ypp" /* yacc.c:339  */
 
 #include <cstdlib>
 #include <string>
 #include <utility>
 
+#include "catalog/PartitionSchemeHeader.hpp"
 #include "parser/ParseAssignment.hpp"
 #include "parser/ParseAttributeDefinition.hpp"
 #include "parser/ParseBasicExpressions.hpp"
@@ -114,6 +115,7 @@
 #include "parser/ParseLimit.hpp"
 #include "parser/ParseLiteralValue.hpp"
 #include "parser/ParseOrderBy.hpp"
+#include "parser/ParsePartitionClause.hpp"
 #include "parser/ParsePredicate.hpp"
 #include "parser/ParserUtil.hpp"
 #include "parser/ParseSample.hpp"
@@ -144,7 +146,7 @@
 // Needed for Bison 2.6 and higher, which do not automatically provide this typedef.
 typedef void* yyscan_t;
 
-#line 148 "SqlParser_gen.cpp" /* yacc.c:339  */
+#line 150 "SqlParser_gen.cpp" /* yacc.c:339  */
 
 # ifndef YY_NULLPTR
 #  if defined __cplusplus && 201103L <= __cplusplus
@@ -228,57 +230,62 @@
     TOKEN_DOUBLE = 304,
     TOKEN_DROP = 305,
     TOKEN_ESCAPE_STRINGS = 306,
-    TOKEN_FALSE = 307,
-    TOKEN_FIRST = 308,
-    TOKEN_FLOAT = 309,
-    TOKEN_FOREIGN = 310,
-    TOKEN_FROM = 311,
-    TOKEN_FULL = 312,
-    TOKEN_GROUP = 313,
-    TOKEN_HAVING = 314,
-    TOKEN_INDEX = 315,
-    TOKEN_INNER = 316,
-    TOKEN_INSERT = 317,
-    TOKEN_INTEGER = 318,
-    TOKEN_INTERVAL = 319,
-    TOKEN_INTO = 320,
-    TOKEN_JOIN = 321,
-    TOKEN_KEY = 322,
-    TOKEN_LAST = 323,
-    TOKEN_LEFT = 324,
-    TOKEN_LIMIT = 325,
-    TOKEN_LONG = 326,
-    TOKEN_NULL = 327,
-    TOKEN_NULLS = 328,
-    TOKEN_OFF = 329,
-    TOKEN_ON = 330,
-    TOKEN_ORDER = 331,
-    TOKEN_OUTER = 332,
-    TOKEN_PERCENT = 333,
-    TOKEN_PRIMARY = 334,
-    TOKEN_QUIT = 335,
-    TOKEN_REAL = 336,
-    TOKEN_REFERENCES = 337,
-    TOKEN_RIGHT = 338,
-    TOKEN_ROW_DELIMITER = 339,
-    TOKEN_SELECT = 340,
-    TOKEN_SET = 341,
-    TOKEN_SMALLINT = 342,
-    TOKEN_TABLE = 343,
-    TOKEN_TIME = 344,
-    TOKEN_TIMESTAMP = 345,
-    TOKEN_TRUE = 346,
-    TOKEN_TUPLESAMPLE = 347,
-    TOKEN_UNIQUE = 348,
-    TOKEN_UPDATE = 349,
-    TOKEN_USING = 350,
-    TOKEN_VALUES = 351,
-    TOKEN_VARCHAR = 352,
-    TOKEN_WHERE = 353,
-    TOKEN_WITH = 354,
-    TOKEN_YEARMONTH = 355,
-    TOKEN_EOF = 356,
-    TOKEN_LEX_ERROR = 357
+    TOKEN_EXTRACT = 307,
+    TOKEN_FALSE = 308,
+    TOKEN_FIRST = 309,
+    TOKEN_FLOAT = 310,
+    TOKEN_FOREIGN = 311,
+    TOKEN_FROM = 312,
+    TOKEN_FULL = 313,
+    TOKEN_GROUP = 314,
+    TOKEN_HASH = 315,
+    TOKEN_HAVING = 316,
+    TOKEN_INDEX = 317,
+    TOKEN_INNER = 318,
+    TOKEN_INSERT = 319,
+    TOKEN_INTEGER = 320,
+    TOKEN_INTERVAL = 321,
+    TOKEN_INTO = 322,
+    TOKEN_JOIN = 323,
+    TOKEN_KEY = 324,
+    TOKEN_LAST = 325,
+    TOKEN_LEFT = 326,
+    TOKEN_LIMIT = 327,
+    TOKEN_LONG = 328,
+    TOKEN_NULL = 329,
+    TOKEN_NULLS = 330,
+    TOKEN_OFF = 331,
+    TOKEN_ON = 332,
+    TOKEN_ORDER = 333,
+    TOKEN_OUTER = 334,
+    TOKEN_PARTITION = 335,
+    TOKEN_PARTITIONS = 336,
+    TOKEN_PERCENT = 337,
+    TOKEN_PRIMARY = 338,
+    TOKEN_QUIT = 339,
+    TOKEN_RANGE = 340,
+    TOKEN_REAL = 341,
+    TOKEN_REFERENCES = 342,
+    TOKEN_RIGHT = 343,
+    TOKEN_ROW_DELIMITER = 344,
+    TOKEN_SELECT = 345,
+    TOKEN_SET = 346,
+    TOKEN_SMALLINT = 347,
+    TOKEN_TABLE = 348,
+    TOKEN_TIME = 349,
+    TOKEN_TIMESTAMP = 350,
+    TOKEN_TRUE = 351,
+    TOKEN_TUPLESAMPLE = 352,
+    TOKEN_UNIQUE = 353,
+    TOKEN_UPDATE = 354,
+    TOKEN_USING = 355,
+    TOKEN_VALUES = 356,
+    TOKEN_VARCHAR = 357,
+    TOKEN_WHERE = 358,
+    TOKEN_WITH = 359,
+    TOKEN_YEARMONTH = 360,
+    TOKEN_EOF = 361,
+    TOKEN_LEX_ERROR = 362
   };
 #endif
 
@@ -287,7 +294,7 @@
 
 union YYSTYPE
 {
-#line 110 "../SqlParser.ypp" /* yacc.c:355  */
+#line 114 "../SqlParser.ypp" /* yacc.c:355  */
 
   quickstep::ParseString *string_value_;
 
@@ -344,6 +351,7 @@
   quickstep::ParseStatementDelete *delete_statement_;
   quickstep::ParseStatementCopyFrom *copy_from_statement_;
   quickstep::ParseStatementCreateTable *create_table_statement_;
+  quickstep::ParsePartitionClause *partition_clause_;
   quickstep::ParseBlockProperties *block_properties_;
   quickstep::ParseStatementDropTable *drop_table_statement_;
   quickstep::ParseStatementQuit *quit_statement_;
@@ -370,7 +378,7 @@
   quickstep::PtrVector<quickstep::ParseSubqueryTableReference> *with_list_;
   quickstep::ParseSubqueryTableReference *with_list_element_;
 
-#line 374 "SqlParser_gen.cpp" /* yacc.c:355  */
+#line 382 "SqlParser_gen.cpp" /* yacc.c:355  */
 };
 
 typedef union YYSTYPE YYSTYPE;
@@ -399,13 +407,13 @@
 #endif /* !YY_QUICKSTEP_YY_SQLPARSER_GEN_HPP_INCLUDED  */
 
 /* Copy the second part of user declarations.  */
-#line 193 "../SqlParser.ypp" /* yacc.c:358  */
+#line 198 "../SqlParser.ypp" /* yacc.c:358  */
 
 /* This header needs YYSTYPE, which is defined by the %union directive above */
 #include "SqlLexer_gen.hpp"
 void NotSupported(const YYLTYPE *location, yyscan_t yyscanner, const std::string &feature);
 
-#line 409 "SqlParser_gen.cpp" /* yacc.c:358  */
+#line 417 "SqlParser_gen.cpp" /* yacc.c:358  */
 
 #ifdef short
 # undef short
@@ -647,23 +655,23 @@
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  42
+#define YYFINAL  47
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   919
+#define YYLAST   982
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  114
+#define YYNTOKENS  119
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  86
+#define YYNNTS  89
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  228
+#define YYNRULES  237
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  433
+#define YYNSTATES  460
 
 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
    by yylex, with out-of-bounds checking.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   357
+#define YYMAXUTOK   362
 
 #define YYTRANSLATE(YYX)                                                \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -673,11 +681,11 @@
 static const yytype_uint8 yytranslate[] =
 {
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     109,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     114,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,   113,     2,     2,
-     110,   111,    23,    21,   112,    22,    27,    24,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,   108,
+       2,     2,     2,     2,     2,     2,     2,   118,     2,     2,
+     115,   116,    23,    21,   117,    22,    27,    24,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,   113,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -707,36 +715,38 @@
       70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
       80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
       90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
-     100,   101,   102,   103,   104,   105,   106,   107
+     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
+     110,   111,   112
 };
 
 #if YYDEBUG
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   523,   523,   527,   531,   535,   539,   542,   549,   552,
-     555,   558,   561,   564,   567,   570,   573,   576,   582,   588,
-     595,   601,   608,   617,   622,   631,   636,   641,   645,   651,
-     656,   659,   662,   667,   670,   673,   676,   679,   682,   685,
-     688,   691,   694,   706,   709,   712,   730,   750,   753,   756,
-     761,   766,   772,   778,   787,   791,   797,   800,   805,   810,
-     815,   822,   829,   833,   839,   842,   847,   850,   855,   858,
-     863,   867,   873,   876,   879,   884,   887,   894,   899,   910,
-     914,   920,   923,   929,   937,   942,   947,   950,   955,   959,
-     963,   967,   973,   978,   983,   987,   993,   999,  1004,  1007,
-    1012,  1016,  1022,  1028,  1034,  1037,  1041,  1047,  1050,  1055,
-    1059,  1065,  1068,  1071,  1076,  1081,  1084,  1090,  1094,  1100,
-    1106,  1112,  1118,  1124,  1130,  1136,  1142,  1150,  1155,  1158,
-    1161,  1166,  1170,  1174,  1177,  1181,  1186,  1189,  1194,  1197,
-    1202,  1206,  1212,  1215,  1220,  1223,  1228,  1231,  1236,  1239,
-    1258,  1262,  1268,  1275,  1278,  1281,  1286,  1289,  1292,  1298,
-    1301,  1306,  1311,  1320,  1325,  1334,  1339,  1342,  1347,  1350,
-    1355,  1361,  1367,  1370,  1376,  1379,  1384,  1387,  1392,  1395,
-    1400,  1403,  1406,  1409,  1414,  1418,  1422,  1427,  1431,  1437,
-    1440,  1443,  1446,  1458,  1462,  1481,  1496,  1500,  1506,  1509,
-    1514,  1518,  1525,  1528,  1531,  1534,  1537,  1540,  1543,  1546,
-    1549,  1552,  1557,  1568,  1571,  1576,  1579,  1582,  1588,  1592,
-    1598,  1601,  1609,  1612,  1615,  1618,  1624,  1629,  1634
+       0,   538,   538,   542,   546,   550,   554,   557,   564,   567,
+     570,   573,   576,   579,   582,   585,   588,   591,   597,   603,
+     610,   616,   623,   632,   637,   646,   651,   656,   660,   666,
+     671,   674,   677,   682,   685,   688,   691,   694,   697,   700,
+     703,   706,   709,   721,   724,   727,   745,   765,   768,   771,
+     776,   781,   787,   793,   802,   806,   812,   815,   820,   825,
+     830,   837,   844,   848,   854,   857,   862,   865,   870,   873,
+     878,   881,   900,   904,   910,   914,   920,   923,   926,   931,
+     934,   941,   946,   957,   961,   967,   970,   976,   984,   987,
+     990,   996,  1001,  1004,  1009,  1013,  1017,  1021,  1027,  1032,
+    1037,  1041,  1047,  1053,  1056,  1061,  1066,  1070,  1076,  1082,
+    1088,  1091,  1095,  1101,  1104,  1109,  1113,  1119,  1122,  1125,
+    1130,  1135,  1138,  1144,  1148,  1154,  1160,  1166,  1172,  1178,
+    1184,  1190,  1196,  1204,  1209,  1212,  1215,  1220,  1224,  1228,
+    1231,  1235,  1240,  1243,  1248,  1251,  1256,  1260,  1266,  1269,
+    1274,  1277,  1282,  1285,  1290,  1293,  1312,  1316,  1322,  1329,
+    1332,  1335,  1340,  1343,  1346,  1352,  1355,  1360,  1365,  1374,
+    1379,  1388,  1393,  1396,  1401,  1404,  1409,  1415,  1421,  1424,
+    1430,  1433,  1438,  1441,  1446,  1449,  1454,  1457,  1460,  1463,
+    1466,  1471,  1475,  1479,  1482,  1487,  1492,  1496,  1502,  1505,
+    1508,  1511,  1523,  1527,  1546,  1561,  1565,  1571,  1574,  1579,
+    1583,  1590,  1593,  1596,  1599,  1602,  1605,  1608,  1611,  1614,
+    1617,  1622,  1633,  1636,  1641,  1644,  1647,  1653,  1657,  1663,
+    1666,  1674,  1677,  1680,  1683,  1689,  1694,  1699
 };
 #endif
 
@@ -758,34 +768,35 @@
   "TOKEN_COPY", "TOKEN_CREATE", "TOKEN_DATE", "TOKEN_DATETIME",
   "TOKEN_DECIMAL", "TOKEN_DEFAULT", "TOKEN_DELETE", "TOKEN_DELIMITER",
   "TOKEN_DESC", "TOKEN_DISTINCT", "TOKEN_DOUBLE", "TOKEN_DROP",
-  "TOKEN_ESCAPE_STRINGS", "TOKEN_FALSE", "TOKEN_FIRST", "TOKEN_FLOAT",
-  "TOKEN_FOREIGN", "TOKEN_FROM", "TOKEN_FULL", "TOKEN_GROUP",
-  "TOKEN_HAVING", "TOKEN_INDEX", "TOKEN_INNER", "TOKEN_INSERT",
-  "TOKEN_INTEGER", "TOKEN_INTERVAL", "TOKEN_INTO", "TOKEN_JOIN",
-  "TOKEN_KEY", "TOKEN_LAST", "TOKEN_LEFT", "TOKEN_LIMIT", "TOKEN_LONG",
-  "TOKEN_NULL", "TOKEN_NULLS", "TOKEN_OFF", "TOKEN_ON", "TOKEN_ORDER",
-  "TOKEN_OUTER", "TOKEN_PERCENT", "TOKEN_PRIMARY", "TOKEN_QUIT",
-  "TOKEN_REAL", "TOKEN_REFERENCES", "TOKEN_RIGHT", "TOKEN_ROW_DELIMITER",
-  "TOKEN_SELECT", "TOKEN_SET", "TOKEN_SMALLINT", "TOKEN_TABLE",
-  "TOKEN_TIME", "TOKEN_TIMESTAMP", "TOKEN_TRUE", "TOKEN_TUPLESAMPLE",
-  "TOKEN_UNIQUE", "TOKEN_UPDATE", "TOKEN_USING", "TOKEN_VALUES",
-  "TOKEN_VARCHAR", "TOKEN_WHERE", "TOKEN_WITH", "TOKEN_YEARMONTH",
-  "TOKEN_EOF", "TOKEN_LEX_ERROR", "';'", "'\\n'", "'('", "')'", "','",
-  "'%'", "$accept", "start", "sql_statement", "quit_statement",
-  "alter_table_statement", "create_table_statement",
+  "TOKEN_ESCAPE_STRINGS", "TOKEN_EXTRACT", "TOKEN_FALSE", "TOKEN_FIRST",
+  "TOKEN_FLOAT", "TOKEN_FOREIGN", "TOKEN_FROM", "TOKEN_FULL",
+  "TOKEN_GROUP", "TOKEN_HASH", "TOKEN_HAVING", "TOKEN_INDEX",
+  "TOKEN_INNER", "TOKEN_INSERT", "TOKEN_INTEGER", "TOKEN_INTERVAL",
+  "TOKEN_INTO", "TOKEN_JOIN", "TOKEN_KEY", "TOKEN_LAST", "TOKEN_LEFT",
+  "TOKEN_LIMIT", "TOKEN_LONG", "TOKEN_NULL", "TOKEN_NULLS", "TOKEN_OFF",
+  "TOKEN_ON", "TOKEN_ORDER", "TOKEN_OUTER", "TOKEN_PARTITION",
+  "TOKEN_PARTITIONS", "TOKEN_PERCENT", "TOKEN_PRIMARY", "TOKEN_QUIT",
+  "TOKEN_RANGE", "TOKEN_REAL", "TOKEN_REFERENCES", "TOKEN_RIGHT",
+  "TOKEN_ROW_DELIMITER", "TOKEN_SELECT", "TOKEN_SET", "TOKEN_SMALLINT",
+  "TOKEN_TABLE", "TOKEN_TIME", "TOKEN_TIMESTAMP", "TOKEN_TRUE",
+  "TOKEN_TUPLESAMPLE", "TOKEN_UNIQUE", "TOKEN_UPDATE", "TOKEN_USING",
+  "TOKEN_VALUES", "TOKEN_VARCHAR", "TOKEN_WHERE", "TOKEN_WITH",
+  "TOKEN_YEARMONTH", "TOKEN_EOF", "TOKEN_LEX_ERROR", "';'", "'\\n'", "'('",
+  "')'", "','", "'%'", "$accept", "start", "sql_statement",
+  "quit_statement", "alter_table_statement", "create_table_statement",
   "create_index_statement", "drop_table_statement", "column_def",
   "column_def_commalist", "data_type", "column_constraint_def",
   "column_constraint_def_list", "opt_column_constraint_def_list",
   "table_constraint_def", "table_constraint_def_commalist",
   "opt_table_constraint_def_commalist", "opt_column_list",
-  "opt_block_properties", "key_value_list", "key_value",
-  "key_string_value", "key_string_list", "key_integer_value", "index_type",
-  "opt_index_properties", "insert_statement", "copy_from_statement",
-  "opt_copy_from_params", "copy_from_params", "update_statement",
-  "delete_statement", "assignment_list", "assignment_item",
-  "select_statement", "opt_with_clause", "with_list", "with_list_element",
-  "select_query", "opt_all_distinct", "selection",
-  "selection_item_commalist", "selection_item", "from_clause",
+  "opt_block_properties", "opt_partition_clause", "partition_type",
+  "key_value_list", "key_value", "key_string_value", "key_string_list",
+  "key_integer_value", "index_type", "opt_index_properties",
+  "insert_statement", "copy_from_statement", "opt_copy_from_params",
+  "copy_from_params", "update_statement", "delete_statement",
+  "assignment_list", "assignment_item", "select_statement", "with_clause",
+  "with_list", "with_list_element", "select_query", "opt_all_distinct",
+  "selection", "selection_item_commalist", "selection_item", "from_clause",
   "opt_join_chain", "join_chain", "join", "subquery_expression",
   "opt_sample_clause", "table_reference", "table_reference_signature",
   "table_reference_signature_primary", "table_reference_commalist",
@@ -795,11 +806,11 @@
   "where_clause", "or_expression", "and_expression", "not_expression",
   "predicate_expression_base", "add_expression", "multiply_expression",
   "unary_expression", "expression_base", "function_call",
-  "expression_list", "literal_value", "literal_value_commalist",
-  "attribute_ref", "attribute_ref_list", "comparison_operation",
-  "unary_operation", "add_operation", "multiply_operation",
-  "name_commalist", "any_name", "boolean_value", "command",
-  "command_argument_list", YY_NULLPTR
+  "extract_function", "expression_list", "literal_value",
+  "literal_value_commalist", "attribute_ref", "attribute_ref_list",
+  "comparison_operation", "unary_operation", "add_operation",
+  "multiply_operation", "name_commalist", "any_name", "boolean_value",
+  "command", "command_argument_list", YY_NULLPTR
 };
 #endif
 
@@ -818,17 +829,17 @@
      320,   321,   322,   323,   324,   325,   326,   327,   328,   329,
      330,   331,   332,   333,   334,   335,   336,   337,   338,   339,
      340,   341,   342,   343,   344,   345,   346,   347,   348,   349,
-     350,   351,   352,   353,   354,   355,   356,   357,    59,    10,
-      40,    41,    44,    37
+     350,   351,   352,   353,   354,   355,   356,   357,   358,   359,
+     360,   361,   362,    59,    10,    40,    41,    44,    37
 };
 # endif
 
-#define YYPACT_NINF -194
+#define YYPACT_NINF -209
 
 #define yypact_value_is_default(Yystate) \
-  (!!((Yystate) == (-194)))
+  (!!((Yystate) == (-209)))
 
-#define YYTABLE_NINF -99
+#define YYTABLE_NINF -1
 
 #define yytable_value_is_error(Yytable_value) \
   0
@@ -837,50 +848,52 @@
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-      40,  -194,  -194,   -55,   206,    -5,    30,    20,    35,  -194,
-     206,   206,  -194,   147,   108,  -194,  -194,  -194,  -194,  -194,
-    -194,  -194,  -194,  -194,  -194,    19,   -69,   157,   206,  -194,
-    -194,   137,   206,   206,   206,   206,   206,   114,    79,  -194,
-     171,    99,  -194,  -194,  -194,    -2,  -194,  -194,  -194,  -194,
-      66,   212,   170,   142,   145,  -194,   -49,   206,   206,   144,
-     206,  -194,  -194,   396,   181,   185,   152,   206,   206,   503,
-    -194,  -194,   148,   206,   -46,  -194,   251,  -194,    19,  -194,
-      42,  -194,  -194,  -194,   260,   274,  -194,  -194,  -194,   174,
-    -194,   219,  -194,  -194,  -194,  -194,   288,  -194,  -194,  -194,
-    -194,  -194,  -194,   186,   229,   569,   294,   239,   189,  -194,
-     182,    -3,  -194,  -194,  -194,  -194,  -194,   635,   -10,   206,
-     -16,   206,   206,   192,  -194,   193,  -194,   109,   801,   701,
-     503,   296,   297,  -194,  -194,   897,   285,   751,   121,   206,
-    -194,   569,   197,  -194,   206,  -194,  -194,   302,  -194,  -194,
-     303,  -194,    12,  -194,    10,   145,   569,  -194,  -194,   206,
-     569,  -194,  -194,  -194,  -194,   569,   274,  -194,   206,   392,
-    -194,   201,   240,   242,   205,  -194,  -194,  -194,    75,   206,
-     217,   -16,   206,  -194,   138,  -194,     1,   155,   503,   503,
-     178,  -194,  -194,  -194,  -194,  -194,  -194,  -194,  -194,   569,
-     569,    16,  -194,   123,   218,  -194,   216,  -194,  -194,   210,
-     213,  -194,    70,  -194,   118,    70,   -18,   262,  -194,  -194,
-      -3,  -194,  -194,   215,  -194,   216,   128,   503,   220,   221,
-     206,   318,   -21,   130,  -194,   133,   301,   209,  -194,   222,
-     231,  -194,   256,   226,   751,  -194,   265,   206,  -194,  -194,
-     138,  -194,  -194,   297,  -194,  -194,  -194,   569,   115,   216,
-     264,  -194,  -194,   751,   232,  -194,  -194,   206,  -194,  -194,
-      -9,   268,   206,    67,   112,    10,  -194,   119,  -194,  -194,
-     336,   337,    70,   307,   283,  -194,  -194,   569,     3,   206,
-     206,   149,  -194,  -194,  -194,  -194,  -194,  -194,  -194,   100,
-    -194,   206,  -194,  -194,   238,   -16,   314,  -194,  -194,   503,
-    -194,  -194,   241,  -194,   136,   569,  -194,  -194,   751,  -194,
-     206,   281,   206,   -41,   206,   287,   206,   292,  -194,  -194,
-     282,   284,  -194,   569,   503,   289,   216,  -194,   153,   158,
-    -194,   359,   -21,  -194,   206,  -194,  -194,   258,    11,   206,
-     569,   216,   161,   -35,   206,   -34,   503,   -32,   206,   -31,
-     206,  -194,  -194,   254,   296,   330,   299,   290,  -194,  -194,
-    -194,   165,  -194,  -194,  -194,  -194,     6,   206,  -194,   267,
-     216,  -194,   503,   -25,   503,   296,   503,   -15,   503,   -13,
-     569,   364,  -194,   206,  -194,   206,  -194,  -194,   206,  -194,
-     168,  -194,   296,   503,   296,   296,   503,   296,   503,   263,
-    -194,   111,  -194,   270,  -194,   179,  -194,   296,   296,   296,
-     569,  -194,  -194,   304,   206,  -194,  -194,    46,  -194,   183,
-    -194,  -194,  -194
+     303,  -209,  -209,    -9,   150,   -10,    65,    46,    37,  -209,
+       7,   150,   150,  -209,   176,    47,  -209,  -209,  -209,  -209,
+    -209,  -209,  -209,  -209,  -209,  -209,    76,  -209,   -21,   178,
+     150,  -209,  -209,   122,   150,   150,   150,   150,   150,  -209,
+    -209,   463,   103,    86,  -209,   204,    94,  -209,  -209,  -209,
+     153,  -209,  -209,  -209,  -209,    84,   222,   147,   135,   144,
+    -209,   145,  -209,  -209,   254,   257,  -209,  -209,  -209,   163,
+    -209,   213,  -209,  -209,   173,  -209,  -209,   285,  -209,  -209,
+    -209,  -209,  -209,  -209,   177,   224,   623,   295,   240,   203,
+    -209,   215,     1,  -209,  -209,  -209,  -209,  -209,  -209,   703,
+      -8,   150,   150,   201,   150,   150,    10,    53,   217,   150,
+     150,   543,  -209,  -209,   212,   150,  -209,  -209,  -209,   321,
+    -209,   150,  -209,   322,  -209,     6,  -209,     5,   144,   623,
+    -209,  -209,   150,   623,  -209,  -209,  -209,  -209,   623,   257,
+    -209,   150,   383,   -14,  -209,   320,  -209,   237,  -209,    73,
+    -209,   237,   150,    22,   150,   150,   219,  -209,   226,  -209,
+     106,   872,   783,   543,   329,   334,  -209,  -209,   943,   324,
+     817,   138,   229,   284,   233,  -209,   143,  -209,    89,   143,
+     -16,   287,  -209,  -209,     1,  -209,  -209,   236,   623,  -209,
+     235,   142,   150,  -209,   623,   241,  -209,   150,  -209,  -209,
+     244,   286,   288,   246,  -209,  -209,  -209,    -1,   150,   258,
+      22,   150,  -209,   136,  -209,     2,    54,   543,   543,   199,
+    -209,  -209,  -209,  -209,  -209,  -209,  -209,  -209,   623,   623,
+      25,  -209,   154,   259,  -209,   623,  -209,   150,  -209,  -209,
+     107,   298,   150,   113,   169,     5,  -209,   137,  -209,  -209,
+     361,   366,   143,   335,   309,  -209,   156,  -209,   623,  -209,
+     235,  -209,  -209,   543,   261,   263,   150,   374,    82,   158,
+    -209,   160,   353,   243,  -209,   264,   273,  -209,   304,   269,
+     817,  -209,   311,   150,  -209,  -209,   136,  -209,  -209,   334,
+    -209,  -209,  -209,   623,   157,   235,   307,  -209,  -209,   817,
+     276,    16,  -209,   150,   323,   150,   -59,   150,   326,   150,
+     327,  -209,  -209,   306,   308,  -209,   623,   543,   314,  -209,
+     235,     8,   150,   150,   166,  -209,  -209,  -209,  -209,  -209,
+    -209,  -209,     0,  -209,   150,  -209,  -209,   279,    22,   368,
+     325,  -209,   543,  -209,  -209,   293,  -209,   223,   623,  -209,
+    -209,   817,  -209,   -43,   150,   -40,   543,   -39,   150,   -38,
+     150,  -209,  -209,   292,   329,   376,   336,  -209,   170,   181,
+    -209,   413,    82,  -209,   150,  -209,  -209,   305,   386,  -209,
+      13,   150,   623,   235,   192,   543,   -37,   543,   329,   543,
+     -35,   543,   -33,   623,   415,  -209,   340,  -209,  -209,  -209,
+     194,  -209,  -209,  -209,  -209,    11,   150,   -36,  -209,   310,
+     235,  -209,   329,   543,   329,   329,   543,   329,   543,   316,
+    -209,   121,  -209,   150,  -209,   150,  -209,  -209,   150,  -209,
+     196,  -209,  -209,   312,  -209,   329,   329,   329,   623,  -209,
+    -209,   348,   319,  -209,   198,  -209,   150,  -209,    33,  -209,
+     150,  -209,   206,  -209,  -209,   208,   349,  -209,   431,  -209
 };
 
   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -888,351 +901,370 @@
      means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       0,     6,   228,     0,     0,     0,     0,     0,     0,    18,
-       0,     0,     7,     0,     0,    15,     8,    10,    11,    13,
-      14,     9,    17,    12,    16,     0,     0,   226,     0,   220,
-     221,     0,     0,     0,     0,     0,     0,     0,    99,   100,
-       0,   138,     1,     3,     2,   104,    97,     5,     4,   227,
-       0,     0,     0,     0,   159,    25,     0,     0,     0,     0,
-       0,   105,   106,     0,     0,     0,    86,     0,     0,     0,
-      93,   160,     0,     0,   159,    95,     0,   101,     0,   102,
-       0,   218,   193,   190,     0,   212,   107,    40,    29,     0,
-      30,    31,    34,    36,    37,    39,     0,    41,   189,    35,
-      38,    32,    33,     0,     0,     0,     0,     0,   108,   109,
-     113,   175,   177,   179,   182,   181,   180,     0,   198,     0,
-       0,     0,     0,     0,    85,    66,    27,     0,     0,     0,
-       0,   161,   163,   165,   167,     0,   180,     0,     0,     0,
-      92,     0,     0,   139,     0,   191,   192,     0,    43,   194,
-       0,    44,     0,   195,     0,   159,     0,   213,   214,     0,
-       0,   112,   216,   217,   215,     0,     0,   178,     0,     0,
-      19,     0,     0,     0,     0,    20,    21,    22,     0,     0,
-       0,    64,     0,    42,    56,   166,     0,     0,     0,     0,
-       0,   202,   204,   205,   206,   207,   203,   208,   210,     0,
-       0,     0,   196,     0,     0,    94,    96,   127,   219,     0,
-       0,   183,     0,   140,   115,   135,   128,   142,   110,   111,
-     174,   176,   199,     0,   184,   187,     0,     0,     0,     0,
-       0,     0,     0,     0,   200,     0,   198,     0,    63,    65,
-      68,    28,     0,     0,     0,    47,     0,     0,    49,    55,
-      57,    26,   173,   162,   164,   209,   211,     0,     0,   172,
-       0,   171,    84,     0,     0,    45,    46,     0,   131,   136,
-       0,     0,     0,     0,     0,     0,   114,   116,   118,   134,
-       0,     0,   133,     0,   144,   185,   186,     0,     0,     0,
-       0,     0,    88,   224,   225,   223,   222,    89,    87,     0,
-      67,     0,    79,    80,    81,     0,     0,    23,    48,     0,
-      51,    50,     0,    54,     0,     0,   170,   197,     0,   137,
-       0,     0,     0,     0,     0,     0,     0,     0,   141,   117,
-       0,     0,   132,     0,     0,   146,   188,    61,     0,     0,
-      58,     0,     0,   201,     0,    24,    62,     0,     0,     0,
-       0,   168,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   129,   130,   143,   145,     0,   148,     0,    59,    90,
-      91,     0,    70,    72,    73,    74,     0,     0,    52,     0,
-     169,    83,     0,     0,     0,   120,     0,     0,     0,     0,
-       0,     0,   103,     0,    82,     0,    78,    76,     0,    75,
-       0,    53,   126,     0,   119,   122,     0,   124,     0,   147,
-     150,   153,   149,     0,    71,     0,    69,   125,   121,   123,
-       0,   154,   155,   156,     0,    77,   151,     0,   152,     0,
-     157,   158,    60
+       0,     6,   237,     0,     0,     0,     0,     0,     0,    18,
+     110,     0,     0,     7,     0,     0,    15,     8,    10,    11,
+      13,    14,     9,    17,    12,    16,     0,   103,     0,   235,
+       0,   229,   230,     0,     0,     0,     0,     0,     0,   111,
+     112,     0,     0,   105,   106,     0,   144,     1,     3,     2,
+       0,   104,     5,     4,   236,     0,     0,     0,     0,   165,
+      25,     0,   202,   199,     0,   221,   113,    40,    29,     0,
+      30,    31,    34,    36,     0,    37,    39,     0,    41,   198,
+      35,    38,    32,    33,     0,     0,     0,     0,     0,   114,
+     115,   119,   181,   183,   185,   188,   189,   187,   186,     0,
+     207,     0,     0,     0,     0,     0,     0,     0,    92,     0,
+       0,     0,    99,   166,     0,     0,    89,   200,   201,     0,
+      43,     0,   203,     0,    44,     0,   204,     0,   165,     0,
+     222,   223,     0,     0,   118,   225,   226,   224,     0,     0,
+     184,     0,     0,   165,   101,     0,   107,     0,   108,     0,
+     227,     0,     0,     0,     0,     0,     0,    91,    66,    27,
+       0,     0,     0,     0,   167,   169,   171,   173,     0,   186,
+       0,     0,     0,     0,     0,   190,     0,   146,   121,   141,
+     134,   148,   116,   117,   180,   182,   208,     0,     0,   191,
+     196,     0,     0,    98,     0,     0,   145,     0,    90,    19,
+       0,     0,     0,     0,    20,    21,    22,     0,     0,     0,
+      64,     0,    42,    56,   172,     0,     0,     0,     0,     0,
+     211,   213,   214,   215,   216,   212,   217,   219,     0,     0,
+       0,   205,     0,     0,    45,     0,    46,     0,   137,   142,
+       0,     0,     0,     0,     0,     0,   120,   122,   124,   140,
+       0,     0,   139,     0,   150,   192,     0,   193,     0,   100,
+     102,   133,   228,     0,     0,     0,     0,     0,     0,     0,
+     209,     0,   207,     0,    63,    65,    68,    28,     0,     0,
+       0,    47,     0,     0,    49,    55,    57,    26,   179,   168,
+     170,   218,   220,     0,     0,   178,     0,   177,    88,     0,
+       0,     0,   143,     0,     0,     0,     0,     0,     0,     0,
+       0,   147,   123,     0,     0,   138,     0,     0,   152,   194,
+     197,     0,     0,     0,     0,    94,   233,   234,   232,   231,
+      95,    93,     0,    67,     0,    83,    84,    85,     0,     0,
+      70,    48,     0,    51,    50,     0,    54,     0,     0,   176,
+     206,     0,   195,     0,     0,     0,     0,     0,     0,     0,
+       0,   135,   136,   149,   151,     0,   154,    61,     0,     0,
+      58,     0,     0,   210,     0,    24,    62,     0,     0,    23,
+       0,     0,     0,   174,     0,     0,     0,     0,   126,     0,
+       0,     0,     0,     0,     0,   109,     0,    59,    96,    97,
+       0,    74,    76,    77,    78,     0,     0,     0,    52,     0,
+     175,    87,   132,     0,   125,   128,     0,   130,     0,   153,
+     156,   159,   155,     0,    86,     0,    82,    80,     0,    79,
+       0,    72,    73,     0,    53,   131,   127,   129,     0,   160,
+     161,   162,     0,    75,     0,    69,     0,   157,     0,   158,
+       0,    81,     0,   163,   164,     0,     0,    60,     0,    71
 };
 
   /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -194,  -194,  -194,  -194,  -194,  -194,  -194,  -194,   -96,  -194,
-     255,   134,  -194,  -194,  -177,  -194,  -194,  -194,  -194,     8,
-       0,  -194,  -194,  -194,  -194,  -194,  -194,  -194,  -194,  -194,
-    -194,  -194,  -194,   248,  -194,  -194,  -194,   335,   326,  -194,
-    -194,  -194,   249,  -194,  -194,  -194,   129,   349,  -194,   141,
-    -193,    -8,  -194,  -194,  -194,  -194,  -194,  -194,   -11,  -194,
-    -194,   -59,  -194,     4,   223,   233,   295,   -58,   261,   266,
-     306,  -146,    94,  -136,   110,   -27,  -194,  -194,  -194,  -194,
-    -194,   -71,    -4,    91,  -194,  -194
+    -209,  -209,  -209,  -209,  -209,  -209,  -209,  -209,  -130,  -209,
+     278,   155,  -209,  -209,  -208,  -209,  -209,  -209,  -209,  -209,
+    -209,    38,    20,  -209,  -209,  -209,  -209,  -209,  -209,  -209,
+    -209,  -209,  -209,  -209,  -209,   255,  -209,  -209,  -209,   346,
+     -13,  -209,  -209,  -209,   328,  -209,  -209,  -209,   202,   347,
+    -209,   207,  -167,   -11,  -209,  -209,  -209,  -209,  -209,  -209,
+      17,  -209,  -209,   -82,  -209,  -122,   234,   238,   296,   -27,
+     330,   333,   360,  -124,  -209,  -183,  -164,   109,   -49,  -209,
+    -209,  -209,  -209,  -209,  -111,    -4,    92,  -209,  -209
 };
 
   /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,    13,    14,    15,    16,    17,    18,    19,   126,   127,
-     106,   249,   250,   251,   175,   239,   240,   180,   307,   371,
-     372,   373,   374,   375,   304,   345,    20,    21,   124,   233,
-      22,    23,    74,    75,    24,    25,    38,    39,    46,    63,
-     107,   108,   109,   155,   276,   277,   278,   212,   282,   213,
-     268,   269,   214,   284,   335,   366,   392,   409,   410,   423,
-     428,    70,    71,   131,   132,   133,   134,   135,   111,   112,
-     113,   114,   226,   115,   203,   116,   235,   200,   117,   160,
-     165,    80,   118,   297,    26,    27
+      -1,    14,    15,    16,    17,    18,    19,    20,   159,   160,
+      87,   285,   286,   287,   204,   275,   276,   209,   340,   379,
+     433,   400,   401,   402,   403,   404,   337,   375,    21,    22,
+     157,   269,    23,    24,   143,   144,    25,    26,    43,    44,
+      27,    41,    88,    89,    90,   128,   246,   247,   248,   176,
+     252,   177,   238,   239,   178,   254,   318,   366,   395,   419,
+     420,   441,   449,   112,   113,   164,   165,   166,   167,   168,
+      92,    93,    94,    95,    96,   191,    97,   232,    98,   271,
+     229,    99,   133,   138,   149,   100,   330,    28,    29
 };
 
   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
      positive, shift that token.  If negative, reduce the rule whose
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
-static const yytype_int16 yytable[] =
+static const yytype_uint16 yytable[] =
 {
-      31,   202,   138,    40,   238,   110,    37,    41,   215,   188,
-      29,   188,    30,   396,    29,   140,    30,   168,   280,   188,
-     162,   163,   279,   170,    50,   171,   260,    61,    52,    53,
-      54,    55,    56,   157,   158,   397,   293,    47,    28,   356,
-      48,     1,   136,     2,   172,   382,   384,   152,   386,   388,
-      40,    62,    72,    76,    41,   403,    81,    69,   294,   295,
-      32,    73,   320,   125,   128,   406,   139,   408,   173,    81,
-       3,   144,   187,   321,    29,   296,    30,   144,   144,   281,
-     144,   144,   174,   206,     4,     5,   241,   144,    33,   332,
-       6,    34,   169,   261,    64,     7,   217,   144,   110,   144,
-     169,   267,   136,   136,   430,    36,   161,     8,   310,    45,
-     164,   225,   252,    35,   337,   128,   398,   176,   177,   431,
-      78,    65,   378,   211,   315,     9,   231,   317,   346,   215,
-     -98,   232,   157,   158,   186,    76,   157,   158,   324,    10,
-     208,   258,   259,   421,    11,   350,    12,    42,   242,   325,
-     216,   341,   234,   143,   144,   219,   342,   157,   158,   291,
-      49,   136,   136,   422,   222,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   236,   157,   158,   128,   243,
-     270,   270,   202,   326,   271,   271,    29,   244,    30,   272,
-     272,    58,   273,   273,   327,   255,   256,   257,    51,   314,
-     136,   323,    59,   157,   158,    57,   274,   274,    41,    60,
-      29,    41,    30,   159,    43,   245,    44,    66,   338,   339,
-     181,   182,   246,   119,   120,   247,    81,   121,   122,   336,
-     275,   288,   204,   144,   262,   263,   248,   157,   158,   286,
-     287,   298,   299,   312,   300,   301,   302,   303,    69,   353,
-      67,   355,    68,   357,    78,   359,   123,   351,   137,   319,
-     340,   144,   141,    41,   367,   144,   211,   145,    81,   368,
-     144,   216,   381,   263,   343,   225,   394,   395,    41,   416,
-     395,   146,   136,   383,   147,    81,    81,   387,   148,   389,
-     425,   144,   380,   149,   432,   144,   150,   236,   151,   153,
-     154,   156,   178,   179,   188,   201,   189,   136,   207,   209,
-     210,   227,   228,   348,   229,   230,    81,   237,    81,   264,
-      81,   265,    81,   292,   266,   283,   285,   415,   168,   136,
-     289,   290,   411,   308,   305,   306,   309,   311,   364,   322,
-     376,   316,   318,   330,   331,   379,   333,   334,   344,   347,
-      81,   349,   354,   429,    81,   136,    81,   136,   358,   136,
-     385,   136,   411,   360,   369,   361,   287,   362,   377,   390,
-     365,   412,   399,   376,   391,   420,   136,   393,   401,   136,
-     424,   136,   427,   184,   313,   400,   402,   205,   404,   413,
-     405,   376,   407,    77,    81,   414,    29,    82,    30,    83,
-      29,    82,    30,    83,   142,   218,   329,   417,    79,   426,
-     418,   253,   419,    84,    85,   223,   328,    84,    85,    86,
-      81,   220,   254,   167,   185,    87,    88,   363,   352,    87,
-      88,   221,    89,   370,     0,     0,    89,     0,    90,    91,
-      92,     0,    90,    91,    92,     0,    93,     0,     0,     0,
-      93,    94,     0,     0,     0,    94,     0,     0,     0,     0,
-      95,    96,     0,     0,    95,    96,     0,     0,    97,    98,
-       0,     0,    97,    98,     0,     0,     0,     0,    99,     0,
-       0,     0,    99,     0,   100,     0,   101,   102,   100,     0,
-     101,   102,     0,     0,   103,     0,     0,   104,   103,     0,
-       0,   104,   105,   224,     0,     0,   105,    29,    82,    30,
-      83,     0,     0,   129,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    84,    85,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    87,    88,     0,     0,
-       0,     0,     0,    89,     0,     0,     0,     0,     0,    90,
-      91,    92,     0,     0,     0,     0,     0,    93,     0,     0,
-       0,     0,    94,     0,     0,     0,     0,     0,     0,     0,
-       0,    95,    96,    29,    82,    30,    83,     0,     0,    97,
-      98,     0,     0,     0,     0,     0,     0,     0,     0,    99,
-      84,    85,     0,     0,     0,   100,     0,   101,   102,     0,
-       0,     0,    87,    88,     0,   103,     0,     0,   104,    89,
-       0,     0,     0,   130,     0,    90,    91,    92,     0,     0,
-       0,     0,     0,    93,     0,     0,     0,     0,    94,     0,
-       0,     0,     0,     0,     0,     0,     0,    95,    96,    29,
-      82,    30,    83,     0,     0,    97,    98,     0,     0,     0,
-       0,     0,     0,     0,     0,    99,    84,   166,     0,     0,
-       0,   100,     0,   101,   102,     0,     0,     0,    87,    88,
-       0,   103,     0,     0,   104,    89,     0,     0,     0,   105,
-       0,    90,    91,    92,     0,     0,     0,     0,     0,    93,
-       0,     0,     0,     0,    94,     0,     0,     0,     0,     0,
-       0,     0,     0,    95,    96,    29,    82,    30,    83,     0,
-       0,    97,    98,     0,     0,     0,     0,     0,     0,     0,
-       0,    99,    84,    85,     0,     0,     0,   100,     0,   101,
-     102,     0,     0,     0,    87,    88,     0,   103,     0,     0,
-     104,    89,     0,     0,     0,   105,     0,    90,    91,    92,
-       0,     0,     0,     0,     0,    93,    82,     0,    83,     0,
-      94,     0,     0,     0,     0,     0,     0,     0,     0,    95,
-      96,     0,    84,   166,     0,     0,     0,    97,    98,     0,
-       0,     0,     0,     0,    87,    88,     0,    99,     0,     0,
-       0,    89,     0,   100,     0,   101,   102,    90,    91,    92,
-       0,     0,     0,   103,     0,    93,   104,     0,     0,     0,
-      94,   130,     0,     0,     0,     0,     0,     0,     0,    95,
-      96,     0,     0,     0,     0,     0,     0,    97,    98,     0,
-       0,     0,     0,     0,    87,    88,     0,    99,     0,     0,
-       0,    89,     0,   100,     0,   101,   102,    90,    91,    92,
-       0,     0,     0,   103,     0,    93,   104,     0,     0,     0,
-      94,     0,     0,     0,     0,     0,     0,     0,     0,    95,
-     183,     0,     0,     0,     0,     0,     0,    97,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    99,     0,     0,
-       0,     0,     0,   100,     0,   101,   102,     0,     0,     0,
-       0,     0,     0,   103,     0,     0,   104,   190,   191,   192,
-     193,   194,   195,   196,   197,   198,   199,     0,   157,   158
+      33,    45,   274,   179,   171,   256,   231,    42,    46,    31,
+     217,    32,   249,    51,    91,    31,   217,    32,   426,   141,
+     250,   217,   199,   356,   135,   136,    55,   130,   131,   431,
+      57,    58,    59,    60,    61,   296,    39,   130,   131,   385,
+     427,   215,   387,   389,   391,   413,   181,   416,   116,   418,
+     267,   371,   152,   153,   432,   268,   372,    34,   197,   125,
+      40,   193,   169,   200,   219,   220,   221,   222,   223,   224,
+     225,   226,   227,   228,   197,   130,   131,   197,   197,   197,
+     197,   277,   197,   201,   197,   315,   251,   134,    35,    30,
+      52,    45,   453,    53,   111,   154,   155,   145,    46,   142,
+     150,   151,    91,   192,   297,   158,   161,   142,   454,    38,
+     202,   150,   106,   169,   169,   190,   343,   173,   288,   137,
+     147,   179,   175,   180,   367,   203,   428,    36,   183,   408,
+     376,   306,   352,   363,   195,   350,   216,   186,   198,   107,
+     326,   321,   130,   131,    37,    50,   278,    31,   161,    32,
+     205,   206,   240,   439,    31,   324,    32,   241,    48,   270,
+      49,   190,   242,   327,   328,   243,   348,   260,   169,   169,
+     175,    10,    46,   440,   237,    46,    47,   279,   130,   131,
+     303,    54,   244,   329,    56,   280,   307,   231,   145,   196,
+     197,   304,   353,   262,   355,   364,   357,   308,   359,   101,
+     240,   294,   295,   102,   272,   241,   245,   161,   301,   104,
+     242,   368,   369,   243,   169,   281,   291,   292,   293,    31,
+     380,    32,   210,   211,   282,   105,   302,   108,   283,   109,
+     244,   320,   382,    46,   388,   103,   130,   131,   150,   284,
+      10,   180,   309,   386,   130,   131,   132,   390,    46,   392,
+     110,   114,   111,   310,   233,   197,   130,   131,   257,   258,
+     115,   117,   150,   412,   118,   414,   347,   415,   169,   417,
+     298,   299,   319,   258,   331,   332,   333,   334,   119,   345,
+     335,   336,   370,   197,   120,   373,   396,   197,   121,   190,
+     122,   435,   123,   169,   436,   124,   437,   397,   197,   150,
+     126,   150,   127,   150,     1,   150,     2,   169,   411,   299,
+     424,   425,   445,   425,   451,   197,   147,   444,   150,   150,
+     129,   383,   456,   197,   457,   197,   156,   170,   172,   174,
+     272,   194,    10,     3,   207,   452,   169,   217,   169,   455,
+     169,   208,   169,   218,   230,   234,   235,     4,     5,   236,
+     150,   253,   255,     6,   150,   410,   150,   261,     7,   263,
+     264,   266,   265,   273,   169,   300,   421,   169,   313,   169,
+     405,   305,     8,   314,   316,   317,   322,   409,   323,   325,
+     141,   338,   339,   341,   342,   344,   349,    31,    62,    32,
+      63,   351,     9,   361,   374,   362,   354,   365,    10,   358,
+     360,   429,   405,   377,    64,    65,   187,    11,   381,   258,
+     378,   421,    12,   394,    13,   393,    67,    68,   398,   442,
+     406,   405,   422,    69,   150,   407,   434,   446,   448,    70,
+      71,    72,   423,   438,   450,   458,   188,    73,   459,   213,
+      74,   346,   150,    75,   430,   443,   150,   259,   146,   312,
+     148,   289,   311,    76,    77,   447,   290,   182,   214,   140,
+     384,    78,    79,   184,   399,     0,     0,    31,    62,    32,
+      63,   185,     0,     0,    80,     0,     0,     0,     0,     0,
+      81,     0,    82,    83,    64,    65,    66,     0,     0,     0,
+      84,     0,     0,    85,     0,     0,    67,    68,    86,   189,
+       0,     0,     0,    69,     0,     0,     0,     0,     0,    70,
+      71,    72,     0,     0,     0,     0,     0,    73,     0,     0,
+      74,     0,     0,    75,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    76,    77,     0,     0,     0,     0,     0,
+       0,    78,    79,     0,     0,     0,     0,    31,    62,    32,
+      63,     0,     0,   162,    80,     0,     0,     0,     0,     0,
+      81,     0,    82,    83,    64,    65,     0,     0,     0,     0,
+      84,     0,     0,    85,     0,     0,    67,    68,    86,     0,
+       0,     0,     0,    69,     0,     0,     0,     0,     0,    70,
+      71,    72,     0,     0,     0,     0,     0,    73,     0,     0,
+      74,     0,     0,    75,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    76,    77,     0,     0,     0,     0,     0,
+       0,    78,    79,     0,     0,     0,     0,    31,    62,    32,
+      63,     0,     0,     0,    80,     0,     0,     0,     0,     0,
+      81,     0,    82,    83,    64,    65,     0,     0,     0,     0,
+      84,     0,     0,    85,     0,     0,    67,    68,   163,     0,
+       0,     0,     0,    69,     0,     0,     0,     0,     0,    70,
+      71,    72,     0,     0,     0,     0,     0,    73,     0,     0,
+      74,     0,     0,    75,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    76,    77,     0,     0,     0,     0,     0,
+       0,    78,    79,     0,     0,     0,     0,    31,    62,    32,
+      63,     0,     0,     0,    80,     0,     0,     0,     0,     0,
+      81,     0,    82,    83,    64,   139,     0,     0,     0,     0,
+      84,     0,     0,    85,     0,     0,    67,    68,    86,     0,
+       0,     0,     0,    69,     0,     0,     0,     0,     0,    70,
+      71,    72,     0,     0,     0,     0,     0,    73,     0,     0,
+      74,     0,     0,    75,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    76,    77,     0,     0,     0,     0,     0,
+       0,    78,    79,     0,     0,     0,     0,    31,    62,    32,
+      63,     0,     0,     0,    80,     0,     0,     0,     0,     0,
+      81,     0,    82,    83,    64,    65,     0,     0,     0,     0,
+      84,     0,     0,    85,     0,     0,    67,    68,    86,     0,
+       0,     0,    62,    69,    63,     0,     0,     0,     0,    70,
+      71,    72,     0,     0,     0,     0,     0,    73,    64,   139,
+      74,     0,     0,    75,     0,     0,     0,     0,     0,     0,
+      67,    68,     0,    76,    77,     0,     0,    69,     0,     0,
+       0,    78,    79,    70,    71,    72,     0,     0,     0,     0,
+       0,    73,     0,     0,    80,     0,     0,    75,     0,     0,
+      81,     0,    82,    83,     0,     0,     0,    76,    77,     0,
+      84,     0,     0,    85,     0,    78,    79,     0,   163,     0,
+       0,     0,     0,     0,     0,    67,    68,     0,    80,     0,
+       0,     0,    69,     0,    81,     0,    82,    83,    70,    71,
+      72,     0,     0,     0,    84,     0,    73,    85,     0,     0,
+       0,     0,    75,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    76,   212,     0,     0,     0,     0,     0,     0,
+      78,     0,     0,   219,   220,   221,   222,   223,   224,   225,
+     226,   227,   228,    80,   130,   131,     0,     0,     0,    81,
+       0,    82,    83,     0,     0,     0,     0,     0,     0,    84,
+       0,     0,    85
 };
 
 static const yytype_int16 yycheck[] =
 {
-       4,   137,    73,    11,   181,    63,    10,    11,   154,     8,
-       4,     8,     6,     7,     4,    74,     6,    27,    36,     8,
-      23,    24,   215,   119,    28,    41,    10,    29,    32,    33,
-      34,    35,    36,    21,    22,    29,    57,   106,    93,    80,
-     109,     1,    69,     3,    60,    80,    80,   105,    80,    80,
-      58,    53,   101,    57,    58,    80,    60,   103,    79,    80,
-      65,   110,    71,    67,    68,    80,   112,    80,    84,    73,
-      30,   112,   130,    82,     4,    96,     6,   112,   112,    97,
-     112,   112,    98,   141,    44,    45,   182,   112,    93,   282,
-      50,    61,   110,    77,    28,    55,   155,   112,   156,   112,
-     110,    31,   129,   130,    58,    70,   110,    67,   244,    90,
-     113,   169,   111,    93,   111,   119,   110,   121,   122,    73,
-     110,    55,   111,   111,     9,    85,    51,   263,   305,   275,
-      90,    56,    21,    22,   130,   139,    21,    22,    71,    99,
-     144,   199,   200,    32,   104,     9,   106,     0,    10,    82,
-     154,    51,   179,   111,   112,   159,    56,    21,    22,   230,
-       3,   188,   189,    52,   168,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,   179,    21,    22,   182,    41,
-      62,    62,   318,    71,    66,    66,     4,    49,     6,    71,
-      71,   112,    74,    74,    82,    17,    18,    19,    61,   257,
-     227,   272,    31,    21,    22,    91,    88,    88,   212,   110,
-       4,   215,     6,    31,   106,    77,   108,     5,   289,   290,
-     111,   112,    84,    42,    43,    87,   230,    42,    43,   287,
-     112,   227,   111,   112,   111,   112,    98,    21,    22,   111,
-     112,   111,   112,   247,   111,   112,    37,    38,   103,   320,
-      80,   322,   110,   324,   110,   326,   104,   315,   110,   267,
-     111,   112,    11,   267,   111,   112,   111,     7,   272,   111,
-     112,   275,   111,   112,   301,   333,   111,   112,   282,   111,
-     112,     7,   309,   354,   110,   289,   290,   358,    69,   360,
-     111,   112,   350,     5,   111,   112,   110,   301,    69,     5,
-      61,   112,   110,   110,     8,    20,     9,   334,   111,     7,
-       7,   110,    72,   309,    72,   110,   320,   100,   322,   101,
-     324,   111,   326,     5,   111,    63,   111,   398,    27,   356,
-     110,   110,   390,    77,   112,   104,   110,    72,   334,    71,
-     344,    77,   110,     7,     7,   349,    39,    64,   110,    35,
-     354,   110,    71,   424,   358,   382,   360,   384,    71,   386,
-     356,   388,   420,    71,     5,    83,   112,    83,   110,    39,
-      81,     7,   376,   377,    75,   112,   403,    87,   111,   406,
-     110,   408,    78,   128,   250,   377,   382,   139,   384,   393,
-     386,   395,   388,    58,   398,   395,     4,     5,     6,     7,
-       4,     5,     6,     7,    78,   156,   277,   403,    59,   420,
-     406,   188,   408,    21,    22,    23,   275,    21,    22,    23,
-     424,   160,   189,   117,   129,    33,    34,   333,   318,    33,
-      34,   165,    40,   342,    -1,    -1,    40,    -1,    46,    47,
-      48,    -1,    46,    47,    48,    -1,    54,    -1,    -1,    -1,
-      54,    59,    -1,    -1,    -1,    59,    -1,    -1,    -1,    -1,
-      68,    69,    -1,    -1,    68,    69,    -1,    -1,    76,    77,
-      -1,    -1,    76,    77,    -1,    -1,    -1,    -1,    86,    -1,
-      -1,    -1,    86,    -1,    92,    -1,    94,    95,    92,    -1,
-      94,    95,    -1,    -1,   102,    -1,    -1,   105,   102,    -1,
-      -1,   105,   110,   111,    -1,    -1,   110,     4,     5,     6,
-       7,    -1,    -1,    10,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    21,    22,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    33,    34,    -1,    -1,
+       4,    12,   210,   127,   115,   188,   170,    11,    12,     4,
+       8,     6,   179,    26,    41,     4,     8,     6,     7,    27,
+      36,     8,   152,    82,    23,    24,    30,    21,    22,    65,
+      34,    35,    36,    37,    38,    10,    29,    21,    22,    82,
+      29,   163,    82,    82,    82,    82,   128,    82,    61,    82,
+      51,    51,    42,    43,    90,    56,    56,    67,   117,    86,
+      53,   143,   111,    41,    10,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,   117,    21,    22,   117,   117,   117,
+     117,   211,   117,    61,   117,   252,   102,    91,    98,    98,
+     111,   102,    59,   114,   108,    42,    43,   101,   102,   115,
+     104,   105,   129,   117,    79,   109,   110,   115,    75,    72,
+      88,   115,    28,   162,   163,   142,   280,   121,   116,   118,
+     115,   245,   116,   127,   116,   103,   115,    62,   132,   116,
+     338,   242,   116,   316,   147,   299,   163,   141,   151,    55,
+      58,   263,    21,    22,    98,    69,    10,     4,   152,     6,
+     154,   155,    63,    32,     4,   266,     6,    68,   111,   208,
+     113,   188,    73,    81,    82,    76,     9,   194,   217,   218,
+     116,    95,   176,    52,    31,   179,     0,    41,    21,    22,
+      73,     3,    93,   101,    62,    49,    73,   351,   192,   116,
+     117,    84,   303,   197,   305,   317,   307,    84,   309,    96,
+      63,   228,   229,   117,   208,    68,   117,   211,   235,   115,
+      73,   322,   323,    76,   263,    79,    17,    18,    19,     4,
+     342,     6,   116,   117,    88,    72,   237,     5,    92,    82,
+      93,   258,     9,   237,   356,    31,    21,    22,   242,   103,
+      95,   245,    73,   354,    21,    22,    31,   358,   252,   360,
+     115,   106,   108,    84,   116,   117,    21,    22,   116,   117,
+     115,     7,   266,   385,     7,   387,   293,   389,   317,   391,
+     116,   117,   116,   117,   116,   117,   116,   117,   115,   283,
+      37,    38,   116,   117,    71,   334,   116,   117,   115,   316,
+       5,   413,   115,   342,   416,    71,   418,   116,   117,   303,
+       5,   305,    62,   307,     1,   309,     3,   356,   116,   117,
+     116,   117,   116,   117,   116,   117,   115,   428,   322,   323,
+     117,   348,   116,   117,   116,   117,   109,   115,     7,     7,
+     334,    11,    95,    30,   115,   446,   385,     8,   387,   450,
+     389,   115,   391,     9,    20,   116,    62,    44,    45,   116,
+     354,    64,   116,    50,   358,   382,   360,   116,    55,   115,
+      74,   115,    74,   105,   413,   106,   393,   416,     7,   418,
+     374,    73,    69,     7,    39,    66,   115,   381,   115,     5,
+      27,   117,   109,    79,   115,    74,    79,     4,     5,     6,
+       7,   115,    89,    87,   115,    87,    73,    83,    95,    73,
+      73,   405,   406,    35,    21,    22,    23,   104,   115,   117,
+      85,   438,   109,    77,   111,    39,    33,    34,     5,   423,
+     115,   425,     7,    40,   428,    39,   116,   115,    80,    46,
+      47,    48,    92,   117,   115,    86,    53,    54,     7,   161,
+      57,   286,   446,    60,   406,   425,   450,   192,   102,   247,
+     103,   217,   245,    70,    71,   438,   218,   129,   162,    99,
+     351,    78,    79,   133,   372,    -1,    -1,     4,     5,     6,
+       7,   138,    -1,    -1,    91,    -1,    -1,    -1,    -1,    -1,
+      97,    -1,    99,   100,    21,    22,    23,    -1,    -1,    -1,
+     107,    -1,    -1,   110,    -1,    -1,    33,    34,   115,   116,
       -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,    46,
       47,    48,    -1,    -1,    -1,    -1,    -1,    54,    -1,    -1,
-      -1,    -1,    59,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    68,    69,     4,     5,     6,     7,    -1,    -1,    76,
-      77,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,
-      21,    22,    -1,    -1,    -1,    92,    -1,    94,    95,    -1,
-      -1,    -1,    33,    34,    -1,   102,    -1,    -1,   105,    40,
-      -1,    -1,    -1,   110,    -1,    46,    47,    48,    -1,    -1,
-      -1,    -1,    -1,    54,    -1,    -1,    -1,    -1,    59,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,    69,     4,
-       5,     6,     7,    -1,    -1,    76,    77,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    86,    21,    22,    -1,    -1,
-      -1,    92,    -1,    94,    95,    -1,    -1,    -1,    33,    34,
-      -1,   102,    -1,    -1,   105,    40,    -1,    -1,    -1,   110,
-      -1,    46,    47,    48,    -1,    -1,    -1,    -1,    -1,    54,
-      -1,    -1,    -1,    -1,    59,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    68,    69,     4,     5,     6,     7,    -1,
-      -1,    76,    77,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    86,    21,    22,    -1,    -1,    -1,    92,    -1,    94,
-      95,    -1,    -1,    -1,    33,    34,    -1,   102,    -1,    -1,
-     105,    40,    -1,    -1,    -1,   110,    -1,    46,    47,    48,
-      -1,    -1,    -1,    -1,    -1,    54,     5,    -1,     7,    -1,
-      59,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
-      69,    -1,    21,    22,    -1,    -1,    -1,    76,    77,    -1,
-      -1,    -1,    -1,    -1,    33,    34,    -1,    86,    -1,    -1,
-      -1,    40,    -1,    92,    -1,    94,    95,    46,    47,    48,
-      -1,    -1,    -1,   102,    -1,    54,   105,    -1,    -1,    -1,
-      59,   110,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
-      69,    -1,    -1,    -1,    -1,    -1,    -1,    76,    77,    -1,
-      -1,    -1,    -1,    -1,    33,    34,    -1,    86,    -1,    -1,
-      -1,    40,    -1,    92,    -1,    94,    95,    46,    47,    48,
-      -1,    -1,    -1,   102,    -1,    54,   105,    -1,    -1,    -1,
-      59,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    68,
-      69,    -1,    -1,    -1,    -1,    -1,    -1,    76,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,    -1,    -1,
-      -1,    -1,    -1,    92,    -1,    94,    95,    -1,    -1,    -1,
-      -1,    -1,    -1,   102,    -1,    -1,   105,    10,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    -1,    21,    22
+      57,    -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    70,    71,    -1,    -1,    -1,    -1,    -1,
+      -1,    78,    79,    -1,    -1,    -1,    -1,     4,     5,     6,
+       7,    -1,    -1,    10,    91,    -1,    -1,    -1,    -1,    -1,
+      97,    -1,    99,   100,    21,    22,    -1,    -1,    -1,    -1,
+     107,    -1,    -1,   110,    -1,    -1,    33,    34,   115,    -1,
+      -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,    46,
+      47,    48,    -1,    -1,    -1,    -1,    -1,    54,    -1,    -1,
+      57,    -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    70,    71,    -1,    -1,    -1,    -1,    -1,
+      -1,    78,    79,    -1,    -1,    -1,    -1,     4,     5,     6,
+       7,    -1,    -1,    -1,    91,    -1,    -1,    -1,    -1,    -1,
+      97,    -1,    99,   100,    21,    22,    -1,    -1,    -1,    -1,
+     107,    -1,    -1,   110,    -1,    -1,    33,    34,   115,    -1,
+      -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,    46,
+      47,    48,    -1,    -1,    -1,    -1,    -1,    54,    -1,    -1,
+      57,    -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    70,    71,    -1,    -1,    -1,    -1,    -1,
+      -1,    78,    79,    -1,    -1,    -1,    -1,     4,     5,     6,
+       7,    -1,    -1,    -1,    91,    -1,    -1,    -1,    -1,    -1,
+      97,    -1,    99,   100,    21,    22,    -1,    -1,    -1,    -1,
+     107,    -1,    -1,   110,    -1,    -1,    33,    34,   115,    -1,
+      -1,    -1,    -1,    40,    -1,    -1,    -1,    -1,    -1,    46,
+      47,    48,    -1,    -1,    -1,    -1,    -1,    54,    -1,    -1,
+      57,    -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    70,    71,    -1,    -1,    -1,    -1,    -1,
+      -1,    78,    79,    -1,    -1,    -1,    -1,     4,     5,     6,
+       7,    -1,    -1,    -1,    91,    -1,    -1,    -1,    -1,    -1,
+      97,    -1,    99,   100,    21,    22,    -1,    -1,    -1,    -1,
+     107,    -1,    -1,   110,    -1,    -1,    33,    34,   115,    -1,
+      -1,    -1,     5,    40,     7,    -1,    -1,    -1,    -1,    46,
+      47,    48,    -1,    -1,    -1,    -1,    -1,    54,    21,    22,
+      57,    -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,
+      33,    34,    -1,    70,    71,    -1,    -1,    40,    -1,    -1,
+      -1,    78,    79,    46,    47,    48,    -1,    -1,    -1,    -1,
+      -1,    54,    -1,    -1,    91,    -1,    -1,    60,    -1,    -1,
+      97,    -1,    99,   100,    -1,    -1,    -1,    70,    71,    -1,
+     107,    -1,    -1,   110,    -1,    78,    79,    -1,   115,    -1,
+      -1,    -1,    -1,    -1,    -1,    33,    34,    -1,    91,    -1,
+      -1,    -1,    40,    -1,    97,    -1,    99,   100,    46,    47,
+      48,    -1,    -1,    -1,   107,    -1,    54,   110,    -1,    -1,
+      -1,    -1,    60,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,
+      78,    -1,    -1,    10,    11,    12,    13,    14,    15,    16,
+      17,    18,    19,    91,    21,    22,    -1,    -1,    -1,    97,
+      -1,    99,   100,    -1,    -1,    -1,    -1,    -1,    -1,   107,
+      -1,    -1,   110
 };
 
   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
      symbol of state STATE-NUM.  */
 static const yytype_uint8 yystos[] =
 {
-       0,     1,     3,    30,    44,    45,    50,    55,    67,    85,
-      99,   104,   106,   115,   116,   117,   118,   119,   120,   121,
-     140,   141,   144,   145,   148,   149,   198,   199,    93,     4,
-       6,   196,    65,    93,    61,    93,    70,   196,   150,   151,
-     165,   196,     0,   106,   108,    90,   152,   106,   109,     3,
-     196,    61,   196,   196,   196,   196,   196,    91,   112,    31,
-     110,    29,    53,   153,    28,    55,     5,    80,   110,   103,
-     175,   176,   101,   110,   146,   147,   196,   151,   110,   161,
-     195,   196,     5,     7,    21,    22,    23,    33,    34,    40,
-      46,    47,    48,    54,    59,    68,    69,    76,    77,    86,
-      92,    94,    95,   102,   105,   110,   124,   154,   155,   156,
-     181,   182,   183,   184,   185,   187,   189,   192,   196,    42,
-      43,    42,    43,   104,   142,   196,   122,   123,   196,    10,
-     110,   177,   178,   179,   180,   181,   189,   110,   195,   112,
-     175,    11,   152,   111,   112,     7,     7,   110,    69,     5,
-     110,    69,   181,     5,    61,   157,   112,    21,    22,    31,
-     193,   196,    23,    24,   113,   194,    22,   184,    27,   110,
-     122,    41,    60,    84,    98,   128,   196,   196,   110,   110,
-     131,   111,   112,    69,   124,   180,   177,   181,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-     191,    20,   187,   188,   111,   147,   181,   111,   196,     7,
-       7,   111,   161,   163,   166,   185,   196,   175,   156,   196,
-     182,   183,   196,    23,   111,   181,   186,   110,    72,    72,
-     110,    51,    56,   143,   189,   190,   196,   100,   128,   129,
-     130,   122,    10,    41,    49,    77,    84,    87,    98,   125,
-     126,   127,   111,   178,   179,    17,    18,    19,   181,   181,
-      10,    77,   111,   112,   101,   111,   111,    31,   164,   165,
-      62,    66,    71,    74,    88,   112,   158,   159,   160,   164,
-      36,    97,   162,    63,   167,   111,   111,   112,   177,   110,
-     110,   195,     5,    57,    79,    80,    96,   197,   111,   112,
-     111,   112,    37,    38,   138,   112,   104,   132,    77,   110,
-     187,    72,   196,   125,   181,     9,    77,   187,   110,   165,
-      71,    82,    71,   195,    71,    82,    71,    82,   163,   160,
-       7,     7,   164,    39,    64,   168,   181,   111,   195,   195,
-     111,    51,    56,   189,   110,   139,   128,    35,   177,   110,
-       9,   181,   188,   195,    71,   195,    80,   195,    71,   195,
-      71,    83,    83,   186,   177,    81,   169,   111,   111,     5,
-     197,   133,   134,   135,   136,   137,   196,   110,   111,   196,
-     181,   111,    80,   195,    80,   177,    80,   195,    80,   195,
-      39,    75,   170,    87,   111,   112,     7,    29,   110,   196,
-     133,   111,   177,    80,   177,   177,    80,   177,    80,   171,
-     172,   181,     7,   196,   134,   195,   111,   177,   177,   177,
-     112,    32,    52,   173,   110,   111,   172,    78,   174,   195,
-      58,    73,   111
+       0,     1,     3,    30,    44,    45,    50,    55,    69,    89,
+      95,   104,   109,   111,   120,   121,   122,   123,   124,   125,
+     126,   147,   148,   151,   152,   155,   156,   159,   206,   207,
+      98,     4,     6,   204,    67,    98,    62,    98,    72,    29,
+      53,   160,   204,   157,   158,   172,   204,     0,   111,   113,
+      69,   159,   111,   114,     3,   204,    62,   204,   204,   204,
+     204,   204,     5,     7,    21,    22,    23,    33,    34,    40,
+      46,    47,    48,    54,    57,    60,    70,    71,    78,    79,
+      91,    97,    99,   100,   107,   110,   115,   129,   161,   162,
+     163,   188,   189,   190,   191,   192,   193,   195,   197,   200,
+     204,    96,   117,    31,   115,    72,    28,    55,     5,    82,
+     115,   108,   182,   183,   106,   115,   159,     7,     7,   115,
+      71,   115,     5,   115,    71,   188,     5,    62,   164,   117,
+      21,    22,    31,   201,   204,    23,    24,   118,   202,    22,
+     191,    27,   115,   153,   154,   204,   158,   115,   168,   203,
+     204,   204,    42,    43,    42,    43,   109,   149,   204,   127,
+     128,   204,    10,   115,   184,   185,   186,   187,   188,   197,
+     115,   203,     7,   204,     7,   116,   168,   170,   173,   192,
+     204,   182,   163,   204,   189,   190,   204,    23,    53,   116,
+     188,   194,   117,   182,    11,   159,   116,   117,   159,   127,
+      41,    61,    88,   103,   133,   204,   204,   115,   115,   136,
+     116,   117,    71,   129,   187,   184,   188,     8,     9,    10,
+      11,    12,    13,    14,    15,    16,    17,    18,    19,   199,
+      20,   195,   196,   116,   116,    62,   116,    31,   171,   172,
+      63,    68,    73,    76,    93,   117,   165,   166,   167,   171,
+      36,   102,   169,    64,   174,   116,   194,   116,   117,   154,
+     188,   116,   204,   115,    74,    74,   115,    51,    56,   150,
+     197,   198,   204,   105,   133,   134,   135,   127,    10,    41,
+      49,    79,    88,    92,   103,   130,   131,   132,   116,   185,
+     186,    17,    18,    19,   188,   188,    10,    79,   116,   117,
+     106,   188,   172,    73,    84,    73,   203,    73,    84,    73,
+      84,   170,   167,     7,     7,   171,    39,    66,   175,   116,
+     188,   184,   115,   115,   203,     5,    58,    81,    82,   101,
+     205,   116,   117,   116,   117,    37,    38,   145,   117,   109,
+     137,    79,   115,   195,    74,   204,   130,   188,     9,    79,
+     195,   115,   116,   203,    73,   203,    82,   203,    73,   203,
+      73,    87,    87,   194,   184,    83,   176,   116,   203,   203,
+     116,    51,    56,   197,   115,   146,   133,    35,    85,   138,
+     184,   115,     9,   188,   196,    82,   203,    82,   184,    82,
+     203,    82,   203,    39,    77,   177,   116,   116,     5,   205,
+     140,   141,   142,   143,   144,   204,   115,    39,   116,   204,
+     188,   116,   184,    82,   184,   184,    82,   184,    82,   178,
+     179,   188,     7,    92,   116,   117,     7,    29,   115,   204,
+     140,    65,    90,   139,   116,   184,   184,   184,   117,    32,
+      52,   180,   204,   141,   203,   116,   115,   179,    80,   181,
+     115,   116,   203,    59,    75,   203,   116,   116,    86,     7
 };
 
   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint8 yyr1[] =
 {
-       0,   114,   115,   115,   115,   115,   115,   115,   116,   116,
-     116,   116,   116,   116,   116,   116,   116,   116,   117,   118,
-     118,   118,   118,   119,   120,   121,   122,   123,   123,   124,
-     124,   124,   124,   124,   124,   124,   124,   124,   124,   124,
-     124,   124,   124,   124,   124,   124,   124,   125,   125,   125,
-     125,   125,   125,   125,   126,   126,   127,   127,   128,   128,
-     128,   128,   129,   129,   130,   130,   131,   131,   132,   132,
-     133,   133,   134,   134,   134,   135,   135,   136,   137,   138,
-     138,   139,   139,   140,   140,   141,   142,   142,   143,   143,
-     143,   143,   144,   145,   146,   146,   147,   148,   149,   149,
-     150,   150,   151,   152,   153,   153,   153,   154,   154,   155,
-     155,   156,   156,   156,   157,   158,   158,   159,   159,   160,
-     160,   160,   160,   160,   160,   160,   160,   161,   162,   162,
-     162,   163,   163,   163,   163,   163,   164,   164,   165,   165,
-     166,   166,   167,   167,   168,   168,   169,   169,   170,   170,
-     171,   171,   172,   173,   173,   173,   174,   174,   174,   175,
-     175,   176,   177,   177,   178,   178,   179,   179,   180,   180,
-     180,   180,   180,   180,   181,   181,   182,   182,   183,   183,
-     184,   184,   184,   184,   185,   185,   185,   186,   186,   187,
-     187,   187,   187,   187,   187,   187,   188,   188,   189,   189,
-     190,   190,   191,   191,   191,   191,   191,   191,   191,   191,
-     191,   191,   192,   193,   193,   194,   194,   194,   195,   195,
-     196,   196,   197,   197,   197,   197,   198,   199,   199
+       0,   119,   120,   120,   120,   120,   120,   120,   121,   121,
+     121,   121,   121,   121,   121,   121,   121,   121,   122,   123,
+     123,   123,   123,   124,   125,   126,   127,   128,   128,   129,
+     129,   129,   129,   129,   129,   129,   129,   129,   129,   129,
+     129,   129,   129,   129,   129,   129,   129,   130,   130,   130,
+     130,   130,   130,   130,   131,   131,   132,   132,   133,   133,
+     133,   133,   134,   134,   135,   135,   136,   136,   137,   137,
+     138,   138,   139,   139,   140,   140,   141,   141,   141,   142,
+     142,   143,   144,   145,   145,   146,   146,   147,   147,   147,
+     147,   148,   149,   149,   150,   150,   150,   150,   151,   152,
+     153,   153,   154,   155,   155,   156,   157,   157,   158,   159,
+     160,   160,   160,   161,   161,   162,   162,   163,   163,   163,
+     164,   165,   165,   166,   166,   167,   167,   167,   167,   167,
+     167,   167,   167,   168,   169,   169,   169,   170,   170,   170,
+     170,   170,   171,   171,   172,   172,   173,   173,   174,   174,
+     175,   175,   176,   176,   177,   177,   178,   178,   179,   180,
+     180,   180,   181,   181,   181,   182,   182,   183,   184,   184,
+     185,   185,   186,   186,   187,   187,   187,   187,   187,   187,
+     188,   188,   189,   189,   190,   190,   191,   191,   191,   191,
+     191,   192,   192,   192,   192,   193,   194,   194,   195,   195,
+     195,   195,   195,   195,   195,   196,   196,   197,   197,   198,
+     198,   199,   199,   199,   199,   199,   199,   199,   199,   199,
+     199,   200,   201,   201,   202,   202,   202,   203,   203,   204,
+     204,   205,   205,   205,   205,   206,   207,   207
 };
 
   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
@@ -1240,27 +1272,28 @@
 {
        0,     2,     2,     2,     2,     2,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     6,
-       6,     6,     6,     8,     9,     3,     3,     1,     3,     1,
+       6,     6,     6,     9,     9,     3,     3,     1,     3,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     2,     2,     4,     4,     1,     2,     1,
        2,     2,     4,     5,     2,     1,     0,     1,     4,     5,
       10,     4,     3,     1,     0,     1,     0,     3,     0,     5,
-       1,     3,     1,     1,     1,     2,     2,     4,     2,     1,
-       1,     0,     3,    10,     7,     5,     0,     4,     2,     2,
-       4,     4,     5,     4,     3,     1,     3,     2,     0,     2,
-       1,     3,     3,     9,     0,     1,     1,     1,     1,     1,
-       3,     3,     2,     1,     3,     0,     1,     2,     1,     5,
-       4,     6,     5,     6,     5,     6,     5,     3,     0,     3,
-       3,     2,     3,     2,     2,     1,     1,     2,     1,     4,
-       1,     3,     0,     3,     0,     2,     0,     3,     0,     2,
-       1,     3,     3,     0,     1,     1,     0,     2,     2,     0,
-       1,     2,     3,     1,     3,     1,     2,     1,     5,     6,
-       4,     3,     3,     3,     3,     1,     3,     1,     2,     1,
-       1,     1,     1,     3,     3,     4,     4,     1,     3,     1,
-       1,     2,     2,     1,     2,     2,     1,     3,     1,     3,
-       1,     3,     1,     1,     1,     1,     1,     1,     1,     2,
-       1,     2,     1,     1,     1,     1,     1,     1,     1,     3,
-       1,     1,     1,     1,     1,     1,     2,     2,     0
+       0,     8,     1,     1,     1,     3,     1,     1,     1,     2,
+       2,     4,     2,     1,     1,     0,     3,    10,     7,     4,
+       5,     5,     0,     4,     2,     2,     4,     4,     5,     4,
+       3,     1,     3,     1,     2,     2,     1,     3,     3,     9,
+       0,     1,     1,     1,     1,     1,     3,     3,     2,     1,
+       3,     0,     1,     2,     1,     5,     4,     6,     5,     6,
+       5,     6,     5,     3,     0,     3,     3,     2,     3,     2,
+       2,     1,     1,     2,     1,     4,     1,     3,     0,     3,
+       0,     2,     0,     3,     0,     2,     1,     3,     3,     0,
+       1,     1,     0,     2,     2,     0,     1,     2,     3,     1,
+       3,     1,     2,     1,     5,     6,     4,     3,     3,     3,
+       3,     1,     3,     1,     2,     1,     1,     1,     1,     1,
+       3,     3,     4,     4,     5,     6,     1,     3,     1,     1,
+       2,     2,     1,     2,     2,     1,     3,     1,     3,     1,
+       3,     1,     1,     1,     1,     1,     1,     1,     2,     1,
+       2,     1,     1,     1,     1,     1,     1,     1,     3,     1,
+       1,     1,     1,     1,     1,     2,     2,     0
 };
 
 
@@ -1757,803 +1790,833 @@
   switch (yytype)
     {
           case 3: /* TOKEN_COMMAND  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).string_value_) != nullptr) {
     delete ((*yyvaluep).string_value_);
   }
 }
-#line 1767 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1800 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
     case 4: /* TOKEN_NAME  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).string_value_) != nullptr) {
     delete ((*yyvaluep).string_value_);
   }
 }
-#line 1777 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1810 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
     case 5: /* TOKEN_STRING_SINGLE_QUOTED  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).string_value_) != nullptr) {
     delete ((*yyvaluep).string_value_);
   }
 }
-#line 1787 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1820 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
     case 6: /* TOKEN_STRING_DOUBLE_QUOTED  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).string_value_) != nullptr) {
     delete ((*yyvaluep).string_value_);
   }
 }
-#line 1797 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1830 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
     case 7: /* TOKEN_UNSIGNED_NUMVAL  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).numeric_literal_value_) != nullptr) {
     delete ((*yyvaluep).numeric_literal_value_);
   }
 }
-#line 1807 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1840 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 116: /* sql_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 121: /* sql_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).statement_) != nullptr) {
     delete ((*yyvaluep).statement_);
   }
 }
-#line 1817 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1850 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 117: /* quit_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 122: /* quit_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).quit_statement_) != nullptr) {
     delete ((*yyvaluep).quit_statement_);
   }
 }
-#line 1827 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1860 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 118: /* alter_table_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 123: /* alter_table_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).statement_) != nullptr) {
     delete ((*yyvaluep).statement_);
   }
 }
-#line 1837 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1870 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 119: /* create_table_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 124: /* create_table_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).create_table_statement_) != nullptr) {
     delete ((*yyvaluep).create_table_statement_);
   }
 }
-#line 1847 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1880 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 120: /* create_index_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 125: /* create_index_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).statement_) != nullptr) {
     delete ((*yyvaluep).statement_);
   }
 }
-#line 1857 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1890 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 121: /* drop_table_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 126: /* drop_table_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).drop_table_statement_) != nullptr) {
     delete ((*yyvaluep).drop_table_statement_);
   }
 }
-#line 1867 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1900 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 122: /* column_def  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 127: /* column_def  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).attribute_definition_) != nullptr) {
     delete ((*yyvaluep).attribute_definition_);
   }
 }
-#line 1877 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1910 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 123: /* column_def_commalist  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 128: /* column_def_commalist  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).attribute_definition_list_) != nullptr) {
     delete ((*yyvaluep).attribute_definition_list_);
   }
 }
-#line 1887 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1920 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 124: /* data_type  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 129: /* data_type  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).data_type_) != nullptr) {
     delete ((*yyvaluep).data_type_);
   }
 }
-#line 1897 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1930 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 125: /* column_constraint_def  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 130: /* column_constraint_def  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).column_constraint_) != nullptr) {
     delete ((*yyvaluep).column_constraint_);
   }
 }
-#line 1907 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1940 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 126: /* column_constraint_def_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 131: /* column_constraint_def_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).column_constraint_list_) != nullptr) {
     delete ((*yyvaluep).column_constraint_list_);
   }
 }
-#line 1917 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1950 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 127: /* opt_column_constraint_def_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 132: /* opt_column_constraint_def_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).column_constraint_list_) != nullptr) {
     delete ((*yyvaluep).column_constraint_list_);
   }
 }
-#line 1927 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1960 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 131: /* opt_column_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 136: /* opt_column_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).attribute_list_) != nullptr) {
     delete ((*yyvaluep).attribute_list_);
   }
 }
-#line 1937 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1970 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 132: /* opt_block_properties  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 137: /* opt_block_properties  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).block_properties_) != nullptr) {
     delete ((*yyvaluep).block_properties_);
   }
 }
-#line 1947 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 1980 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 133: /* key_value_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 138: /* opt_partition_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
+      {
+  if (((*yyvaluep).partition_clause_) != nullptr) {
+    delete ((*yyvaluep).partition_clause_);
+  }
+}
+#line 1990 "SqlParser_gen.cpp" /* yacc.c:1257  */
+        break;
+
+    case 139: /* partition_type  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
+      {
+  if (((*yyvaluep).string_value_) != nullptr) {
+    delete ((*yyvaluep).string_value_);
+  }
+}
+#line 2000 "SqlParser_gen.cpp" /* yacc.c:1257  */
+        break;
+
+    case 140: /* key_value_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).key_value_list_) != nullptr) {
     delete ((*yyvaluep).key_value_list_);
   }
 }
-#line 1957 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2010 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 134: /* key_value  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 141: /* key_value  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).key_value_) != nullptr) {
     delete ((*yyvaluep).key_value_);
   }
 }
-#line 1967 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2020 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 135: /* key_string_value  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 142: /* key_string_value  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).key_string_value_) != nullptr) {
     delete ((*yyvaluep).key_string_value_);
   }
 }
-#line 1977 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2030 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 136: /* key_string_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 143: /* key_string_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).key_string_list_) != nullptr) {
     delete ((*yyvaluep).key_string_list_);
   }
 }
-#line 1987 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2040 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 137: /* key_integer_value  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 144: /* key_integer_value  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).key_integer_value_) != nullptr) {
     delete ((*yyvaluep).key_integer_value_);
   }
 }
-#line 1997 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2050 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 138: /* index_type  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 145: /* index_type  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).string_value_) != nullptr) {
     delete ((*yyvaluep).string_value_);
   }
 }
-#line 2007 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2060 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 139: /* opt_index_properties  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 146: /* opt_index_properties  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).key_value_list_) != nullptr) {
     delete ((*yyvaluep).key_value_list_);
   }
 }
-#line 2017 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2070 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 140: /* insert_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 147: /* insert_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).insert_statement_) != nullptr) {
     delete ((*yyvaluep).insert_statement_);
   }
 }
-#line 2027 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2080 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 141: /* copy_from_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 148: /* copy_from_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).copy_from_statement_) != nullptr) {
     delete ((*yyvaluep).copy_from_statement_);
   }
 }
-#line 2037 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2090 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 142: /* opt_copy_from_params  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 149: /* opt_copy_from_params  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).copy_from_params_) != nullptr) {
     delete ((*yyvaluep).copy_from_params_);
   }
 }
-#line 2047 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2100 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 143: /* copy_from_params  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 150: /* copy_from_params  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).copy_from_params_) != nullptr) {
     delete ((*yyvaluep).copy_from_params_);
   }
 }
-#line 2057 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2110 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 144: /* update_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 151: /* update_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).update_statement_) != nullptr) {
     delete ((*yyvaluep).update_statement_);
   }
 }
-#line 2067 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2120 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 145: /* delete_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 152: /* delete_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).delete_statement_) != nullptr) {
     delete ((*yyvaluep).delete_statement_);
   }
 }
-#line 2077 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2130 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 146: /* assignment_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 153: /* assignment_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).assignment_list_) != nullptr) {
     delete ((*yyvaluep).assignment_list_);
   }
 }
-#line 2087 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2140 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 147: /* assignment_item  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 154: /* assignment_item  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).assignment_) != nullptr) {
     delete ((*yyvaluep).assignment_);
   }
 }
-#line 2097 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2150 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 148: /* select_statement  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 155: /* select_statement  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).select_statement_) != nullptr) {
     delete ((*yyvaluep).select_statement_);
   }
 }
-#line 2107 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2160 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 149: /* opt_with_clause  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 156: /* with_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).with_list_) != nullptr) {
     delete ((*yyvaluep).with_list_);
   }
 }
-#line 2117 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2170 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 150: /* with_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 157: /* with_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).with_list_) != nullptr) {
     delete ((*yyvaluep).with_list_);
   }
 }
-#line 2127 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2180 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 151: /* with_list_element  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 158: /* with_list_element  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).with_list_element_) != nullptr) {
     delete ((*yyvaluep).with_list_element_);
   }
 }
-#line 2137 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2190 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 152: /* select_query  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 159: /* select_query  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).select_query_) != nullptr) {
     delete ((*yyvaluep).select_query_);
   }
 }
-#line 2147 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2200 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 154: /* selection  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 161: /* selection  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).selection_) != nullptr) {
     delete ((*yyvaluep).selection_);
   }
 }
-#line 2157 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2210 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 155: /* selection_item_commalist  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 162: /* selection_item_commalist  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).selection_list_) != nullptr) {
     delete ((*yyvaluep).selection_list_);
   }
 }
-#line 2167 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2220 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 156: /* selection_item  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 163: /* selection_item  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).selection_item_) != nullptr) {
     delete ((*yyvaluep).selection_item_);
   }
 }
-#line 2177 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2230 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 157: /* from_clause  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 164: /* from_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).table_reference_list_) != nullptr) {
     delete ((*yyvaluep).table_reference_list_);
   }
 }
-#line 2187 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2240 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 161: /* subquery_expression  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 168: /* subquery_expression  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).subquery_expression_) != nullptr) {
     delete ((*yyvaluep).subquery_expression_);
   }
 }
-#line 2197 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2250 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 162: /* opt_sample_clause  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 169: /* opt_sample_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).opt_sample_clause_) != nullptr) {
     delete ((*yyvaluep).opt_sample_clause_);
   }
 }
-#line 2207 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2260 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 163: /* table_reference  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 170: /* table_reference  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).table_reference_) != nullptr) {
     delete ((*yyvaluep).table_reference_);
   }
 }
-#line 2217 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2270 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 164: /* table_reference_signature  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 171: /* table_reference_signature  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).table_reference_signature_) != nullptr) {
     delete ((*yyvaluep).table_reference_signature_);
   }
 }
-#line 2227 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2280 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 165: /* table_reference_signature_primary  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 172: /* table_reference_signature_primary  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).table_reference_signature_) != nullptr) {
     delete ((*yyvaluep).table_reference_signature_);
   }
 }
-#line 2237 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2290 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 166: /* table_reference_commalist  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 173: /* table_reference_commalist  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).table_reference_list_) != nullptr) {
     delete ((*yyvaluep).table_reference_list_);
   }
 }
-#line 2247 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2300 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 167: /* opt_group_by_clause  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 174: /* opt_group_by_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).opt_group_by_clause_) != nullptr) {
     delete ((*yyvaluep).opt_group_by_clause_);
   }
 }
-#line 2257 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2310 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 168: /* opt_having_clause  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 175: /* opt_having_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).opt_having_clause_) != nullptr) {
     delete ((*yyvaluep).opt_having_clause_);
   }
 }
-#line 2267 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2320 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 169: /* opt_order_by_clause  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 176: /* opt_order_by_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).opt_order_by_clause_) != nullptr) {
     delete ((*yyvaluep).opt_order_by_clause_);
   }
 }
-#line 2277 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2330 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 170: /* opt_limit_clause  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 177: /* opt_limit_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).opt_limit_clause_) != nullptr) {
     delete ((*yyvaluep).opt_limit_clause_);
   }
 }
-#line 2287 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2340 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 171: /* order_commalist  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 178: /* order_commalist  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).order_commalist_) != nullptr) {
     delete ((*yyvaluep).order_commalist_);
   }
 }
-#line 2297 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2350 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 172: /* order_item  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 179: /* order_item  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).order_item_) != nullptr) {
     delete ((*yyvaluep).order_item_);
   }
 }
-#line 2307 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2360 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 173: /* opt_order_direction  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 180: /* opt_order_direction  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).order_direction_) != nullptr) {
     delete ((*yyvaluep).order_direction_);
   }
 }
-#line 2317 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2370 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 174: /* opt_nulls_first  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 181: /* opt_nulls_first  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).order_direction_) != nullptr) {
     delete ((*yyvaluep).order_direction_);
   }
 }
-#line 2327 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2380 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 175: /* opt_where_clause  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 182: /* opt_where_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).predicate_) != nullptr) {
     delete ((*yyvaluep).predicate_);
   }
 }
-#line 2337 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2390 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 176: /* where_clause  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 183: /* where_clause  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).predicate_) != nullptr) {
     delete ((*yyvaluep).predicate_);
   }
 }
-#line 2347 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2400 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 177: /* or_expression  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 184: /* or_expression  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).predicate_) != nullptr) {
     delete ((*yyvaluep).predicate_);
   }
 }
-#line 2357 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2410 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 178: /* and_expression  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 185: /* and_expression  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).predicate_) != nullptr) {
     delete ((*yyvaluep).predicate_);
   }
 }
-#line 2367 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2420 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 179: /* not_expression  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 186: /* not_expression  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).predicate_) != nullptr) {
     delete ((*yyvaluep).predicate_);
   }
 }
-#line 2377 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2430 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 180: /* predicate_expression_base  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 187: /* predicate_expression_base  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).predicate_) != nullptr) {
     delete ((*yyvaluep).predicate_);
   }
 }
-#line 2387 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2440 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 181: /* add_expression  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 188: /* add_expression  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).expression_) != nullptr) {
     delete ((*yyvaluep).expression_);
   }
 }
-#line 2397 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2450 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 182: /* multiply_expression  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 189: /* multiply_expression  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).expression_) != nullptr) {
     delete ((*yyvaluep).expression_);
   }
 }
-#line 2407 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2460 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 183: /* unary_expression  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 190: /* unary_expression  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).expression_) != nullptr) {
     delete ((*yyvaluep).expression_);
   }
 }
-#line 2417 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2470 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 184: /* expression_base  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 191: /* expression_base  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).expression_) != nullptr) {
     delete ((*yyvaluep).expression_);
   }
 }
-#line 2427 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2480 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 185: /* function_call  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 192: /* function_call  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).function_call_) != nullptr) {
     delete ((*yyvaluep).function_call_);
   }
 }
-#line 2437 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2490 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 186: /* expression_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 193: /* extract_function  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
+      {
+  if (((*yyvaluep).expression_) != nullptr) {
+    delete ((*yyvaluep).expression_);
+  }
+}
+#line 2500 "SqlParser_gen.cpp" /* yacc.c:1257  */
+        break;
+
+    case 194: /* expression_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).expression_list_) != nullptr) {
     delete ((*yyvaluep).expression_list_);
   }
 }
-#line 2447 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2510 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 187: /* literal_value  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 195: /* literal_value  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).literal_value_) != nullptr) {
     delete ((*yyvaluep).literal_value_);
   }
 }
-#line 2457 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2520 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 188: /* literal_value_commalist  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 196: /* literal_value_commalist  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).literal_value_list_) != nullptr) {
     delete ((*yyvaluep).literal_value_list_);
   }
 }
-#line 2467 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2530 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 189: /* attribute_ref  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 197: /* attribute_ref  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).attribute_) != nullptr) {
     delete ((*yyvaluep).attribute_);
   }
 }
-#line 2477 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2540 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 190: /* attribute_ref_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 198: /* attribute_ref_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).attribute_list_) != nullptr) {
     delete ((*yyvaluep).attribute_list_);
   }
 }
-#line 2487 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2550 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 191: /* comparison_operation  */
-#line 510 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 199: /* comparison_operation  */
+#line 525 "../SqlParser.ypp" /* yacc.c:1257  */
       { }
-#line 2493 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2556 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 192: /* unary_operation  */
-#line 511 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 200: /* unary_operation  */
+#line 526 "../SqlParser.ypp" /* yacc.c:1257  */
       { }
-#line 2499 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2562 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 193: /* add_operation  */
-#line 512 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 201: /* add_operation  */
+#line 527 "../SqlParser.ypp" /* yacc.c:1257  */
       { }
-#line 2505 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2568 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 194: /* multiply_operation  */
-#line 512 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 202: /* multiply_operation  */
+#line 527 "../SqlParser.ypp" /* yacc.c:1257  */
       { }
-#line 2511 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2574 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 195: /* name_commalist  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 203: /* name_commalist  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).string_list_) != nullptr) {
     delete ((*yyvaluep).string_list_);
   }
 }
-#line 2521 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2584 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 196: /* any_name  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 204: /* any_name  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).string_value_) != nullptr) {
     delete ((*yyvaluep).string_value_);
   }
 }
-#line 2531 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2594 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 197: /* boolean_value  */
-#line 509 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 205: /* boolean_value  */
+#line 524 "../SqlParser.ypp" /* yacc.c:1257  */
       { }
-#line 2537 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2600 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 198: /* command  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 206: /* command  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).command_) != nullptr) {
     delete ((*yyvaluep).command_);
   }
 }
-#line 2547 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2610 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
-    case 199: /* command_argument_list  */
-#line 514 "../SqlParser.ypp" /* yacc.c:1257  */
+    case 207: /* command_argument_list  */
+#line 529 "../SqlParser.ypp" /* yacc.c:1257  */
       {
   if (((*yyvaluep).command_argument_list_) != nullptr) {
     delete ((*yyvaluep).command_argument_list_);
   }
 }
-#line 2557 "SqlParser_gen.cpp" /* yacc.c:1257  */
+#line 2620 "SqlParser_gen.cpp" /* yacc.c:1257  */
         break;
 
 
@@ -2845,148 +2908,148 @@
   switch (yyn)
     {
         case 2:
-#line 523 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 538 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     *parsedStatement = (yyvsp[-1].statement_);
     YYACCEPT;
   }
-#line 2854 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2917 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 3:
-#line 527 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 542 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     *parsedStatement = (yyvsp[-1].statement_);
     YYACCEPT;
   }
-#line 2863 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2926 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 4:
-#line 531 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 546 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     *parsedStatement = (yyvsp[-1].command_);
     YYACCEPT;
   }
-#line 2872 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2935 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 5:
-#line 535 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 550 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     *parsedStatement = (yyvsp[-1].command_);
     YYACCEPT;
   }
-#line 2881 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2944 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 6:
-#line 539 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 554 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     YYABORT;
   }
-#line 2889 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2952 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 7:
-#line 542 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 557 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     // Regular yyparse() return codes are non-negative, so use a negative one here.
     return -1;
   }
-#line 2898 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2961 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 8:
-#line 549 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 564 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].statement_);
   }
-#line 2906 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2969 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 9:
-#line 552 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 567 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].copy_from_statement_);
   }
-#line 2914 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2977 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 10:
-#line 555 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 570 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].create_table_statement_);
   }
-#line 2922 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2985 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 11:
-#line 558 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 573 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].statement_);
   }
-#line 2930 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 2993 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 12:
-#line 561 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 576 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].delete_statement_);
   }
-#line 2938 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3001 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 13:
-#line 564 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 579 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].drop_table_statement_);
   }
-#line 2946 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3009 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 14:
-#line 567 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 582 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].insert_statement_);
   }
-#line 2954 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3017 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 15:
-#line 570 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 585 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].quit_statement_);
   }
-#line 2962 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3025 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 16:
-#line 573 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 588 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].select_statement_);
   }
-#line 2970 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3033 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 17:
-#line 576 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 591 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.statement_) = (yyvsp[0].update_statement_);
   }
-#line 2978 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3041 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 18:
-#line 582 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 597 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.quit_statement_) = new quickstep::ParseStatementQuit((yylsp[0]).first_line, (yylsp[0]).first_column);
   }
-#line 2986 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3049 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 19:
-#line 588 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 603 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-3].string_value_);
     delete (yyvsp[0].attribute_definition_);
@@ -2994,22 +3057,22 @@
     NotSupported(&(yylsp[-5]), yyscanner, "ALTER statements");
     YYERROR;
   }
-#line 2998 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3061 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 20:
-#line 595 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 610 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-3].string_value_);
     (yyval.statement_) = nullptr;
     NotSupported(&(yylsp[-5]), yyscanner, "ALTER statements");
     YYERROR;
   }
-#line 3009 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3072 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 21:
-#line 601 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 616 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-3].string_value_);
     delete (yyvsp[0].string_value_);
@@ -3017,11 +3080,11 @@
     NotSupported(&(yylsp[-5]), yyscanner, "ALTER statements");
     YYERROR;
   }
-#line 3021 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3084 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 22:
-#line 608 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 623 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-3].string_value_);
     delete (yyvsp[0].string_value_);
@@ -3029,19 +3092,19 @@
     NotSupported(&(yylsp[-5]), yyscanner, "ALTER statements");
     YYERROR;
   }
-#line 3033 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3096 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 23:
-#line 617 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 632 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.create_table_statement_) = new quickstep::ParseStatementCreateTable((yylsp[-7]).first_line, (yylsp[-7]).first_column, (yyvsp[-5].string_value_), (yyvsp[-3].attribute_definition_list_), (yyvsp[0].block_properties_));
+    (yyval.create_table_statement_) = new quickstep::ParseStatementCreateTable((yylsp[-8]).first_line, (yylsp[-8]).first_column, (yyvsp[-6].string_value_), (yyvsp[-4].attribute_definition_list_), (yyvsp[-1].block_properties_), (yyvsp[0].partition_clause_));
   }
-#line 3041 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3104 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 24:
-#line 622 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 637 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     if ((yyvsp[0].key_value_list_)) {
       (yyval.statement_) = new quickstep::ParseStatementCreateIndex((yylsp[-8]).first_line, (yylsp[-8]).first_column, (yyvsp[-6].string_value_), (yyvsp[-4].string_value_), (yyvsp[-3].attribute_list_), (yyvsp[-1].string_value_), (yylsp[0]).first_line, (yylsp[0]).first_column, (yyvsp[0].key_value_list_));
@@ -3049,153 +3112,153 @@
       (yyval.statement_) = new quickstep::ParseStatementCreateIndex((yylsp[-8]).first_line, (yylsp[-8]).first_column, (yyvsp[-6].string_value_), (yyvsp[-4].string_value_), (yyvsp[-3].attribute_list_), (yyvsp[-1].string_value_));
     }
   }
-#line 3053 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3116 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 25:
-#line 631 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 646 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.drop_table_statement_) = new quickstep::ParseStatementDropTable((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[0].string_value_));
   }
-#line 3061 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3124 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 26:
-#line 636 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 651 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.attribute_definition_) = new quickstep::ParseAttributeDefinition((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-2].string_value_), (yyvsp[-1].data_type_), (yyvsp[0].column_constraint_list_));
   }
-#line 3069 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3132 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 27:
-#line 641 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 656 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.attribute_definition_list_) = new quickstep::PtrList<quickstep::ParseAttributeDefinition>();
     (yyval.attribute_definition_list_)->push_back((yyvsp[0].attribute_definition_));
   }
-#line 3078 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3141 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 28:
-#line 645 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 660 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.attribute_definition_list_) = (yyvsp[-2].attribute_definition_list_);
     (yyval.attribute_definition_list_)->push_back((yyvsp[0].attribute_definition_));
   }
-#line 3087 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3150 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 29:
-#line 651 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 666 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = nullptr;
     NotSupported(&(yylsp[0]), yyscanner, "BIT data type");
     YYERROR;
   }
-#line 3097 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3160 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 30:
-#line 656 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 671 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kDatetime));
   }
-#line 3105 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3168 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 31:
-#line 659 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 674 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kDatetime));
   }
-#line 3113 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3176 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 32:
-#line 662 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 677 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = nullptr;
     NotSupported(&(yylsp[0]), yyscanner, "TIME data type");
     YYERROR;
   }
-#line 3123 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3186 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 33:
-#line 667 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 682 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kDatetime));
   }
-#line 3131 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3194 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 34:
-#line 670 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 685 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kDouble));
   }
-#line 3139 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3202 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 35:
-#line 673 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 688 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kDouble));
   }
-#line 3147 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3210 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 36:
-#line 676 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 691 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kDouble));
   }
-#line 3155 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3218 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 37:
-#line 679 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 694 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kFloat));
   }
-#line 3163 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3226 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 38:
-#line 682 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 697 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kInt));
   }
-#line 3171 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3234 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 39:
-#line 685 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 700 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kInt));
   }
-#line 3179 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3242 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 40:
-#line 688 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 703 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kLong));
   }
-#line 3187 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3250 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 41:
-#line 691 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 706 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kLong));
   }
-#line 3195 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3258 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 42:
-#line 694 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 709 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     /**
      * NOTE(chasseur): This pattern exhibits a shift/reduce conflict with the
@@ -3208,27 +3271,27 @@
         "or YEARMONTH INTERVAL");
     YYERROR;
   }
-#line 3212 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3275 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 43:
-#line 706 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 721 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kDatetimeInterval));
   }
-#line 3220 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3283 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 44:
-#line 709 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 724 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.data_type_) = new quickstep::ParseDataType(quickstep::TypeFactory::GetType(quickstep::kYearMonthInterval));
   }
-#line 3228 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3291 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 45:
-#line 712 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 727 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     if ((yyvsp[-1].numeric_literal_value_)->float_like()) {
       delete (yyvsp[-1].numeric_literal_value_);
@@ -3247,11 +3310,11 @@
       }
     }
   }
-#line 3251 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3314 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 46:
-#line 730 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 745 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     if ((yyvsp[-1].numeric_literal_value_)->float_like()) {
       delete (yyvsp[-1].numeric_literal_value_);
@@ -3270,69 +3333,69 @@
       }
     }
   }
-#line 3274 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3337 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 47:
-#line 750 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 765 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_) = new quickstep::ParseColumnConstraintNull((yylsp[0]).first_line, (yylsp[0]).first_column);
   }
-#line 3282 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3345 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 48:
-#line 753 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 768 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_) = new quickstep::ParseColumnConstraintNotNull((yylsp[-1]).first_line, (yylsp[-1]).first_column);
   }
-#line 3290 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3353 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 49:
-#line 756 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 771 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_) = nullptr;
     NotSupported(&(yylsp[0]), yyscanner, "Column Constraints (UNIQUE)");
     YYERROR;
   }
-#line 3300 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3363 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 50:
-#line 761 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 776 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_) = nullptr;
     NotSupported(&(yylsp[-1]), yyscanner, "Column Constraints (PRIMARY KEY)");
     YYERROR;
   }
-#line 3310 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3373 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 51:
-#line 766 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 781 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_) = nullptr;
     delete (yyvsp[0].literal_value_);
     NotSupported(&(yylsp[-1]), yyscanner, "Column Constraints (DEFAULT)");
     YYERROR;
   }
-#line 3321 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3384 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 52:
-#line 772 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 787 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_) = nullptr;
     delete (yyvsp[-1].predicate_);
     NotSupported(&(yylsp[-3]), yyscanner, "Column Constraints (CHECK)");
     YYERROR;
   }
-#line 3332 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3395 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 53:
-#line 778 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 793 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_) = nullptr;
     delete (yyvsp[-3].string_value_);
@@ -3340,65 +3403,65 @@
     NotSupported(&(yylsp[-4]), yyscanner, "Foreign Keys");
     YYERROR;
   }
-#line 3344 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3407 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 54:
-#line 787 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 802 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_list_) = (yyvsp[-1].column_constraint_list_);
     (yyval.column_constraint_list_)->push_back((yyvsp[0].column_constraint_));
   }
-#line 3353 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3416 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 55:
-#line 791 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 806 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_list_) = new quickstep::PtrList<quickstep::ParseColumnConstraint>();
     (yyval.column_constraint_list_)->push_back((yyvsp[0].column_constraint_));
   }
-#line 3362 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3425 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 56:
-#line 797 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 812 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_list_) = nullptr;
   }
-#line 3370 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3433 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 57:
-#line 800 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 815 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.column_constraint_list_) = (yyvsp[0].column_constraint_list_);
   }
-#line 3378 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3441 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 58:
-#line 805 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 820 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-1].string_list_);
     NotSupported(&(yylsp[-3]), yyscanner, "Table Constraints (UNIQUE)");
     YYERROR;
   }
-#line 3388 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3451 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 59:
-#line 810 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 825 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-1].string_list_);
     NotSupported(&(yylsp[-4]), yyscanner, "Table Constraints (PRIMARY KEY)");
     YYERROR;
   }
-#line 3398 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3461 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 60:
-#line 815 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 830 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-6].string_list_);
     delete (yyvsp[-3].string_value_);
@@ -3406,155 +3469,203 @@
     NotSupported(&(yylsp[-9]), yyscanner, "Table Constraints (FOREIGN KEY)");
     YYERROR;
   }
-#line 3410 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3473 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 61:
-#line 822 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 837 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-1].predicate_);
     NotSupported(&(yylsp[-3]), yyscanner, "Table Constraints (CHECK)");
     YYERROR;
   }
-#line 3420 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3483 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 62:
-#line 829 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 844 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     NotSupported(&(yylsp[-2]), yyscanner, "Table Constraints");
     YYERROR;
   }
-#line 3429 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3492 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 63:
-#line 833 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 848 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     NotSupported(&(yylsp[0]), yyscanner, "Table Constraints");
     YYERROR;
   }
-#line 3438 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3501 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 64:
-#line 839 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 854 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     /* $$ = nullptr; */
   }
-#line 3446 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3509 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 65:
-#line 842 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 857 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     /* $$ = $1; */
   }
-#line 3454 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3517 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 66:
-#line 847 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 862 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.attribute_list_) = nullptr;
   }
-#line 3462 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3525 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 67:
-#line 850 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 865 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.attribute_list_) = (yyvsp[-1].attribute_list_);
   }
-#line 3470 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3533 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 68:
-#line 855 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 870 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.block_properties_) = nullptr;
   }
-#line 3478 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3541 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 69:
-#line 858 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 873 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.block_properties_) = new quickstep::ParseBlockProperties((yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-1].key_value_list_));
   }
-#line 3486 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3549 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 70:
-#line 863 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 878 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.partition_clause_) = nullptr;
+  }
+#line 3557 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 71:
+#line 881 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    if ((yyvsp[0].numeric_literal_value_)->float_like()) {
+      delete (yyvsp[0].numeric_literal_value_);
+      (yyval.partition_clause_) = NULL;
+      quickstep_yyerror(&(yylsp[0]), yyscanner, NULL, "NUMBER OF PARTITIONS must be an integer");
+      YYERROR;
+    } else {
+      if ((yyvsp[0].numeric_literal_value_)->long_value() <= 0 || (yyvsp[0].numeric_literal_value_)->long_value() > 64) {
+        delete (yyvsp[0].numeric_literal_value_);
+        (yyval.partition_clause_) = NULL;
+        quickstep_yyerror(&(yylsp[0]), yyscanner, NULL, "NUMBER OF PARITIONS must be between 1 and 64");
+        YYERROR;
+      } else {
+        (yyval.partition_clause_) = new quickstep::ParsePartitionClause((yylsp[-7]).first_line, (yylsp[-7]).first_column, (yyvsp[-5].string_value_), (yyvsp[-3].string_list_), (yyvsp[0].numeric_literal_value_));
+      }
+    }
+  }
+#line 3579 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 72:
+#line 900 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.string_value_) = new quickstep::ParseString((yylsp[0]).first_line, (yylsp[0]).first_column,
+           std::to_string(quickstep::PartitionSchemeHeader::PartitionType::kHash));
+  }
+#line 3588 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 73:
+#line 904 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.string_value_) = new quickstep::ParseString((yylsp[0]).first_line, (yylsp[0]).first_column,
+           std::to_string(quickstep::PartitionSchemeHeader::PartitionType::kRange));
+  }
+#line 3597 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 74:
+#line 910 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.key_value_list_) = new quickstep::PtrList<quickstep::ParseKeyValue>();
     (yyval.key_value_list_)->push_back((yyvsp[0].key_value_));
   }
-#line 3495 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3606 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 71:
-#line 867 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 75:
+#line 914 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.key_value_list_) = (yyvsp[-2].key_value_list_);
     (yyval.key_value_list_)->push_back((yyvsp[0].key_value_));
   }
-#line 3504 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 72:
-#line 873 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.key_value_) = (yyvsp[0].key_string_value_);
-  }
-#line 3512 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 73:
-#line 876 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.key_value_) = (yyvsp[0].key_string_list_);
-  }
-#line 3520 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 74:
-#line 879 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.key_value_) = (yyvsp[0].key_integer_value_);
-  }
-#line 3528 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 75:
-#line 884 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.key_string_value_) = new quickstep::ParseKeyStringValue((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].string_value_));
-  }
-#line 3536 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3615 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 76:
-#line 887 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 920 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.key_value_) = (yyvsp[0].key_string_value_);
+  }
+#line 3623 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 77:
+#line 923 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.key_value_) = (yyvsp[0].key_string_list_);
+  }
+#line 3631 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 78:
+#line 926 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.key_value_) = (yyvsp[0].key_integer_value_);
+  }
+#line 3639 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 79:
+#line 931 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.key_string_value_) = new quickstep::ParseKeyStringValue((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].string_value_));
+  }
+#line 3647 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 80:
+#line 934 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     // This is a special case to handle the COMPRESS ALL option of the BLOCK PROPERTIES.
     (yyval.key_string_value_) = new quickstep::ParseKeyStringValue((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].string_value_),
         new quickstep::ParseString((yylsp[0]).first_line, (yylsp[0]).first_column, "ALL"));
   }
-#line 3546 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3657 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 77:
-#line 894 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 81:
+#line 941 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.key_string_list_) = new quickstep::ParseKeyStringList((yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-3].string_value_), (yyvsp[-1].string_list_));
   }
-#line 3554 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3665 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 78:
-#line 899 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 82:
+#line 946 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     if ((yyvsp[0].numeric_literal_value_)->float_like()) {
       delete (yyvsp[0].numeric_literal_value_);
@@ -3564,45 +3675,45 @@
     }
     (yyval.key_integer_value_) = new quickstep::ParseKeyIntegerValue((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].numeric_literal_value_));
   }
-#line 3568 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3679 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 79:
-#line 910 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 83:
+#line 957 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.string_value_) = new quickstep::ParseString((yylsp[0]).first_line, (yylsp[0]).first_column,
            std::to_string(quickstep::IndexSubBlockType::kBloomFilter));
   }
-#line 3577 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3688 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 80:
-#line 914 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 84:
+#line 961 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.string_value_) = new quickstep::ParseString((yylsp[0]).first_line, (yylsp[0]).first_column,
            std::to_string(quickstep::IndexSubBlockType::kCSBTree));
   }
-#line 3586 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3697 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 81:
-#line 920 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 85:
+#line 967 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.key_value_list_) = nullptr;
   }
-#line 3594 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3705 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 82:
-#line 923 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 86:
+#line 970 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.key_value_list_) = (yyvsp[-1].key_value_list_);
   }
-#line 3602 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3713 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 83:
-#line 929 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 87:
+#line 976 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-7].string_value_);
     delete (yyvsp[-5].string_list_);
@@ -3611,576 +3722,592 @@
     NotSupported(&(yylsp[-6]), yyscanner, "list of column names in INSERT statement");
     YYERROR;
   }
-#line 3615 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 84:
-#line 937 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.insert_statement_) = new quickstep::ParseStatementInsert((yylsp[-6]).first_line, (yylsp[-6]).first_column, (yyvsp[-4].string_value_), (yyvsp[-1].literal_value_list_));
-  }
-#line 3623 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 85:
-#line 942 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.copy_from_statement_) = new quickstep::ParseStatementCopyFrom((yylsp[-4]).first_line, (yylsp[-4]).first_column, (yyvsp[-3].string_value_), (yyvsp[-1].string_value_), (yyvsp[0].copy_from_params_));
-  }
-#line 3631 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 86:
-#line 947 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.copy_from_params_) = nullptr;
-  }
-#line 3639 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 87:
-#line 950 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.copy_from_params_) = (yyvsp[-1].copy_from_params_);
-  }
-#line 3647 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3726 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 88:
-#line 955 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 984 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.copy_from_params_) = new quickstep::ParseCopyFromParams((yylsp[-1]).first_line, (yylsp[-1]).first_column);
-    (yyval.copy_from_params_)->set_delimiter((yyvsp[0].string_value_));
+    (yyval.insert_statement_) = new quickstep::ParseStatementInsertTuple((yylsp[-6]).first_line, (yylsp[-6]).first_column, (yyvsp[-4].string_value_), (yyvsp[-1].literal_value_list_));
   }
-#line 3656 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3734 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 89:
-#line 959 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 987 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.copy_from_params_) = new quickstep::ParseCopyFromParams((yylsp[-1]).first_line, (yylsp[-1]).first_column);
-    (yyval.copy_from_params_)->escape_strings = (yyvsp[0].boolean_value_);
+    (yyval.insert_statement_) = new quickstep::ParseStatementInsertSelection((yylsp[-3]).first_line, (yylsp[-2]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].select_query_), nullptr);
   }
-#line 3665 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3742 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 90:
-#line 963 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 990 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.copy_from_params_) = (yyvsp[-3].copy_from_params_);
-    (yyval.copy_from_params_)->set_delimiter((yyvsp[0].string_value_));
+    (yyval.insert_statement_) = new quickstep::ParseStatementInsertSelection((yylsp[-4]).first_line, (yylsp[-3]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].select_query_), (yyvsp[-4].with_list_));
   }
-#line 3674 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3750 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 91:
-#line 967 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 996 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.copy_from_params_) = (yyvsp[-3].copy_from_params_);
-    (yyval.copy_from_params_)->escape_strings = (yyvsp[0].boolean_value_);
-  }
-#line 3683 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 92:
-#line 973 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.update_statement_) = new quickstep::ParseStatementUpdate((yylsp[-4]).first_line, (yylsp[-4]).first_column, (yyvsp[-3].string_value_), (yyvsp[-1].assignment_list_), (yyvsp[0].predicate_));
-  }
-#line 3691 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 93:
-#line 978 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.delete_statement_) = new quickstep::ParseStatementDelete((yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].predicate_));
-  }
-#line 3699 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 94:
-#line 983 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.assignment_list_) = (yyvsp[-2].assignment_list_);
-    (yyval.assignment_list_)->push_back((yyvsp[0].assignment_));
-  }
-#line 3708 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 95:
-#line 987 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.assignment_list_) = new quickstep::PtrList<quickstep::ParseAssignment>();
-    (yyval.assignment_list_)->push_back((yyvsp[0].assignment_));
-  }
-#line 3717 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 96:
-#line 993 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.assignment_) = new quickstep::ParseAssignment((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-2].string_value_), (yyvsp[0].expression_));
-  }
-#line 3725 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 97:
-#line 999 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.select_statement_) = new quickstep::ParseStatementSelect((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[0].select_query_), (yyvsp[-1].with_list_));
-  }
-#line 3733 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 98:
-#line 1004 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.with_list_) = nullptr;
-  }
-#line 3741 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 99:
-#line 1007 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.with_list_) = (yyvsp[0].with_list_);
-  }
-#line 3749 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 100:
-#line 1012 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.with_list_) = new quickstep::PtrVector<quickstep::ParseSubqueryTableReference>();
-    (yyval.with_list_)->push_back((yyvsp[0].with_list_element_));
+    (yyval.copy_from_statement_) = new quickstep::ParseStatementCopyFrom((yylsp[-4]).first_line, (yylsp[-4]).first_column, (yyvsp[-3].string_value_), (yyvsp[-1].string_value_), (yyvsp[0].copy_from_params_));
   }
 #line 3758 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 101:
-#line 1016 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 92:
+#line 1001 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.with_list_) = (yyvsp[-2].with_list_);
-    (yyval.with_list_)->push_back((yyvsp[0].with_list_element_));
+    (yyval.copy_from_params_) = nullptr;
   }
-#line 3767 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3766 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 102:
-#line 1022 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 93:
+#line 1004 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.with_list_element_) = new quickstep::ParseSubqueryTableReference((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[0].subquery_expression_));
-    (yyval.with_list_element_)->set_table_reference_signature((yyvsp[-2].table_reference_signature_));
+    (yyval.copy_from_params_) = (yyvsp[-1].copy_from_params_);
   }
-#line 3776 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3774 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 103:
-#line 1029 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 94:
+#line 1009 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.select_query_) = new quickstep::ParseSelect((yylsp[-8]).first_line, (yylsp[-8]).first_column, (yyvsp[-6].selection_), (yyvsp[-5].table_reference_list_), (yyvsp[-4].predicate_), (yyvsp[-3].opt_group_by_clause_), (yyvsp[-2].opt_having_clause_), (yyvsp[-1].opt_order_by_clause_), (yyvsp[0].opt_limit_clause_));
+    (yyval.copy_from_params_) = new quickstep::ParseCopyFromParams((yylsp[-1]).first_line, (yylsp[-1]).first_column);
+    (yyval.copy_from_params_)->set_delimiter((yyvsp[0].string_value_));
   }
-#line 3784 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3783 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 104:
-#line 1034 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 95:
+#line 1013 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    /* $$ = nullptr; */
+    (yyval.copy_from_params_) = new quickstep::ParseCopyFromParams((yylsp[-1]).first_line, (yylsp[-1]).first_column);
+    (yyval.copy_from_params_)->escape_strings = (yyvsp[0].boolean_value_);
   }
 #line 3792 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 105:
-#line 1037 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 96:
+#line 1017 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    NotSupported(&(yylsp[0]), yyscanner, "ALL in selection");
-    YYERROR;
+    (yyval.copy_from_params_) = (yyvsp[-3].copy_from_params_);
+    (yyval.copy_from_params_)->set_delimiter((yyvsp[0].string_value_));
   }
 #line 3801 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 106:
-#line 1041 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 97:
+#line 1021 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    NotSupported(&(yylsp[0]), yyscanner, "DISTINCT in selection");
-    YYERROR;
+    (yyval.copy_from_params_) = (yyvsp[-3].copy_from_params_);
+    (yyval.copy_from_params_)->escape_strings = (yyvsp[0].boolean_value_);
   }
 #line 3810 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 107:
-#line 1047 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 98:
+#line 1027 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.selection_) = new quickstep::ParseSelectionStar((yylsp[0]).first_line, (yylsp[0]).first_column);
+    (yyval.update_statement_) = new quickstep::ParseStatementUpdate((yylsp[-4]).first_line, (yylsp[-4]).first_column, (yyvsp[-3].string_value_), (yyvsp[-1].assignment_list_), (yyvsp[0].predicate_));
   }
 #line 3818 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 108:
-#line 1050 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 99:
+#line 1032 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.selection_) = (yyvsp[0].selection_list_);
+    (yyval.delete_statement_) = new quickstep::ParseStatementDelete((yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].predicate_));
   }
 #line 3826 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 109:
-#line 1055 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 100:
+#line 1037 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.selection_list_) = new quickstep::ParseSelectionList((yylsp[0]).first_line, (yylsp[0]).first_column);
-    (yyval.selection_list_)->add((yyvsp[0].selection_item_));
+    (yyval.assignment_list_) = (yyvsp[-2].assignment_list_);
+    (yyval.assignment_list_)->push_back((yyvsp[0].assignment_));
   }
 #line 3835 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 110:
-#line 1059 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 101:
+#line 1041 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.selection_list_) = (yyvsp[-2].selection_list_);
-    (yyval.selection_list_)->add((yyvsp[0].selection_item_));
+    (yyval.assignment_list_) = new quickstep::PtrList<quickstep::ParseAssignment>();
+    (yyval.assignment_list_)->push_back((yyvsp[0].assignment_));
   }
 #line 3844 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 111:
-#line 1065 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 102:
+#line 1047 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.selection_item_) = new quickstep::ParseSelectionItem((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-2].expression_), (yyvsp[0].string_value_));
+    (yyval.assignment_) = new quickstep::ParseAssignment((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-2].string_value_), (yyvsp[0].expression_));
   }
 #line 3852 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 112:
-#line 1068 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 103:
+#line 1053 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.selection_item_) = new quickstep::ParseSelectionItem((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].expression_), (yyvsp[0].string_value_));
+    (yyval.select_statement_) = new quickstep::ParseStatementSelect((yylsp[0]).first_line, (yylsp[0]).first_column, (yyvsp[0].select_query_), nullptr);
   }
 #line 3860 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 113:
-#line 1071 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 104:
+#line 1056 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.selection_item_) = new quickstep::ParseSelectionItem((yylsp[0]).first_line, (yylsp[0]).first_column, (yyvsp[0].expression_));
+    (yyval.select_statement_) = new quickstep::ParseStatementSelect((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[0].select_query_), (yyvsp[-1].with_list_));
   }
 #line 3868 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 114:
-#line 1076 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 105:
+#line 1061 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.table_reference_list_) = (yyvsp[-1].table_reference_list_);
+    (yyval.with_list_) = (yyvsp[0].with_list_);
   }
 #line 3876 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 115:
-#line 1081 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 106:
+#line 1066 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    /* $$ = nullptr; */
+    (yyval.with_list_) = new quickstep::PtrVector<quickstep::ParseSubqueryTableReference>();
+    (yyval.with_list_)->push_back((yyvsp[0].with_list_element_));
   }
-#line 3884 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3885 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 116:
-#line 1084 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 107:
+#line 1070 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    NotSupported(&(yylsp[0]), yyscanner, "alternate JOIN syntax (specify in WHERE clause instead)");
-    YYERROR;
+    (yyval.with_list_) = (yyvsp[-2].with_list_);
+    (yyval.with_list_)->push_back((yyvsp[0].with_list_element_));
   }
-#line 3893 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3894 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 117:
-#line 1090 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 108:
+#line 1076 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    NotSupported(&(yylsp[-1]), yyscanner, "alternate JOIN syntax (specify in WHERE clause instead)");
-    YYERROR;
+    (yyval.with_list_element_) = new quickstep::ParseSubqueryTableReference((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[0].subquery_expression_));
+    (yyval.with_list_element_)->set_table_reference_signature((yyvsp[-2].table_reference_signature_));
   }
-#line 3902 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 3903 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 118:
-#line 1094 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 109:
+#line 1083 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    NotSupported(&(yylsp[0]), yyscanner, "alternate JOIN syntax (specify in WHERE clause instead)");
-    YYERROR;
+    (yyval.select_query_) = new quickstep::ParseSelect((yylsp[-8]).first_line, (yylsp[-8]).first_column, (yyvsp[-6].selection_), (yyvsp[-5].table_reference_list_), (yyvsp[-4].predicate_), (yyvsp[-3].opt_group_by_clause_), (yyvsp[-2].opt_having_clause_), (yyvsp[-1].opt_order_by_clause_), (yyvsp[0].opt_limit_clause_));
   }
 #line 3911 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
+  case 110:
+#line 1088 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    /* $$ = nullptr; */
+  }
+#line 3919 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 111:
+#line 1091 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    NotSupported(&(yylsp[0]), yyscanner, "ALL in selection");
+    YYERROR;
+  }
+#line 3928 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 112:
+#line 1095 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    NotSupported(&(yylsp[0]), yyscanner, "DISTINCT in selection");
+    YYERROR;
+  }
+#line 3937 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 113:
+#line 1101 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.selection_) = new quickstep::ParseSelectionStar((yylsp[0]).first_line, (yylsp[0]).first_column);
+  }
+#line 3945 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 114:
+#line 1104 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.selection_) = (yyvsp[0].selection_list_);
+  }
+#line 3953 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 115:
+#line 1109 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.selection_list_) = new quickstep::ParseSelectionList((yylsp[0]).first_line, (yylsp[0]).first_column);
+    (yyval.selection_list_)->add((yyvsp[0].selection_item_));
+  }
+#line 3962 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 116:
+#line 1113 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.selection_list_) = (yyvsp[-2].selection_list_);
+    (yyval.selection_list_)->add((yyvsp[0].selection_item_));
+  }
+#line 3971 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 117:
+#line 1119 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.selection_item_) = new quickstep::ParseSelectionItem((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-2].expression_), (yyvsp[0].string_value_));
+  }
+#line 3979 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 118:
+#line 1122 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.selection_item_) = new quickstep::ParseSelectionItem((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].expression_), (yyvsp[0].string_value_));
+  }
+#line 3987 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
   case 119:
-#line 1100 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1125 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.selection_item_) = new quickstep::ParseSelectionItem((yylsp[0]).first_line, (yylsp[0]).first_column, (yyvsp[0].expression_));
+  }
+#line 3995 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 120:
+#line 1130 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_list_) = (yyvsp[-1].table_reference_list_);
+  }
+#line 4003 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 121:
+#line 1135 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    /* $$ = nullptr; */
+  }
+#line 4011 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 122:
+#line 1138 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    NotSupported(&(yylsp[0]), yyscanner, "alternate JOIN syntax (specify in WHERE clause instead)");
+    YYERROR;
+  }
+#line 4020 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 123:
+#line 1144 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    NotSupported(&(yylsp[-1]), yyscanner, "alternate JOIN syntax (specify in WHERE clause instead)");
+    YYERROR;
+  }
+#line 4029 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 124:
+#line 1148 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    NotSupported(&(yylsp[0]), yyscanner, "alternate JOIN syntax (specify in WHERE clause instead)");
+    YYERROR;
+  }
+#line 4038 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 125:
+#line 1154 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-2].string_list_);
     delete (yyvsp[0].predicate_);
     NotSupported(&(yylsp[-4]), yyscanner, "alternate JOIN syntax (specify in WHERE clause instead)");
     YYERROR;
   }
-#line 3922 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4049 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 120:
-#line 1106 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 126:
+#line 1160 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-2].string_list_);
     delete (yyvsp[0].predicate_);
     NotSupported(&(yylsp[-3]), yyscanner, "alternate JOIN syntax (specify in WHERE clause instead)");
     YYERROR;
   }
-#line 3933 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 121:
-#line 1112 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    delete (yyvsp[-2].string_list_);
-    delete (yyvsp[0].predicate_);
-    NotSupported(&(yylsp[-5]), yyscanner, "OUTER JOIN");
-    YYERROR;
-  }
-#line 3944 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 122:
-#line 1118 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    delete (yyvsp[-2].string_list_);
-    delete (yyvsp[0].predicate_);
-    NotSupported(&(yylsp[-4]), yyscanner, "OUTER JOIN");
-    YYERROR;
-  }
-#line 3955 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 123:
-#line 1124 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    delete (yyvsp[-2].string_list_);
-    delete (yyvsp[0].predicate_);
-    NotSupported(&(yylsp[-5]), yyscanner, "OUTER JOIN");
-    YYERROR;
-  }
-#line 3966 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 124:
-#line 1130 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    delete (yyvsp[-2].string_list_);
-    delete (yyvsp[0].predicate_);
-    NotSupported(&(yylsp[-4]), yyscanner, "OUTER JOIN");
-    YYERROR;
-  }
-#line 3977 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 125:
-#line 1136 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    delete (yyvsp[-2].string_list_);
-    delete (yyvsp[0].predicate_);
-    NotSupported(&(yylsp[-5]), yyscanner, "OUTER JOIN");
-    YYERROR;
-  }
-#line 3988 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 126:
-#line 1142 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    delete (yyvsp[-2].string_list_);
-    delete (yyvsp[0].predicate_);
-    NotSupported(&(yylsp[-4]), yyscanner, "OUTER JOIN");
-    YYERROR;
-  }
-#line 3999 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4060 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 127:
-#line 1150 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1166 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.subquery_expression_) = new quickstep::ParseSubqueryExpression((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-1].select_query_));
+    delete (yyvsp[-2].string_list_);
+    delete (yyvsp[0].predicate_);
+    NotSupported(&(yylsp[-5]), yyscanner, "OUTER JOIN");
+    YYERROR;
   }
-#line 4007 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4071 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 128:
-#line 1155 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1172 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.opt_sample_clause_) = NULL;
-  }
-#line 4015 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 129:
-#line 1158 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.opt_sample_clause_) = new quickstep::ParseSample((yylsp[-2]).first_line, (yylsp[-2]).first_column, true, (yyvsp[-1].numeric_literal_value_));
-  }
-#line 4023 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 130:
-#line 1161 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.opt_sample_clause_) = new quickstep::ParseSample((yylsp[-2]).first_line, (yylsp[-2]).first_column, false, (yyvsp[-1].numeric_literal_value_));
-  }
-#line 4031 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 131:
-#line 1166 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.table_reference_) = new quickstep::ParseSubqueryTableReference((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].subquery_expression_));
-    (yyval.table_reference_)->set_table_reference_signature((yyvsp[0].table_reference_signature_));
-  }
-#line 4040 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 132:
-#line 1170 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.table_reference_) = new quickstep::ParseSimpleTableReference((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-2].string_value_), (yyvsp[-1].opt_sample_clause_));
-    (yyval.table_reference_)->set_table_reference_signature((yyvsp[0].table_reference_signature_));
-  }
-#line 4049 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 133:
-#line 1174 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.table_reference_) = new quickstep::ParseSimpleTableReference((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].opt_sample_clause_));
-  }
-#line 4057 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 134:
-#line 1177 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.table_reference_) = new quickstep::ParseGeneratorTableReference((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].function_call_));
-    (yyval.table_reference_)->set_table_reference_signature((yyvsp[0].table_reference_signature_));
-  }
-#line 4066 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 135:
-#line 1181 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.table_reference_) = new quickstep::ParseGeneratorTableReference((yylsp[0]).first_line, (yylsp[0]).first_column, (yyvsp[0].function_call_));
-  }
-#line 4074 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 136:
-#line 1186 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.table_reference_signature_) = (yyvsp[0].table_reference_signature_);
+    delete (yyvsp[-2].string_list_);
+    delete (yyvsp[0].predicate_);
+    NotSupported(&(yylsp[-4]), yyscanner, "OUTER JOIN");
+    YYERROR;
   }
 #line 4082 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 137:
-#line 1189 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 129:
+#line 1178 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.table_reference_signature_) = (yyvsp[0].table_reference_signature_);
+    delete (yyvsp[-2].string_list_);
+    delete (yyvsp[0].predicate_);
+    NotSupported(&(yylsp[-5]), yyscanner, "OUTER JOIN");
+    YYERROR;
   }
-#line 4090 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4093 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 138:
-#line 1194 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 130:
+#line 1184 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.table_reference_signature_) = new ::quickstep::ParseTableReferenceSignature((yylsp[0]).first_line, (yylsp[0]).first_column, (yyvsp[0].string_value_));
+    delete (yyvsp[-2].string_list_);
+    delete (yyvsp[0].predicate_);
+    NotSupported(&(yylsp[-4]), yyscanner, "OUTER JOIN");
+    YYERROR;
   }
-#line 4098 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4104 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 139:
-#line 1197 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 131:
+#line 1190 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.table_reference_signature_) = new ::quickstep::ParseTableReferenceSignature((yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-3].string_value_), (yyvsp[-1].string_list_));
-  }
-#line 4106 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 140:
-#line 1202 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.table_reference_list_) = new quickstep::PtrList<quickstep::ParseTableReference>();
-    (yyval.table_reference_list_)->push_back((yyvsp[0].table_reference_));
+    delete (yyvsp[-2].string_list_);
+    delete (yyvsp[0].predicate_);
+    NotSupported(&(yylsp[-5]), yyscanner, "OUTER JOIN");
+    YYERROR;
   }
 #line 4115 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
+  case 132:
+#line 1196 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    delete (yyvsp[-2].string_list_);
+    delete (yyvsp[0].predicate_);
+    NotSupported(&(yylsp[-4]), yyscanner, "OUTER JOIN");
+    YYERROR;
+  }
+#line 4126 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 133:
+#line 1204 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.subquery_expression_) = new quickstep::ParseSubqueryExpression((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-1].select_query_));
+  }
+#line 4134 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 134:
+#line 1209 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.opt_sample_clause_) = NULL;
+  }
+#line 4142 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 135:
+#line 1212 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.opt_sample_clause_) = new quickstep::ParseSample((yylsp[-2]).first_line, (yylsp[-2]).first_column, true, (yyvsp[-1].numeric_literal_value_));
+  }
+#line 4150 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 136:
+#line 1215 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.opt_sample_clause_) = new quickstep::ParseSample((yylsp[-2]).first_line, (yylsp[-2]).first_column, false, (yyvsp[-1].numeric_literal_value_));
+  }
+#line 4158 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 137:
+#line 1220 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_) = new quickstep::ParseSubqueryTableReference((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].subquery_expression_));
+    (yyval.table_reference_)->set_table_reference_signature((yyvsp[0].table_reference_signature_));
+  }
+#line 4167 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 138:
+#line 1224 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_) = new quickstep::ParseSimpleTableReference((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-2].string_value_), (yyvsp[-1].opt_sample_clause_));
+    (yyval.table_reference_)->set_table_reference_signature((yyvsp[0].table_reference_signature_));
+  }
+#line 4176 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 139:
+#line 1228 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_) = new quickstep::ParseSimpleTableReference((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].opt_sample_clause_));
+  }
+#line 4184 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 140:
+#line 1231 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_) = new quickstep::ParseGeneratorTableReference((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].function_call_));
+    (yyval.table_reference_)->set_table_reference_signature((yyvsp[0].table_reference_signature_));
+  }
+#line 4193 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
   case 141:
-#line 1206 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1235 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_) = new quickstep::ParseGeneratorTableReference((yylsp[0]).first_line, (yylsp[0]).first_column, (yyvsp[0].function_call_));
+  }
+#line 4201 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 142:
+#line 1240 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_signature_) = (yyvsp[0].table_reference_signature_);
+  }
+#line 4209 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 143:
+#line 1243 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_signature_) = (yyvsp[0].table_reference_signature_);
+  }
+#line 4217 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 144:
+#line 1248 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_signature_) = new ::quickstep::ParseTableReferenceSignature((yylsp[0]).first_line, (yylsp[0]).first_column, (yyvsp[0].string_value_));
+  }
+#line 4225 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 145:
+#line 1251 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_signature_) = new ::quickstep::ParseTableReferenceSignature((yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-3].string_value_), (yyvsp[-1].string_list_));
+  }
+#line 4233 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 146:
+#line 1256 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.table_reference_list_) = new quickstep::PtrList<quickstep::ParseTableReference>();
+    (yyval.table_reference_list_)->push_back((yyvsp[0].table_reference_));
+  }
+#line 4242 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 147:
+#line 1260 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.table_reference_list_) = (yyvsp[-2].table_reference_list_);
     (yyval.table_reference_list_)->push_back((yyvsp[0].table_reference_));
   }
-#line 4124 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 142:
-#line 1212 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.opt_group_by_clause_) = nullptr;
-  }
-#line 4132 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 143:
-#line 1215 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.opt_group_by_clause_) = new quickstep::ParseGroupBy((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[0].expression_list_));
-  }
-#line 4140 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 144:
-#line 1220 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.opt_having_clause_) = nullptr;
-  }
-#line 4148 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 145:
-#line 1223 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.opt_having_clause_) = new quickstep::ParseHaving((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[0].predicate_));
-  }
-#line 4156 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 146:
-#line 1228 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.opt_order_by_clause_) = nullptr;
-  }
-#line 4164 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 147:
-#line 1231 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.opt_order_by_clause_) = new quickstep::ParseOrderBy((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[0].order_commalist_));
-  }
-#line 4172 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4251 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 148:
-#line 1236 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1266 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.opt_limit_clause_) = nullptr;
+    (yyval.opt_group_by_clause_) = nullptr;
   }
-#line 4180 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4259 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 149:
-#line 1239 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1269 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.opt_group_by_clause_) = new quickstep::ParseGroupBy((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[0].expression_list_));
+  }
+#line 4267 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 150:
+#line 1274 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.opt_having_clause_) = nullptr;
+  }
+#line 4275 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 151:
+#line 1277 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.opt_having_clause_) = new quickstep::ParseHaving((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[0].predicate_));
+  }
+#line 4283 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 152:
+#line 1282 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.opt_order_by_clause_) = nullptr;
+  }
+#line 4291 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 153:
+#line 1285 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.opt_order_by_clause_) = new quickstep::ParseOrderBy((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[0].order_commalist_));
+  }
+#line 4299 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 154:
+#line 1290 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.opt_limit_clause_) = nullptr;
+  }
+#line 4307 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 155:
+#line 1293 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     if ((yyvsp[0].numeric_literal_value_)->float_like()) {
       delete (yyvsp[0].numeric_literal_value_);
@@ -4198,111 +4325,111 @@
       }
     }
   }
-#line 4202 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4329 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 150:
-#line 1258 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 156:
+#line 1312 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.order_commalist_) = new quickstep::PtrList<quickstep::ParseOrderByItem>();
     (yyval.order_commalist_)->push_back((yyvsp[0].order_item_));
   }
-#line 4211 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4338 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 151:
-#line 1262 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 157:
+#line 1316 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.order_commalist_) = (yyvsp[-2].order_commalist_);
     (yyval.order_commalist_)->push_back((yyvsp[0].order_item_));
   }
-#line 4220 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4347 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 152:
-#line 1268 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 158:
+#line 1322 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.order_item_) = new quickstep::ParseOrderByItem((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-2].expression_), (yyvsp[-1].order_direction_), (yyvsp[0].order_direction_));
     delete (yyvsp[-1].order_direction_);
     delete (yyvsp[0].order_direction_);
   }
-#line 4230 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 153:
-#line 1275 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.order_direction_) = nullptr;
-  }
-#line 4238 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 154:
-#line 1278 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.order_direction_) = new bool(true);
-  }
-#line 4246 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 155:
-#line 1281 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.order_direction_) = new bool(false);
-  }
-#line 4254 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 156:
-#line 1286 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.order_direction_) = nullptr;
-  }
-#line 4262 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 157:
-#line 1289 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.order_direction_) = new bool(true);
-  }
-#line 4270 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 158:
-#line 1292 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.order_direction_) = new bool(false);
-  }
-#line 4278 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4357 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 159:
-#line 1298 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1329 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.predicate_) = nullptr;
+    (yyval.order_direction_) = nullptr;
   }
-#line 4286 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4365 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 160:
-#line 1301 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1332 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.predicate_) = (yyvsp[0].predicate_);
+    (yyval.order_direction_) = new bool(true);
   }
-#line 4294 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4373 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 161:
-#line 1306 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1335 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.predicate_) = (yyvsp[0].predicate_);
+    (yyval.order_direction_) = new bool(false);
   }
-#line 4302 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4381 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 162:
-#line 1311 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1340 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.order_direction_) = nullptr;
+  }
+#line 4389 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 163:
+#line 1343 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.order_direction_) = new bool(true);
+  }
+#line 4397 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 164:
+#line 1346 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.order_direction_) = new bool(false);
+  }
+#line 4405 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 165:
+#line 1352 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.predicate_) = nullptr;
+  }
+#line 4413 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 166:
+#line 1355 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.predicate_) = (yyvsp[0].predicate_);
+  }
+#line 4421 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 167:
+#line 1360 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.predicate_) = (yyvsp[0].predicate_);
+  }
+#line 4429 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 168:
+#line 1365 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     if ((yyvsp[-2].predicate_)->getParsePredicateType() == quickstep::ParsePredicate::kDisjunction) {
       (yyval.predicate_) = (yyvsp[-2].predicate_);
@@ -4312,19 +4439,19 @@
     }
     static_cast<quickstep::ParsePredicateDisjunction *>((yyval.predicate_))->addPredicate((yyvsp[0].predicate_));
   }
-#line 4316 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4443 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 163:
-#line 1320 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 169:
+#line 1374 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.predicate_) = (yyvsp[0].predicate_);
   }
-#line 4324 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4451 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 164:
-#line 1325 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 170:
+#line 1379 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     if ((yyvsp[-2].predicate_)->getParsePredicateType() == quickstep::ParsePredicate::kConjunction) {
       (yyval.predicate_) = (yyvsp[-2].predicate_);
@@ -4334,239 +4461,263 @@
     }
     static_cast<quickstep::ParsePredicateConjunction *>((yyval.predicate_))->addPredicate((yyvsp[0].predicate_));
   }
-#line 4338 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4465 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 165:
-#line 1334 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 171:
+#line 1388 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.predicate_) = (yyvsp[0].predicate_);
   }
-#line 4346 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4473 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 166:
-#line 1339 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 172:
+#line 1393 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.predicate_) = new quickstep::ParsePredicateNegation((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[0].predicate_));
   }
-#line 4354 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4481 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 167:
-#line 1342 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 173:
+#line 1396 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.predicate_) = (yyvsp[0].predicate_);
   }
-#line 4362 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4489 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 168:
-#line 1347 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 174:
+#line 1401 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.predicate_) = new quickstep::ParsePredicateBetween((yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-4].expression_), (yyvsp[-2].expression_), (yyvsp[0].expression_));
   }
-#line 4370 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4497 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 169:
-#line 1350 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 175:
+#line 1404 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.predicate_) = new quickstep::ParsePredicateNegation(
         (yylsp[-4]).first_line, (yylsp[-4]).first_column,
         new quickstep::ParsePredicateBetween((yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-5].expression_), (yyvsp[-2].expression_), (yyvsp[0].expression_)));
   }
-#line 4380 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4507 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 170:
-#line 1355 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 176:
+#line 1409 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-3].attribute_);
     (yyval.predicate_) = nullptr;
     NotSupported(&(yylsp[-2]), yyscanner, "NULL comparison predicates");
     YYERROR;
   }
-#line 4391 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4518 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 171:
-#line 1361 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 177:
+#line 1415 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     delete (yyvsp[-2].attribute_);
     (yyval.predicate_) = nullptr;
     NotSupported(&(yylsp[-1]), yyscanner, "NULL comparison predicates");
     YYERROR;
   }
-#line 4402 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 172:
-#line 1367 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.predicate_) = new quickstep::ParsePredicateComparison((yylsp[-1]).first_line, (yylsp[-1]).first_column, *(yyvsp[-1].comparison_), (yyvsp[-2].expression_), (yyvsp[0].expression_));
-  }
-#line 4410 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 173:
-#line 1370 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.predicate_) = (yyvsp[-1].predicate_);
-  }
-#line 4418 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 174:
-#line 1376 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.expression_) = new quickstep::ParseBinaryExpression((yylsp[-1]).first_line, (yylsp[-1]).first_column, *(yyvsp[-1].binary_operation_), (yyvsp[-2].expression_), (yyvsp[0].expression_));
-  }
-#line 4426 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 175:
-#line 1379 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.expression_) = (yyvsp[0].expression_);
-  }
-#line 4434 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 176:
-#line 1384 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.expression_) = new quickstep::ParseBinaryExpression((yylsp[-1]).first_line, (yylsp[-1]).first_column, *(yyvsp[-1].binary_operation_), (yyvsp[-2].expression_), (yyvsp[0].expression_));
-  }
-#line 4442 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 177:
-#line 1387 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.expression_) = (yyvsp[0].expression_);
-  }
-#line 4450 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4529 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 178:
-#line 1392 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1421 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.expression_) = new quickstep::ParseUnaryExpression((yylsp[-1]).first_line, (yylsp[-1]).first_column, *(yyvsp[-1].unary_operation_), (yyvsp[0].expression_));
+    (yyval.predicate_) = new quickstep::ParsePredicateComparison((yylsp[-1]).first_line, (yylsp[-1]).first_column, *(yyvsp[-1].comparison_), (yyvsp[-2].expression_), (yyvsp[0].expression_));
   }
-#line 4458 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4537 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 179:
-#line 1395 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1424 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.expression_) = (yyvsp[0].expression_);
+    (yyval.predicate_) = (yyvsp[-1].predicate_);
   }
-#line 4466 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4545 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 180:
-#line 1400 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1430 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.expression_) = (yyvsp[0].attribute_);
+    (yyval.expression_) = new quickstep::ParseBinaryExpression((yylsp[-1]).first_line, (yylsp[-1]).first_column, *(yyvsp[-1].binary_operation_), (yyvsp[-2].expression_), (yyvsp[0].expression_));
   }
-#line 4474 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4553 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 181:
-#line 1403 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1433 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.expression_) = new quickstep::ParseScalarLiteral((yyvsp[0].literal_value_));
+    (yyval.expression_) = (yyvsp[0].expression_);
   }
-#line 4482 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4561 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 182:
-#line 1406 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1438 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.expression_) = (yyvsp[0].function_call_);
+    (yyval.expression_) = new quickstep::ParseBinaryExpression((yylsp[-1]).first_line, (yylsp[-1]).first_column, *(yyvsp[-1].binary_operation_), (yyvsp[-2].expression_), (yyvsp[0].expression_));
   }
-#line 4490 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4569 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 183:
-#line 1409 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1441 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.expression_) = (yyvsp[-1].expression_);
+    (yyval.expression_) = (yyvsp[0].expression_);
   }
-#line 4498 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4577 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 184:
-#line 1414 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1446 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.function_call_) = new quickstep::ParseFunctionCall(
-        (yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[-2].string_value_), new quickstep::PtrList<quickstep::ParseExpression>());
+    (yyval.expression_) = new quickstep::ParseUnaryExpression((yylsp[-1]).first_line, (yylsp[-1]).first_column, *(yyvsp[-1].unary_operation_), (yyvsp[0].expression_));
   }
-#line 4507 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4585 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 185:
-#line 1418 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1449 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.expression_) = (yyvsp[0].expression_);
+  }
+#line 4593 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 186:
+#line 1454 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.expression_) = (yyvsp[0].attribute_);
+  }
+#line 4601 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 187:
+#line 1457 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.expression_) = new quickstep::ParseScalarLiteral((yyvsp[0].literal_value_));
+  }
+#line 4609 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 188:
+#line 1460 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.expression_) = (yyvsp[0].function_call_);
+  }
+#line 4617 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 189:
+#line 1463 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.expression_) = (yyvsp[0].expression_);
+  }
+#line 4625 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 190:
+#line 1466 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.expression_) = (yyvsp[-1].expression_);
+  }
+#line 4633 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 191:
+#line 1471 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.function_call_) = new quickstep::ParseFunctionCall(
+        (yylsp[-2]).first_line, (yylsp[-2]).first_column, false, (yyvsp[-2].string_value_), new quickstep::PtrList<quickstep::ParseExpression>());
+  }
+#line 4642 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 192:
+#line 1475 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.function_call_) = new quickstep::ParseFunctionCall(
         (yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-3].string_value_), new quickstep::ParseStar((yylsp[-1]).first_line, (yylsp[-1]).first_column));
   }
-#line 4516 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4651 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 186:
-#line 1422 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 193:
+#line 1479 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.function_call_) = new quickstep::ParseFunctionCall((yylsp[-3]).first_line, (yylsp[-3]).first_column, (yyvsp[-3].string_value_), (yyvsp[-1].expression_list_));
+    (yyval.function_call_) = new quickstep::ParseFunctionCall((yylsp[-3]).first_line, (yylsp[-3]).first_column, false, (yyvsp[-3].string_value_), (yyvsp[-1].expression_list_));
   }
-#line 4524 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4659 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 187:
-#line 1427 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 194:
+#line 1482 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.function_call_) = new quickstep::ParseFunctionCall((yylsp[-4]).first_line, (yylsp[-4]).first_column, true, (yyvsp[-4].string_value_), (yyvsp[-1].expression_list_));
+  }
+#line 4667 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 195:
+#line 1487 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.expression_) = new quickstep::ParseExtractFunction((yylsp[-5]).first_line, (yylsp[-5]).first_column, (yyvsp[-3].string_value_), (yyvsp[-1].expression_));
+  }
+#line 4675 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 196:
+#line 1492 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.expression_list_) = new quickstep::PtrList<quickstep::ParseExpression>();
     (yyval.expression_list_)->push_back((yyvsp[0].expression_));
   }
-#line 4533 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4684 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 188:
-#line 1431 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 197:
+#line 1496 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.expression_list_) = (yyvsp[-2].expression_list_);
     (yyval.expression_list_)->push_back((yyvsp[0].expression_));
   }
-#line 4542 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4693 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 189:
-#line 1437 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 198:
+#line 1502 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.literal_value_) = new quickstep::NullParseLiteralValue((yylsp[0]).first_line, (yylsp[0]).first_column);
   }
-#line 4550 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4701 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 190:
-#line 1440 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 199:
+#line 1505 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.literal_value_) = (yyvsp[0].numeric_literal_value_);
   }
-#line 4558 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4709 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 191:
-#line 1443 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 200:
+#line 1508 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.literal_value_) = (yyvsp[0].numeric_literal_value_);
   }
-#line 4566 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4717 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 192:
-#line 1446 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 201:
+#line 1511 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     /**
      * NOTE(chasseur): This case exhibits a shift/reduce conflict with the
@@ -4579,20 +4730,20 @@
     (yyvsp[0].numeric_literal_value_)->prependMinus();
     (yyval.literal_value_) = (yyvsp[0].numeric_literal_value_);
   }
-#line 4583 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4734 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 193:
-#line 1458 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 202:
+#line 1523 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.literal_value_) = new quickstep::StringParseLiteralValue((yyvsp[0].string_value_),
                                                 nullptr);  // No explicit type.
   }
-#line 4592 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4743 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 194:
-#line 1462 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 203:
+#line 1527 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     /**
      * NOTE(chasseur): This case exhibits a shift/reduce conflict with the
@@ -4612,11 +4763,11 @@
       YYERROR;
     }
   }
-#line 4616 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4767 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 195:
-#line 1481 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 204:
+#line 1546 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     quickstep::StringParseLiteralValue *parse_value
         = new quickstep::StringParseLiteralValue((yyvsp[0].string_value_), &((yyvsp[-1].data_type_)->getType()));
@@ -4630,143 +4781,143 @@
       (yyval.literal_value_) = parse_value;
     }
   }
-#line 4634 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4785 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 196:
-#line 1496 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 205:
+#line 1561 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.literal_value_list_) = new quickstep::PtrList<quickstep::ParseScalarLiteral>();
     (yyval.literal_value_list_)->push_back(new quickstep::ParseScalarLiteral((yyvsp[0].literal_value_)));
   }
-#line 4643 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4794 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 197:
-#line 1500 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 206:
+#line 1565 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.literal_value_list_) = (yyvsp[-2].literal_value_list_);
     (yyval.literal_value_list_)->push_back(new quickstep::ParseScalarLiteral((yyvsp[0].literal_value_)));
   }
-#line 4652 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4803 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 198:
-#line 1506 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 207:
+#line 1571 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.attribute_) = new quickstep::ParseAttribute((yylsp[0]).first_line, (yylsp[0]).first_column, (yyvsp[0].string_value_));
   }
-#line 4660 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4811 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 199:
-#line 1509 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 208:
+#line 1574 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.attribute_) = new quickstep::ParseAttribute((yylsp[-2]).first_line, (yylsp[-2]).first_column, (yyvsp[0].string_value_), (yyvsp[-2].string_value_));
   }
-#line 4668 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4819 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 200:
-#line 1514 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 209:
+#line 1579 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.attribute_list_) = new quickstep::PtrList<quickstep::ParseAttribute>();
     (yyval.attribute_list_)->push_back((yyvsp[0].attribute_));
   }
-#line 4677 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4828 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 201:
-#line 1518 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 210:
+#line 1583 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.attribute_list_) = (yyvsp[-2].attribute_list_);
     (yyval.attribute_list_)->push_back((yyvsp[0].attribute_));
   }
-#line 4686 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 202:
-#line 1525 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kEqual);
-  }
-#line 4694 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 203:
-#line 1528 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kNotEqual);
-  }
-#line 4702 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 204:
-#line 1531 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kLess);
-  }
-#line 4710 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 205:
-#line 1534 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kLessOrEqual);
-  }
-#line 4718 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 206:
-#line 1537 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kGreater);
-  }
-#line 4726 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 207:
-#line 1540 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kGreaterOrEqual);
-  }
-#line 4734 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 208:
-#line 1543 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.comparison_) =  &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kLike);
-  }
-#line 4742 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 209:
-#line 1546 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.comparison_) =  &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kNotLike);
-  }
-#line 4750 "SqlParser_gen.cpp" /* yacc.c:1661  */
-    break;
-
-  case 210:
-#line 1549 "../SqlParser.ypp" /* yacc.c:1661  */
-    {
-    (yyval.comparison_) =  &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kRegexMatch);
-  }
-#line 4758 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4837 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 211:
-#line 1552 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1590 "../SqlParser.ypp" /* yacc.c:1661  */
     {
-    (yyval.comparison_) =  &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kNotRegexMatch);
+    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kEqual);
   }
-#line 4766 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4845 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
   case 212:
-#line 1557 "../SqlParser.ypp" /* yacc.c:1661  */
+#line 1593 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kNotEqual);
+  }
+#line 4853 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 213:
+#line 1596 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kLess);
+  }
+#line 4861 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 214:
+#line 1599 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kLessOrEqual);
+  }
+#line 4869 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 215:
+#line 1602 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kGreater);
+  }
+#line 4877 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 216:
+#line 1605 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.comparison_) = &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kGreaterOrEqual);
+  }
+#line 4885 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 217:
+#line 1608 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.comparison_) =  &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kLike);
+  }
+#line 4893 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 218:
+#line 1611 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.comparison_) =  &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kNotLike);
+  }
+#line 4901 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 219:
+#line 1614 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.comparison_) =  &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kRegexMatch);
+  }
+#line 4909 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 220:
+#line 1617 "../SqlParser.ypp" /* yacc.c:1661  */
+    {
+    (yyval.comparison_) =  &quickstep::ComparisonFactory::GetComparison(quickstep::ComparisonID::kNotRegexMatch);
+  }
+#line 4917 "SqlParser_gen.cpp" /* yacc.c:1661  */
+    break;
+
+  case 221:
+#line 1622 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     /**
      * NOTE(chasseur): This case exhibits a shift/reduce conflict with the
@@ -4776,146 +4927,146 @@
      **/
     (yyval.unary_operation_) = &quickstep::UnaryOperationFactory::GetUnaryOperation(quickstep::UnaryOperationID::kNegate);
   }
-#line 4780 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4931 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 213:
-#line 1568 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 222:
+#line 1633 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.binary_operation_) = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kAdd);
   }
-#line 4788 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4939 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 214:
-#line 1571 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 223:
+#line 1636 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.binary_operation_) = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kSubtract);
   }
-#line 4796 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4947 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 215:
-#line 1576 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 224:
+#line 1641 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.binary_operation_) = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kModulo);
   }
-#line 4804 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4955 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 216:
-#line 1579 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 225:
+#line 1644 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.binary_operation_) = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kMultiply);
   }
-#line 4812 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4963 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 217:
-#line 1582 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 226:
+#line 1647 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.binary_operation_) = &quickstep::BinaryOperationFactory::GetBinaryOperation(quickstep::BinaryOperationID::kDivide);
   }
-#line 4820 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4971 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 218:
-#line 1588 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 227:
+#line 1653 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.string_list_) = new quickstep::PtrList<quickstep::ParseString>();
     (yyval.string_list_)->push_back((yyvsp[0].string_value_));
   }
-#line 4829 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4980 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 219:
-#line 1592 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 228:
+#line 1657 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.string_list_) = (yyvsp[-2].string_list_);
     (yyval.string_list_)->push_back((yyvsp[0].string_value_));
   }
-#line 4838 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4989 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 220:
-#line 1598 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 229:
+#line 1663 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.string_value_) = (yyvsp[0].string_value_);
   }
-#line 4846 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 4997 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 221:
-#line 1601 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 230:
+#line 1666 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     if ((yyvsp[0].string_value_)->value().empty()) {
       quickstep_yyerror(&(yylsp[0]), yyscanner, nullptr, "Zero-length identifier");
     }
     (yyval.string_value_) = (yyvsp[0].string_value_);
   }
-#line 4857 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 5008 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 222:
-#line 1609 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 231:
+#line 1674 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.boolean_value_) = true;
   }
-#line 4865 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 5016 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 223:
-#line 1612 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 232:
+#line 1677 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.boolean_value_) = true;
   }
-#line 4873 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 5024 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 224:
-#line 1615 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 233:
+#line 1680 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.boolean_value_) = false;
   }
-#line 4881 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 5032 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 225:
-#line 1618 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 234:
+#line 1683 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.boolean_value_) = false;
   }
-#line 4889 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 5040 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 226:
-#line 1624 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 235:
+#line 1689 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     (yyval.command_) = new quickstep::ParseCommand((yylsp[-1]).first_line, (yylsp[-1]).first_column, (yyvsp[-1].string_value_), (yyvsp[0].command_argument_list_));
   }
-#line 4897 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 5048 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 227:
-#line 1629 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 236:
+#line 1694 "../SqlParser.ypp" /* yacc.c:1661  */
     {
     quickstep::PtrVector<quickstep::ParseString> *argument_list = (yyvsp[-1].command_argument_list_);
     argument_list->push_back((yyvsp[0].string_value_));
     (yyval.command_argument_list_) = argument_list;
   }
-#line 4907 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 5058 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
-  case 228:
-#line 1634 "../SqlParser.ypp" /* yacc.c:1661  */
+  case 237:
+#line 1699 "../SqlParser.ypp" /* yacc.c:1661  */
     { /* Epsilon, an empy match. */
     (yyval.command_argument_list_) = new quickstep::PtrVector<quickstep::ParseString>();
   }
-#line 4915 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 5066 "SqlParser_gen.cpp" /* yacc.c:1661  */
     break;
 
 
-#line 4919 "SqlParser_gen.cpp" /* yacc.c:1661  */
+#line 5070 "SqlParser_gen.cpp" /* yacc.c:1661  */
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -5150,7 +5301,7 @@
 #endif
   return yyresult;
 }
-#line 1638 "../SqlParser.ypp" /* yacc.c:1906  */
+#line 1703 "../SqlParser.ypp" /* yacc.c:1906  */
 
 
 void NotSupported(const YYLTYPE *location, yyscan_t yyscanner, const std::string &feature) {
diff --git a/parser/preprocessed/SqlParser_gen.hpp b/parser/preprocessed/SqlParser_gen.hpp
index 7119cba..71fddb3 100644
--- a/parser/preprocessed/SqlParser_gen.hpp
+++ b/parser/preprocessed/SqlParser_gen.hpp
@@ -94,57 +94,62 @@
     TOKEN_DOUBLE = 304,
     TOKEN_DROP = 305,
     TOKEN_ESCAPE_STRINGS = 306,
-    TOKEN_FALSE = 307,
-    TOKEN_FIRST = 308,
-    TOKEN_FLOAT = 309,
-    TOKEN_FOREIGN = 310,
-    TOKEN_FROM = 311,
-    TOKEN_FULL = 312,
-    TOKEN_GROUP = 313,
-    TOKEN_HAVING = 314,
-    TOKEN_INDEX = 315,
-    TOKEN_INNER = 316,
-    TOKEN_INSERT = 317,
-    TOKEN_INTEGER = 318,
-    TOKEN_INTERVAL = 319,
-    TOKEN_INTO = 320,
-    TOKEN_JOIN = 321,
-    TOKEN_KEY = 322,
-    TOKEN_LAST = 323,
-    TOKEN_LEFT = 324,
-    TOKEN_LIMIT = 325,
-    TOKEN_LONG = 326,
-    TOKEN_NULL = 327,
-    TOKEN_NULLS = 328,
-    TOKEN_OFF = 329,
-    TOKEN_ON = 330,
-    TOKEN_ORDER = 331,
-    TOKEN_OUTER = 332,
-    TOKEN_PERCENT = 333,
-    TOKEN_PRIMARY = 334,
-    TOKEN_QUIT = 335,
-    TOKEN_REAL = 336,
-    TOKEN_REFERENCES = 337,
-    TOKEN_RIGHT = 338,
-    TOKEN_ROW_DELIMITER = 339,
-    TOKEN_SELECT = 340,
-    TOKEN_SET = 341,
-    TOKEN_SMALLINT = 342,
-    TOKEN_TABLE = 343,
-    TOKEN_TIME = 344,
-    TOKEN_TIMESTAMP = 345,
-    TOKEN_TRUE = 346,
-    TOKEN_TUPLESAMPLE = 347,
-    TOKEN_UNIQUE = 348,
-    TOKEN_UPDATE = 349,
-    TOKEN_USING = 350,
-    TOKEN_VALUES = 351,
-    TOKEN_VARCHAR = 352,
-    TOKEN_WHERE = 353,
-    TOKEN_WITH = 354,
-    TOKEN_YEARMONTH = 355,
-    TOKEN_EOF = 356,
-    TOKEN_LEX_ERROR = 357
+    TOKEN_EXTRACT = 307,
+    TOKEN_FALSE = 308,
+    TOKEN_FIRST = 309,
+    TOKEN_FLOAT = 310,
+    TOKEN_FOREIGN = 311,
+    TOKEN_FROM = 312,
+    TOKEN_FULL = 313,
+    TOKEN_GROUP = 314,
+    TOKEN_HASH = 315,
+    TOKEN_HAVING = 316,
+    TOKEN_INDEX = 317,
+    TOKEN_INNER = 318,
+    TOKEN_INSERT = 319,
+    TOKEN_INTEGER = 320,
+    TOKEN_INTERVAL = 321,
+    TOKEN_INTO = 322,
+    TOKEN_JOIN = 323,
+    TOKEN_KEY = 324,
+    TOKEN_LAST = 325,
+    TOKEN_LEFT = 326,
+    TOKEN_LIMIT = 327,
+    TOKEN_LONG = 328,
+    TOKEN_NULL = 329,
+    TOKEN_NULLS = 330,
+    TOKEN_OFF = 331,
+    TOKEN_ON = 332,
+    TOKEN_ORDER = 333,
+    TOKEN_OUTER = 334,
+    TOKEN_PARTITION = 335,
+    TOKEN_PARTITIONS = 336,
+    TOKEN_PERCENT = 337,
+    TOKEN_PRIMARY = 338,
+    TOKEN_QUIT = 339,
+    TOKEN_RANGE = 340,
+    TOKEN_REAL = 341,
+    TOKEN_REFERENCES = 342,
+    TOKEN_RIGHT = 343,
+    TOKEN_ROW_DELIMITER = 344,
+    TOKEN_SELECT = 345,
+    TOKEN_SET = 346,
+    TOKEN_SMALLINT = 347,
+    TOKEN_TABLE = 348,
+    TOKEN_TIME = 349,
+    TOKEN_TIMESTAMP = 350,
+    TOKEN_TRUE = 351,
+    TOKEN_TUPLESAMPLE = 352,
+    TOKEN_UNIQUE = 353,
+    TOKEN_UPDATE = 354,
+    TOKEN_USING = 355,
+    TOKEN_VALUES = 356,
+    TOKEN_VARCHAR = 357,
+    TOKEN_WHERE = 358,
+    TOKEN_WITH = 359,
+    TOKEN_YEARMONTH = 360,
+    TOKEN_EOF = 361,
+    TOKEN_LEX_ERROR = 362
   };
 #endif
 
@@ -153,7 +158,7 @@
 
 union YYSTYPE
 {
-#line 110 "../SqlParser.ypp" /* yacc.c:1915  */
+#line 114 "../SqlParser.ypp" /* yacc.c:1915  */
 
   quickstep::ParseString *string_value_;
 
@@ -210,6 +215,7 @@
   quickstep::ParseStatementDelete *delete_statement_;
   quickstep::ParseStatementCopyFrom *copy_from_statement_;
   quickstep::ParseStatementCreateTable *create_table_statement_;
+  quickstep::ParsePartitionClause *partition_clause_;
   quickstep::ParseBlockProperties *block_properties_;
   quickstep::ParseStatementDropTable *drop_table_statement_;
   quickstep::ParseStatementQuit *quit_statement_;
@@ -236,7 +242,7 @@
   quickstep::PtrVector<quickstep::ParseSubqueryTableReference> *with_list_;
   quickstep::ParseSubqueryTableReference *with_list_element_;
 
-#line 240 "SqlParser_gen.hpp" /* yacc.c:1915  */
+#line 246 "SqlParser_gen.hpp" /* yacc.c:1915  */
 };
 
 typedef union YYSTYPE YYSTYPE;
diff --git a/parser/tests/Aggregate.test b/parser/tests/Aggregate.test
index 3fbf3f1..7962d3e 100644
--- a/parser/tests/Aggregate.test
+++ b/parser/tests/Aggregate.test
@@ -166,3 +166,53 @@
   |   +-right_operand=FunctionCall[name=AGG]
   +-from_clause=
     +-TableReference[table=test]
+==
+
+SELECT AGG(DISTINCT x), AGG(y) FROM test GROUP BY z
+--
+SelectStatement
++-select_query=Select
+  +-select_clause=SelectList
+  | +-SelectListItem
+  | | +-FunctionCall[name=AGG,is_distinct=true]
+  | |   +-AttributeReference[attribute_name=x]
+  | +-SelectListItem
+  |   +-FunctionCall[name=AGG]
+  |     +-AttributeReference[attribute_name=y]
+  +-group_by=GroupBy
+  | +-AttributeReference[attribute_name=z]
+  +-from_clause=
+    +-TableReference[table=test]
+==
+
+SELECT AGG(DISTINCT FUN(x) + y) * AGG(z)
+FROM test
+GROUP BY z
+HAVING AGG(DISTINCT w) + AGG(s) > 1
+--
+SelectStatement
++-select_query=Select
+  +-select_clause=SelectList
+  | +-SelectListItem
+  |   +-Multiply
+  |     +-left_operand=FunctionCall[name=AGG,is_distinct=true]
+  |     | +-Add
+  |     |   +-left_operand=FunctionCall[name=FUN]
+  |     |   | +-AttributeReference[attribute_name=x]
+  |     |   +-right_operand=AttributeReference[attribute_name=y]
+  |     +-right_operand=FunctionCall[name=AGG]
+  |       +-AttributeReference[attribute_name=z]
+  +-group_by=GroupBy
+  | +-AttributeReference[attribute_name=z]
+  +-having=HAVING
+  | +-Greater
+  |   +-left_operand=Add
+  |   | +-left_operand=FunctionCall[name=AGG,is_distinct=true]
+  |   | | +-AttributeReference[attribute_name=w]
+  |   | +-right_operand=FunctionCall[name=AGG]
+  |   |   +-AttributeReference[attribute_name=s]
+  |   +-right_operand=Literal
+  |     +-NumericLiteral[numeric_string=1,float_like=false]
+  +-from_clause=
+    +-TableReference[table=test]
+==
diff --git a/parser/tests/Create.test b/parser/tests/Create.test
index b156db8..2670c66 100644
--- a/parser/tests/Create.test
+++ b/parser/tests/Create.test
@@ -139,6 +139,74 @@
                              ^
 ==
 
+CREATE TABLE test (attr INT) PARTITION BY HASH(attr) PARTITIONS 4
+--
+CreateTableStatement[relation_name=test]
++-attribute_list=
+| +-AttributeDefinition[name=attr,type=Int]
++-partition_clause=
+  +-PartitionClause[partition_type=0]
+    +-Number of Partitions=NumericLiteral[numeric_string=4,float_like=false]
+    +-attribute_name_list=
+      +-String[value=attr]
+==
+
+# Empty partitioning attribute is not allowed
+CREATE TABLE test (attr INT) PARTITION BY HASH() PARTITIONS 4
+--
+ERROR: syntax error (1 : 48)
+...TABLE test (attr INT) PARTITION BY HASH() PARTITIONS 4
+                                           ^
+==
+
+# Zero partitions not allowed
+CREATE TABLE test (attr INT) PARTITION BY HASH(attr) PARTITIONS 0
+--
+ERROR: NUMBER OF PARITIONS must be between 1 and 64 (1 : 65)
+...INT) PARTITION BY HASH(attr) PARTITIONS 0
+                                           ^
+==
+
+# Missing number of partitions not allowed
+CREATE TABLE test (attr INT) PARTITION BY HASH(attr) PARTITIONS
+--
+ERROR: syntax error (1 : 64)
+... INT) PARTITION BY HASH(attr) PARTITIONS
+                                           ^
+==
+
+# Missing PARTITIONS attribute not allowed
+CREATE TABLE test (attr INT) PARTITION BY HASH(attr)
+--
+ERROR: syntax error (1 : 53)
+... test (attr INT) PARTITION BY HASH(attr)
+                                           ^
+==
+
+# Missing partitioning type not allowed
+CREATE TABLE test (attr INT) PARTITION BY (attr) PARTITIONS 4
+--
+ERROR: syntax error (1 : 43)
+CREATE TABLE test (attr INT) PARTITION BY (attr) PARTITIONS 4
+                                          ^
+==
+
+# Number of partitions greater than 64 not allowed
+CREATE TABLE test (attr INT) PARTITION BY HASH(attr) PARTITIONS 65
+--
+ERROR: NUMBER OF PARITIONS must be between 1 and 64 (1 : 65)
+...INT) PARTITION BY HASH(attr) PARTITIONS 65
+                                           ^
+==
+
+# Missing PARTITION BY clause not allowed
+CREATE TABLE test (attr INT) PARTITIONS 4
+--
+ERROR: syntax error (1 : 30)
+CREATE TABLE test (attr INT) PARTITIONS 4
+                             ^
+==
+
 CREATE TABLE test (attr INT) WITH BLOCKPROPERTIES
 (TYPE rowstore)
 --
diff --git a/parser/tests/TPCH.test b/parser/tests/TPCH.test
index fffd59e..f62c314 100644
--- a/parser/tests/TPCH.test
+++ b/parser/tests/TPCH.test
@@ -1,5 +1,7 @@
 #   Copyright 2011-2015 Quickstep Technologies LLC.
 #   Copyright 2015 Pivotal Software, Inc.
+#   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+#     University of Wisconsin—Madison.
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -436,9 +438,105 @@
   cust_nation,
   l_year
 --
-ERROR: syntax error (11 : 20)
-      EXTRACT(year FROM l_shipdate) AS l_year,
-                   ^
+SelectStatement
++-select_query=Select
+  +-select_clause=SelectList
+  | +-SelectListItem
+  | | +-AttributeReference[attribute_name=supp_nation]
+  | +-SelectListItem
+  | | +-AttributeReference[attribute_name=cust_nation]
+  | +-SelectListItem
+  | | +-AttributeReference[attribute_name=l_year]
+  | +-SelectListItem[alias=revenue]
+  |   +-FunctionCall[name=SUM]
+  |     +-AttributeReference[attribute_name=volume]
+  +-group_by=GroupBy
+  | +-AttributeReference[attribute_name=supp_nation]
+  | +-AttributeReference[attribute_name=cust_nation]
+  | +-AttributeReference[attribute_name=l_year]
+  +-order_by=OrderBy
+  | +-OrderByItem[is_asc=true,nulls_first=false]
+  | | +-AttributeReference[attribute_name=supp_nation]
+  | +-OrderByItem[is_asc=true,nulls_first=false]
+  | | +-AttributeReference[attribute_name=cust_nation]
+  | +-OrderByItem[is_asc=true,nulls_first=false]
+  |   +-AttributeReference[attribute_name=l_year]
+  +-from_clause=
+    +-SubqueryTable
+      +-table_signature=TableSignature[table_alias=shipping]
+      +-SubqueryExpression
+        +-Select
+          +-select_clause=SelectList
+          | +-SelectListItem[alias=supp_nation]
+          | | +-AttributeReference[attribute_name=n_name,relation_name=n1]
+          | +-SelectListItem[alias=cust_nation]
+          | | +-AttributeReference[attribute_name=n_name,relation_name=n2]
+          | +-SelectListItem[alias=l_year]
+          | | +-Extract[unit=year]
+          | |   +-date_expression=AttributeReference[attribute_name=l_shipdate]
+          | +-SelectListItem[alias=volume]
+          |   +-Multiply
+          |     +-left_operand=AttributeReference[attribute_name=l_extendedprice]
+          |     +-right_operand=Subtract
+          |       +-left_operand=Literal
+          |       | +-NumericLiteral[numeric_string=1,float_like=false]
+          |       +-right_operand=AttributeReference[attribute_name=l_discount]
+          +-where_clause=And
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=s_suppkey]
+          | | +-right_operand=AttributeReference[attribute_name=l_suppkey]
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=o_orderkey]
+          | | +-right_operand=AttributeReference[attribute_name=l_orderkey]
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=c_custkey]
+          | | +-right_operand=AttributeReference[attribute_name=o_custkey]
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=s_nationkey]
+          | | +-right_operand=AttributeReference[attribute_name=n_nationkey,
+          | |   relation_name=n1]
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=c_nationkey]
+          | | +-right_operand=AttributeReference[attribute_name=n_nationkey,
+          | |   relation_name=n2]
+          | +-Or
+          | | +-And
+          | | | +-Equal
+          | | | | +-left_operand=AttributeReference[attribute_name=n_name,
+          | | | | | relation_name=n1]
+          | | | | +-right_operand=Literal
+          | | | |   +-StringLiteral[value=ETHIOPIA]
+          | | | +-Equal
+          | | |   +-left_operand=AttributeReference[attribute_name=n_name,
+          | | |   | relation_name=n2]
+          | | |   +-right_operand=Literal
+          | | |     +-StringLiteral[value=UNITED STATES]
+          | | +-And
+          | |   +-Equal
+          | |   | +-left_operand=AttributeReference[attribute_name=n_name,
+          | |   | | relation_name=n1]
+          | |   | +-right_operand=Literal
+          | |   |   +-StringLiteral[value=UNITED STATES]
+          | |   +-Equal
+          | |     +-left_operand=AttributeReference[attribute_name=n_name,
+          | |     | relation_name=n2]
+          | |     +-right_operand=Literal
+          | |       +-StringLiteral[value=ETHIOPIA]
+          | +-Between
+          |   +-check_operand=AttributeReference[attribute_name=l_shipdate]
+          |   +-lower_bound_operand=Literal
+          |   | +-StringLiteral[value=1995-01-01,explicit_type=Datetime]
+          |   +-upper_bound_operand=Literal
+          |     +-StringLiteral[value=1996-12-31,explicit_type=Datetime]
+          +-from_clause=
+            +-TableReference[table=supplier]
+            +-TableReference[table=lineitem]
+            +-TableReference[table=orders]
+            +-TableReference[table=customer]
+            +-TableReference[table=nation]
+            | +-table_signature=TableSignature[table_alias=n1]
+            +-TableReference[table=nation]
+              +-table_signature=TableSignature[table_alias=n2]
 ==
 
 # Query 8
@@ -519,9 +617,77 @@
   nation,
   o_year DESC
 --
-ERROR: syntax error (9 : 20)
-      EXTRACT(year FROM o_orderdate) AS o_year,
-                   ^
+SelectStatement
++-select_query=Select
+  +-select_clause=SelectList
+  | +-SelectListItem
+  | | +-AttributeReference[attribute_name=nation]
+  | +-SelectListItem
+  | | +-AttributeReference[attribute_name=o_year]
+  | +-SelectListItem[alias=sum_profit]
+  |   +-FunctionCall[name=SUM]
+  |     +-AttributeReference[attribute_name=amount]
+  +-group_by=GroupBy
+  | +-AttributeReference[attribute_name=nation]
+  | +-AttributeReference[attribute_name=o_year]
+  +-order_by=OrderBy
+  | +-OrderByItem[is_asc=true,nulls_first=false]
+  | | +-AttributeReference[attribute_name=nation]
+  | +-OrderByItem[is_asc=false,nulls_first=true]
+  |   +-AttributeReference[attribute_name=o_year]
+  +-from_clause=
+    +-SubqueryTable
+      +-table_signature=TableSignature[table_alias=profit]
+      +-SubqueryExpression
+        +-Select
+          +-select_clause=SelectList
+          | +-SelectListItem[alias=nation]
+          | | +-AttributeReference[attribute_name=n_name]
+          | +-SelectListItem[alias=o_year]
+          | | +-Extract[unit=year]
+          | |   +-date_expression=AttributeReference[attribute_name=o_orderdate]
+          | +-SelectListItem[alias=amount]
+          |   +-Subtract
+          |     +-left_operand=Multiply
+          |     | +-left_operand=AttributeReference[
+          |     | | attribute_name=l_extendedprice]
+          |     | +-right_operand=Subtract
+          |     |   +-left_operand=Literal
+          |     |   | +-NumericLiteral[numeric_string=1,float_like=false]
+          |     |   +-right_operand=AttributeReference[attribute_name=l_discount]
+          |     +-right_operand=Multiply
+          |       +-left_operand=AttributeReference[attribute_name=ps_supplycost]
+          |       +-right_operand=AttributeReference[attribute_name=l_quantity]
+          +-where_clause=And
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=s_suppkey]
+          | | +-right_operand=AttributeReference[attribute_name=l_suppkey]
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=ps_suppkey]
+          | | +-right_operand=AttributeReference[attribute_name=l_suppkey]
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=ps_partkey]
+          | | +-right_operand=AttributeReference[attribute_name=l_partkey]
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=p_partkey]
+          | | +-right_operand=AttributeReference[attribute_name=l_partkey]
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=o_orderkey]
+          | | +-right_operand=AttributeReference[attribute_name=l_orderkey]
+          | +-Equal
+          | | +-left_operand=AttributeReference[attribute_name=s_nationkey]
+          | | +-right_operand=AttributeReference[attribute_name=n_nationkey]
+          | +-kLike
+          |   +-left_operand=AttributeReference[attribute_name=p_name]
+          |   +-right_operand=Literal
+          |     +-StringLiteral[value=%ghost%]
+          +-from_clause=
+            +-TableReference[table=part]
+            +-TableReference[table=supplier]
+            +-TableReference[table=lineitem]
+            +-TableReference[table=partsupp]
+            +-TableReference[table=orders]
+            +-TableReference[table=nation]
 ==
 
 # Query 10
@@ -812,9 +978,9 @@
   p_type,
   p_size
 --
-ERROR: syntax error (5 : 9)
-  COUNT(distinct ps_suppkey) AS supplie...
-        ^
+ERROR: syntax error (13 : 14)
+  AND p_size IN (32, 42, 9, 18, 50, 30, 12,...
+             ^
 ==
 
 # Query 17
diff --git a/query_execution/CMakeLists.txt b/query_execution/CMakeLists.txt
index 7eca518..b682618 100644
--- a/query_execution/CMakeLists.txt
+++ b/query_execution/CMakeLists.txt
@@ -29,6 +29,7 @@
 add_library(quickstep_queryexecution_QueryExecutionMessages_proto
             ${queryexecution_QueryExecutionMessages_proto_srcs}
             ${queryexecution_QueryExecutionMessages_proto_hdrs})
+add_library(quickstep_queryexecution_QueryExecutionState ../empty_src.cpp QueryExecutionState.hpp) 
 add_library(quickstep_queryexecution_QueryExecutionTypedefs ../empty_src.cpp QueryExecutionTypedefs.hpp)
 add_library(quickstep_queryexecution_QueryExecutionUtil ../empty_src.cpp QueryExecutionUtil.hpp)
 add_library(quickstep_queryexecution_WorkOrdersContainer WorkOrdersContainer.cpp WorkOrdersContainer.hpp)
@@ -48,6 +49,7 @@
                       quickstep_queryexecution_ForemanLite
                       quickstep_queryexecution_QueryContext
                       quickstep_queryexecution_QueryExecutionMessages_proto
+                      quickstep_queryexecution_QueryExecutionState
                       quickstep_queryexecution_QueryExecutionTypedefs
                       quickstep_queryexecution_QueryExecutionUtil
                       quickstep_queryexecution_WorkOrdersContainer
@@ -100,6 +102,9 @@
                       ${PROTOBUF_LIBRARY})
 target_link_libraries(quickstep_queryexecution_QueryExecutionMessages_proto
                       ${PROTOBUF_LIBRARY})
+target_link_libraries(quickstep_queryexecution_QueryExecutionState
+                      glog
+                      quickstep_utility_Macros)
 target_link_libraries(quickstep_queryexecution_QueryExecutionTypedefs
                       quickstep_threading_ThreadIDBasedMap
                       tmb)
@@ -139,6 +144,7 @@
                       quickstep_queryexecution_QueryContext
                       quickstep_queryexecution_QueryContext_proto
                       quickstep_queryexecution_QueryExecutionMessages_proto
+                      quickstep_queryexecution_QueryExecutionState
                       quickstep_queryexecution_QueryExecutionTypedefs
                       quickstep_queryexecution_QueryExecutionUtil
                       quickstep_queryexecution_WorkOrdersContainer
@@ -159,6 +165,7 @@
                       quickstep_queryexecution_Foreman
                       quickstep_queryexecution_QueryContext
                       quickstep_queryexecution_QueryContext_proto
+                      quickstep_queryexecution_QueryExecutionState
                       quickstep_queryexecution_QueryExecutionTypedefs
                       quickstep_queryexecution_WorkOrdersContainer
                       quickstep_queryexecution_WorkerDirectory
diff --git a/query_execution/Foreman.cpp b/query_execution/Foreman.cpp
index fd4aea7..2b2581a 100644
--- a/query_execution/Foreman.cpp
+++ b/query_execution/Foreman.cpp
@@ -19,7 +19,6 @@
 
 #include <cstddef>
 #include <memory>
-#include <unordered_map>
 #include <utility>
 #include <vector>
 
@@ -77,12 +76,12 @@
 }
 
 void Foreman::processWorkOrderCompleteMessage(const dag_node_index op_index,
-                                              const size_t worker_id) {
-  --queued_workorders_per_op_[op_index];
+                                              const size_t worker_thread_index) {
+  query_exec_state_->decrementNumQueuedWorkOrders(op_index);
 
   // As the given worker finished executing a WorkOrder, decrement its number
   // of queued WorkOrders.
-  workers_->decrementNumQueuedWorkOrders(worker_id);
+  workers_->decrementNumQueuedWorkOrders(worker_thread_index);
 
   // Check if new work orders are available and fetch them if so.
   fetchNormalWorkOrders(op_index);
@@ -123,13 +122,13 @@
   // for the schedulable WorkOrders beginning from 'op_index'. The first
   // candidate worker to receive the next WorkOrder is the one that sent the
   // response message to Foreman.
-  dispatchWorkerMessages(worker_id, op_index);
+  dispatchWorkerMessages(worker_thread_index, op_index);
 }
 
 void Foreman::processRebuildWorkOrderCompleteMessage(const dag_node_index op_index,
-                                                     const size_t worker_id) {
-  --rebuild_status_[op_index].second;
-  workers_->decrementNumQueuedWorkOrders(worker_id);
+                                                     const size_t worker_thread_index) {
+  query_exec_state_->decrementNumRebuildWorkOrders(op_index);
+  workers_->decrementNumQueuedWorkOrders(worker_thread_index);
 
   if (checkRebuildOver(op_index)) {
     markOperatorFinished(op_index);
@@ -147,7 +146,7 @@
   // for the schedulable WorkOrders beginning from 'op_index'. The first
   // candidate worker to receive the next WorkOrder is the one that sent the
   // response message to Foreman.
-  dispatchWorkerMessages(worker_id, op_index);
+  dispatchWorkerMessages(worker_thread_index, op_index);
 }
 
 void Foreman::processDataPipelineMessage(const dag_node_index op_index,
@@ -183,7 +182,7 @@
   initialize();
 
   // Event loop
-  while (!checkQueryExecutionFinished()) {
+  while (!query_exec_state_->hasQueryExecutionFinished()) {
     // Receive() causes this thread to sleep until next message is received.
     AnnotatedMessage annotated_msg = bus_->Receive(foreman_client_id_, 0, true);
     const TaggedMessage &tagged_message = annotated_msg.tagged_message;
@@ -192,14 +191,14 @@
         serialization::WorkOrderCompletionMessage proto;
         CHECK(proto.ParseFromArray(tagged_message.message(), tagged_message.message_bytes()));
 
-        processWorkOrderCompleteMessage(proto.operator_index(), proto.worker_id());
+        processWorkOrderCompleteMessage(proto.operator_index(), proto.worker_thread_index());
         break;
       }
       case kRebuildWorkOrderCompleteMessage: {
         serialization::WorkOrderCompletionMessage proto;
         CHECK(proto.ParseFromArray(tagged_message.message(), tagged_message.message_bytes()));
 
-        processRebuildWorkOrderCompleteMessage(proto.operator_index(), proto.worker_id());
+        processRebuildWorkOrderCompleteMessage(proto.operator_index(), proto.worker_thread_index());
         break;
       }
       case kCatalogRelationNewBlockMessage: {
@@ -288,19 +287,11 @@
 
 void Foreman::initializeState() {
   const dag_node_index dag_size = query_dag_->size();
-  num_operators_finished_ = 0;
-
-  done_gen_.assign(dag_size, false);
-
-  execution_finished_.assign(dag_size, false);
 
   output_consumers_.resize(dag_size);
   blocking_dependencies_.resize(dag_size);
 
-  rebuild_required_.assign(dag_size, false);
-
-  queued_workorders_per_op_.assign(dag_size, 0);
-
+  query_exec_state_.reset(new QueryExecutionState(dag_size));
   workorders_container_.reset(new WorkOrdersContainer(dag_size, num_numa_nodes_));
 
   for (dag_node_index node_index = 0; node_index < dag_size; ++node_index) {
@@ -308,8 +299,8 @@
         query_dag_->getNodePayload(node_index).getInsertDestinationID();
     if (insert_destination_index != QueryContext::kInvalidInsertDestinationId) {
       // Rebuild is necessary whenever InsertDestination is present.
-      rebuild_required_[node_index] = true;
-      rebuild_status_[node_index] = std::make_pair(false, 0);
+      query_exec_state_->setRebuildRequired(node_index);
+      query_exec_state_->setRebuildStatus(node_index, 0, false);
     }
 
     for (const pair<dag_node_index, bool> &dependent_link :
@@ -340,7 +331,7 @@
   for (dag_node_index index = start_operator_index;
        num_operators_checked < query_dag_->size();
        index = (index + 1) % query_dag_->size(), ++num_operators_checked) {
-    if (execution_finished_[index]) {
+    if (query_exec_state_->hasExecutionFinished(index)) {
       continue;
     }
     if (numa_node != -1) {
@@ -348,7 +339,7 @@
       work_order = workorders_container_->getNormalWorkOrderForNUMANode(index, numa_node);
       if (work_order != nullptr) {
         // A WorkOrder found on the given NUMA node.
-        ++queued_workorders_per_op_[index];
+        query_exec_state_->incrementNumQueuedWorkOrders(index);
         return WorkerMessage::WorkOrderMessage(work_order, index);
       } else {
         // Normal workorder not found on this node. Look for a rebuild workorder
@@ -363,7 +354,7 @@
     // Try to get a normal WorkOrder from other NUMA nodes.
     work_order = workorders_container_->getNormalWorkOrder(index);
     if (work_order != nullptr) {
-      ++queued_workorders_per_op_[index];
+      query_exec_state_->incrementNumQueuedWorkOrders(index);
       return WorkerMessage::WorkOrderMessage(work_order, index);
     } else {
       // Normal WorkOrder not found, look for a RebuildWorkOrder.
@@ -377,7 +368,7 @@
   return nullptr;
 }
 
-void Foreman::sendWorkerMessage(const std::size_t worker_id,
+void Foreman::sendWorkerMessage(const std::size_t worker_thread_index,
                                 const WorkerMessage &message) {
   message_type_id type;
   if (message.getType() == WorkerMessage::kRebuildWorkOrder) {
@@ -392,17 +383,17 @@
   const tmb::MessageBus::SendStatus send_status =
       QueryExecutionUtil::SendTMBMessage(bus_,
                                          foreman_client_id_,
-                                         workers_->getClientID(worker_id),
+                                         workers_->getClientID(worker_thread_index),
                                          move(worker_tagged_message));
   CHECK(send_status == tmb::MessageBus::SendStatus::kOK) <<
       "Message could not be sent from Foreman with TMB client ID "
       << foreman_client_id_ << " to Foreman with TMB client ID "
-      << workers_->getClientID(worker_id);
+      << workers_->getClientID(worker_thread_index);
 }
 
 bool Foreman::fetchNormalWorkOrders(const dag_node_index index) {
   bool generated_new_workorders = false;
-  if (!done_gen_[index]) {
+  if (!query_exec_state_->hasDoneGenerationWorkOrders(index)) {
     // Do not fetch any work units until all blocking dependencies are met.
     // The releational operator is not aware of blocking dependencies for
     // uncorrelated scalar queries.
@@ -411,12 +402,15 @@
     }
     const size_t num_pending_workorders_before =
         workorders_container_->getNumNormalWorkOrders(index);
-    done_gen_[index] =
+    const bool done_generation =
         query_dag_->getNodePayloadMutable(index)->getAllWorkOrders(workorders_container_.get(),
                                                                    query_context_.get(),
                                                                    storage_manager_,
                                                                    foreman_client_id_,
                                                                    bus_);
+    if (done_generation) {
+      query_exec_state_->setDoneGenerationWorkOrders(index);
+    }
 
     // TODO(shoban): It would be a good check to see if operator is making
     // useful progress, i.e., the operator either generates work orders to
@@ -473,8 +467,7 @@
 }
 
 void Foreman::markOperatorFinished(const dag_node_index index) {
-  execution_finished_[index] = true;
-  ++num_operators_finished_;
+  query_exec_state_->setExecutionFinished(index);
 
   RelationalOperator *op = query_dag_->getNodePayloadMutable(index);
   op->updateCatalogOnCompletion();
@@ -500,10 +493,10 @@
 
   getRebuildWorkOrders(index, workorders_container_.get());
 
-  rebuild_status_[index] = std::make_pair(
-      true, workorders_container_->getNumRebuildWorkOrders(index));
+  query_exec_state_->setRebuildStatus(
+      index, workorders_container_->getNumRebuildWorkOrders(index), true);
 
-  return (rebuild_status_[index].second == 0);
+  return (query_exec_state_->getNumRebuildWorkOrders(index) == 0);
 }
 
 void Foreman::getRebuildWorkOrders(const dag_node_index index, WorkOrdersContainer *container) {
diff --git a/query_execution/Foreman.hpp b/query_execution/Foreman.hpp
index 0b09f79..373529d 100644
--- a/query_execution/Foreman.hpp
+++ b/query_execution/Foreman.hpp
@@ -20,13 +20,12 @@
 
 #include <cstddef>
 #include <memory>
-#include <unordered_map>
-#include <utility>
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
 #include "query_execution/ForemanLite.hpp"
 #include "query_execution/QueryContext.hpp"
+#include "query_execution/QueryExecutionState.hpp"
 #include "query_execution/QueryExecutionTypedefs.hpp"
 #include "query_execution/WorkOrdersContainer.hpp"
 #include "query_execution/WorkerMessage.hpp"
@@ -80,7 +79,6 @@
       : ForemanLite(bus, cpu_id),
         catalog_database_(DCHECK_NOTNULL(catalog_database)),
         storage_manager_(DCHECK_NOTNULL(storage_manager)),
-        num_operators_finished_(0),
         max_msgs_per_worker_(1),
         num_numa_nodes_(num_numa_nodes) {
     bus_->RegisterClientAsSender(foreman_client_id_, kWorkOrderMessage);
@@ -122,7 +120,7 @@
    **/
   inline void reconstructQueryContextFromProto(const serialization::QueryContext &proto) {
     query_context_.reset(
-        new QueryContext(proto, catalog_database_, storage_manager_, foreman_client_id_, bus_));
+        new QueryContext(proto, *catalog_database_, storage_manager_, foreman_client_id_, bus_));
   }
 
   /**
@@ -159,15 +157,6 @@
   typedef DAG<RelationalOperator, bool>::size_type_nodes dag_node_index;
 
   /**
-   * @brief Check if the current query has finished its execution.
-   *
-   * @return True if the query has finished. Otherwise false.
-   **/
-  bool checkQueryExecutionFinished() const {
-    return num_operators_finished_ == query_dag_->size();
-  }
-
-  /**
    * @brief Check if all the dependencies of the node at specified index have
    *        finished their execution.
    *
@@ -182,7 +171,7 @@
   inline bool checkAllDependenciesMet(const dag_node_index node_index) const {
     for (const dag_node_index dependency_index : query_dag_->getDependencies(node_index)) {
       // If at least one of the dependencies is not met, return false.
-      if (!execution_finished_[dependency_index]) {
+      if (!query_exec_state_->hasExecutionFinished(dependency_index)) {
         return false;
       }
     }
@@ -204,7 +193,7 @@
    **/
   inline bool checkAllBlockingDependenciesMet(const dag_node_index node_index) const {
     for (const dag_node_index blocking_dependency_index : blocking_dependencies_[node_index]) {
-      if (!execution_finished_[blocking_dependency_index]) {
+      if (!query_exec_state_->hasExecutionFinished(blocking_dependency_index)) {
         return false;
       }
     }
@@ -242,21 +231,22 @@
    *
    * @param node_index The index of the specified operator node in the query DAG
    *        for the completed WorkOrder.
-   * @param worker_id The logical ID of the worker for the completed WorkOrder.
+   * @param worker_thread_index The logical index of the worker thread in
+   *        WorkerDirectory for the completed WorkOrder.
    **/
   void processWorkOrderCompleteMessage(const dag_node_index op_index,
-                                       const std::size_t worker_id);
+                                       const std::size_t worker_thread_index);
 
   /**
    * @brief Process the received RebuildWorkOrder complete message.
    *
    * @param node_index The index of the specified operator node in the query DAG
    *        for the completed RebuildWorkOrder.
-   * @param worker_id The logical ID of the worker for the completed
-   *        RebuildWorkOrder.
+   * @param worker_thread_index The logical index of the worker thread in
+   *        WorkerDirectory for the completed RebuildWorkOrder.
    **/
   void processRebuildWorkOrderCompleteMessage(const dag_node_index op_index,
-                                              const std::size_t worker_id);
+                                              const std::size_t worker_thread_index);
 
   /**
    * @brief Process the received data pipeline message.
@@ -284,10 +274,6 @@
   void cleanUp() {
     output_consumers_.clear();
     blocking_dependencies_.clear();
-    done_gen_.clear();
-    execution_finished_.clear();
-    rebuild_required_.clear();
-    rebuild_status_.clear();
   }
 
   /**
@@ -319,10 +305,11 @@
   /**
    * @brief Send the given message to the specified worker.
    *
-   * @param worker_id The logical ID of the recipient worker.
+   * @param worker_thread_index The logical index of the recipient worker thread
+   *        in WorkerDirectory.
    * @param message The WorkerMessage to be sent.
    **/
-  void sendWorkerMessage(const std::size_t worker_id, const WorkerMessage &message);
+  void sendWorkerMessage(const std::size_t worker_thread_index, const WorkerMessage &message);
 
   /**
    * @brief Fetch all work orders currently available in relational operator and
@@ -382,8 +369,8 @@
   inline bool checkNormalExecutionOver(const dag_node_index index) const {
     return (checkAllDependenciesMet(index) &&
             !workorders_container_->hasNormalWorkOrder(index) &&
-            queued_workorders_per_op_[index] == 0 &&
-            done_gen_[index]);
+            query_exec_state_->getNumQueuedWorkOrders(index) == 0 &&
+            query_exec_state_->hasDoneGenerationWorkOrders(index));
   }
 
   /**
@@ -394,7 +381,7 @@
    * @return True if the rebuild operation is required, false otherwise.
    **/
   inline bool checkRebuildRequired(const dag_node_index index) const {
-    return rebuild_required_[index];
+    return query_exec_state_->isRebuildRequired(index);
   }
 
   /**
@@ -405,13 +392,9 @@
    * @return True if the rebuild operation is over, false otherwise.
    **/
   inline bool checkRebuildOver(const dag_node_index index) const {
-    std::unordered_map<dag_node_index,
-                       std::pair<bool, std::size_t>>::const_iterator
-        search_res = rebuild_status_.find(index);
-    DEBUG_ASSERT(search_res != rebuild_status_.end());
-    return checkRebuildInitiated(index) &&
+    return query_exec_state_->hasRebuildInitiated(index) &&
            !workorders_container_->hasRebuildWorkOrder(index) &&
-           (search_res->second.second == 0);
+           (query_exec_state_->getNumRebuildWorkOrders(index) == 0);
   }
 
   /**
@@ -423,7 +406,7 @@
    * @return True if the rebuild operation has been initiated, false otherwise.
    **/
   inline bool checkRebuildInitiated(const dag_node_index index) const {
-    return rebuild_status_.at(index).first;
+    return query_exec_state_->hasRebuildInitiated(index);
   }
 
   /**
@@ -456,38 +439,17 @@
 
   std::unique_ptr<QueryContext> query_context_;
 
-  // Number of operators who've finished their execution.
-  std::size_t num_operators_finished_;
-
   // During a single round of WorkOrder dispatch, a Worker should be allocated
   // at most these many WorkOrders.
   std::size_t max_msgs_per_worker_;
 
-  // The ith bit denotes if the operator with ID = i has finished its execution.
-  std::vector<bool> execution_finished_;
-
   // For all nodes, store their receiving dependents.
   std::vector<std::vector<dag_node_index>> output_consumers_;
 
   // For all nodes, store their pipeline breaking dependencies (if any).
   std::vector<std::vector<dag_node_index>> blocking_dependencies_;
 
-  // The ith bit denotes if the operator with ID = i has finished generating
-  // work orders.
-  std::vector<bool> done_gen_;
-
-  // The ith bit denotes if the operator with ID = i requires generation of
-  // rebuild WorkOrders.
-  std::vector<bool> rebuild_required_;
-
-  // Key is dag_node_index of the operator for which rebuild is required. Value is
-  // a pair - first element has a bool (whether rebuild for operator at index i
-  // has been initiated) and if the boolean is true, the second element denotes
-  // the number of pending rebuild workorders for the operator.
-  std::unordered_map<dag_node_index, std::pair<bool, std::size_t>> rebuild_status_;
-
-  // A vector to track the number of workorders in execution, for each operator.
-  std::vector<int> queued_workorders_per_op_;
+  std::unique_ptr<QueryExecutionState> query_exec_state_;
 
   std::unique_ptr<WorkOrdersContainer> workorders_container_;
 
diff --git a/query_execution/QueryContext.cpp b/query_execution/QueryContext.cpp
index 18e0b72..e9d6d57 100644
--- a/query_execution/QueryContext.cpp
+++ b/query_execution/QueryContext.cpp
@@ -50,18 +50,18 @@
 namespace quickstep {
 
 QueryContext::QueryContext(const serialization::QueryContext &proto,
-                           CatalogDatabaseLite *database,
+                           const CatalogDatabaseLite &database,
                            StorageManager *storage_manager,
                            const tmb::client_id foreman_client_id,
                            tmb::MessageBus *bus) {
-  DCHECK(ProtoIsValid(proto, *database))
+  DCHECK(ProtoIsValid(proto, database))
       << "Attempted to create QueryContext from an invalid proto description:\n"
       << proto.DebugString();
 
   for (int i = 0; i < proto.aggregation_states_size(); ++i) {
     aggregation_states_.emplace_back(
         AggregationOperationState::ReconstructFromProto(proto.aggregation_states(i),
-                                                        *database,
+                                                        database,
                                                         storage_manager));
   }
 
@@ -83,7 +83,7 @@
     const serialization::InsertDestination &insert_destination_proto = proto.insert_destinations(i);
     insert_destinations_.emplace_back(
         InsertDestination::ReconstructFromProto(insert_destination_proto,
-                                                database->getRelationSchemaById(
+                                                database.getRelationSchemaById(
                                                     insert_destination_proto.relation_id()),
                                                 storage_manager,
                                                 foreman_client_id,
@@ -92,7 +92,7 @@
 
   for (int i = 0; i < proto.predicates_size(); ++i) {
     predicates_.emplace_back(
-        PredicateFactory::ReconstructFromProto(proto.predicates(i), *database));
+        PredicateFactory::ReconstructFromProto(proto.predicates(i), database));
   }
 
   for (int i = 0; i < proto.scalar_groups_size(); ++i) {
@@ -101,7 +101,7 @@
     const serialization::QueryContext::ScalarGroup &scalar_group_proto = proto.scalar_groups(i);
     for (int j = 0; j < scalar_group_proto.scalars_size(); ++j) {
       scalar_group.emplace_back(
-          ScalarFactory::ReconstructFromProto(scalar_group_proto.scalars(j), *database));
+          ScalarFactory::ReconstructFromProto(scalar_group_proto.scalars(j), database));
     }
 
     scalar_groups_.push_back(move(scalar_group));
@@ -109,7 +109,7 @@
 
   for (int i = 0; i < proto.sort_configs_size(); ++i) {
     sort_configs_.emplace_back(
-        SortConfiguration::ReconstructFromProto(proto.sort_configs(i), *database));
+        SortConfiguration::ReconstructFromProto(proto.sort_configs(i), database));
   }
 
   for (int i = 0; i < proto.tuples_size(); ++i) {
@@ -125,7 +125,7 @@
           update_group_proto.update_assignments(j);
 
       unique_ptr<const Scalar> scalar(
-          ScalarFactory::ReconstructFromProto(update_assignment_proto.scalar(), *database));
+          ScalarFactory::ReconstructFromProto(update_assignment_proto.scalar(), database));
 
       update_group.emplace(update_assignment_proto.attribute_id(), move(scalar));
     }
diff --git a/query_execution/QueryContext.hpp b/query_execution/QueryContext.hpp
index 5cdfd47..c0c63cf 100644
--- a/query_execution/QueryContext.hpp
+++ b/query_execution/QueryContext.hpp
@@ -113,8 +113,6 @@
 
   /**
    * @brief Constructor.
-   * @note During some query execution, an InsertDestination could change
-   *       CatalogDatabase, more specifically, CatalogRelation's blocks.
    *
    * @param proto A serialized Protocol Buffer representation of a
    *        QueryContext, originally generated by the optimizer.
@@ -125,7 +123,7 @@
    * @param bus A pointer to the TMB.
    **/
   QueryContext(const serialization::QueryContext &proto,
-               CatalogDatabaseLite *database,
+               const CatalogDatabaseLite &database,
                StorageManager *storage_manager,
                const tmb::client_id foreman_client_id,
                tmb::MessageBus *bus);
diff --git a/query_execution/QueryExecutionMessages.proto b/query_execution/QueryExecutionMessages.proto
index 43cd628..8d2efd0 100644
--- a/query_execution/QueryExecutionMessages.proto
+++ b/query_execution/QueryExecutionMessages.proto
@@ -22,7 +22,7 @@
 // WorkOrders.
 message WorkOrderCompletionMessage {
   required uint64 operator_index = 1;
-  required uint64 worker_id = 2;
+  required uint64 worker_thread_index = 2;
 }
 
 message CatalogRelationNewBlockMessage {
diff --git a/query_execution/QueryExecutionState.hpp b/query_execution/QueryExecutionState.hpp
new file mode 100644
index 0000000..7395461
--- /dev/null
+++ b/query_execution/QueryExecutionState.hpp
@@ -0,0 +1,293 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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_EXECUTION_QUERY_EXECUTION_STATE_HPP_
+#define QUICKSTEP_QUERY_EXECUTION_QUERY_EXECUTION_STATE_HPP_
+
+#include <cstddef>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "utility/Macros.hpp"
+
+#include "glog/logging.h"
+
+namespace quickstep {
+
+/** \addtogroup QueryExecution
+ *  @{
+ */
+
+/**
+ * @brief A class that tracks the state of the execution of a query which
+ *        includes status of operators, number of dispatched work orders etc.
+ **/
+class QueryExecutionState {
+ public:
+  /**
+   * @brief Constructor.
+   *
+   * @param num_operators Number of relational operators in the query.
+   **/
+  explicit QueryExecutionState(const std::size_t num_operators)
+      : num_operators_(num_operators),
+        num_operators_finished_(0),
+        queued_workorders_per_op_(num_operators, 0),
+        rebuild_required_(num_operators, false),
+        done_gen_(num_operators, false),
+        execution_finished_(num_operators, false) {}
+
+  /**
+   * @brief Get the number of operators in the query.
+   **/
+  inline const std::size_t getNumOperators() const {
+    return num_operators_;
+  }
+
+  /**
+   * @brief Get the number of operators who have finished their execution.
+   **/
+  inline const std::size_t getNumOperatorsFinished() const {
+    return num_operators_finished_;
+  }
+
+  /**
+   * @brief Check if the query has finished its execution.
+   *
+   * @return True if the query has finished its execution, false otherwise.
+   **/
+  inline bool hasQueryExecutionFinished() const {
+    return num_operators_finished_ == num_operators_;
+  }
+
+  /**
+   * @brief Set the rebuild status of the given operator that includes the
+   *        flag for whether the rebuild has been initiated and if so, the
+   *        number of pending rebuild work orders.
+   *
+   * @param operator_index The index of the given operator.
+   * @param num_rebuild_workorders The number of rebuild workorders of the given
+   *        operator.
+   * @param rebuild_initiated True if the rebuild has been initiated, false
+   *        otherwise.
+   **/
+  inline void setRebuildStatus(const std::size_t operator_index,
+                               const std::size_t num_rebuild_workorders,
+                               const bool rebuild_initiated) {
+    DCHECK(operator_index < num_operators_);
+    rebuild_status_[operator_index].second = num_rebuild_workorders;
+    rebuild_status_[operator_index].first = rebuild_initiated;
+  }
+
+  /**
+   * @brief Check if the rebuild has been initiated for the given operator.
+   *
+   * @param operator_index The index of the given operator.
+   *
+   * @return True if the rebuild has been initiated, false otherwise.
+   **/
+  inline bool hasRebuildInitiated(const std::size_t operator_index) const {
+    DCHECK(operator_index < num_operators_);
+    const auto search_res = rebuild_status_.find(operator_index);
+    if (search_res != rebuild_status_.end()) {
+      return search_res->second.first;
+    }
+    return false;
+  }
+
+  /**
+   * @brief Get the number of pending rebuild workorders for the given operator.
+   *
+   * @param operator_index The index of the given operator.
+   *
+   * @return The number of pending rebuild workorders for the given operator.
+   **/
+  inline const std::size_t getNumRebuildWorkOrders(
+      const std::size_t operator_index) const {
+    DCHECK(operator_index < num_operators_);
+    const auto search_res = rebuild_status_.find(operator_index);
+    if (search_res != rebuild_status_.end()) {
+      return search_res->second.second;
+    }
+    LOG(WARNING) << "Called QueryExecutionState::getNumRebuildWorkOrders() "
+                    "for an operator whose rebuild entry doesn't exist.";
+    return 0;
+  }
+
+  /**
+   * @brief Decrement the number of rebuild WorkOrders for the given operator.
+   *
+   * @param operator_index The index of the given operator.
+   **/
+  inline void decrementNumRebuildWorkOrders(const std::size_t operator_index) {
+    DCHECK(operator_index < num_operators_);
+    const auto search_res = rebuild_status_.find(operator_index);
+    if (search_res != rebuild_status_.end()) {
+      DCHECK(search_res->second.first);
+      DCHECK_GE(search_res->second.second, 1u);
+      --rebuild_status_[operator_index].second;
+    } else {
+      LOG(FATAL) <<
+          "Called QueryExecutionState::decrementNumRebuildWorkOrders() for an "
+          "operator whose rebuild entry doesn't exist.";
+    }
+  }
+
+  /**
+   * @brief Increment the number of queued (normal) WorkOrders for the given
+   *        operator.
+   *
+   * @param operator_index The index of the given operator.
+   **/
+  inline void incrementNumQueuedWorkOrders(const std::size_t operator_index) {
+    DCHECK(operator_index < num_operators_);
+    ++queued_workorders_per_op_[operator_index];
+  }
+
+  /**
+   * @brief Decrement the number of queued (normal) WorkOrders for the given
+   *        operator.
+   *
+   * @param operator_index The index of the given operator.
+   **/
+  inline void decrementNumQueuedWorkOrders(const std::size_t operator_index) {
+    DCHECK(operator_index < num_operators_);
+    DCHECK_GT(queued_workorders_per_op_[operator_index], 0u);
+    --queued_workorders_per_op_[operator_index];
+  }
+
+  /**
+   * @brief Get the number of queued (normal) WorkOrders for the given operator.
+   *
+   * @note Queued WorkOrders mean those WorkOrders which have been dispatched
+   *       for execution by the Foreman and haven't yet completed. These are
+   *       different from pending WorkOrders which mean the WorkOrders that
+   *       haven't been dispatched for execution yet.
+   *
+   * @param operator_index The index of the given operator.
+   *
+   * @return The number of queued (normal) WorkOrders for the given operators.
+   **/
+  inline const std::size_t getNumQueuedWorkOrders(
+      const std::size_t operator_index) const {
+    DCHECK(operator_index < num_operators_);
+    return queued_workorders_per_op_[operator_index];
+  }
+
+  /**
+   * @brief Set the rebuild required flag as true for the given operator.
+   *
+   * @param operator_index The index of the given operator.
+   **/
+  inline void setRebuildRequired(const std::size_t operator_index) {
+    DCHECK(operator_index < num_operators_);
+    rebuild_required_[operator_index] = true;
+  }
+
+  /**
+   * @brief Get the rebuild required flag for the given operator.
+   *
+   * @param operator_index The index of the given operator.
+   **/
+  inline bool isRebuildRequired(const std::size_t operator_index) const {
+    DCHECK(operator_index < num_operators_);
+    return rebuild_required_[operator_index];
+  }
+
+  /**
+   * @brief Set the execution finished flag for the given operator as true.
+   *
+   * @note By default this flag is false.
+   *
+   * @param operator_index The index of the given operator.
+   **/
+  inline void setExecutionFinished(const std::size_t operator_index) {
+    DCHECK(operator_index < num_operators_);
+    execution_finished_[operator_index] = true;
+    ++num_operators_finished_;
+  }
+
+  /**
+   * @brief Get the execution finished flag for the given operator.
+   *
+   * @param operator_index The index of the given operator.
+   **/
+  inline bool hasExecutionFinished(const std::size_t operator_index) const {
+    DCHECK(operator_index < num_operators_);
+    return execution_finished_[operator_index];
+  }
+
+  /**
+   * @brief Set the "done generation of workorders" flag as true for the given
+   *        operator.
+   *
+   * @note By default this flag is false.
+   *
+   * @param operator_index The index of the given operator.
+   **/
+  inline void setDoneGenerationWorkOrders(const std::size_t operator_index) {
+    DCHECK(operator_index < num_operators_);
+    done_gen_[operator_index] = true;
+  }
+
+  /**
+   * @brief Get the "done generation of workorders" flag for the given operator.
+   *
+   * @param operator_index The index of the given operator.
+   **/
+  inline bool hasDoneGenerationWorkOrders(const std::size_t operator_index)
+      const {
+    DCHECK(operator_index < num_operators_);
+    return done_gen_[operator_index];
+  }
+
+ private:
+  // Total number of operators in the query.
+  const std::size_t num_operators_;
+
+  // Number of operators who've finished their execution.
+  std::size_t num_operators_finished_;
+
+  // A vector to track the number of normal WorkOrders in execution.
+  std::vector<std::size_t> queued_workorders_per_op_;
+
+  // The ith bit denotes if the operator with ID = i requires generation of
+  // rebuild WorkOrders.
+  std::vector<bool> rebuild_required_;
+
+  // The ith bit denotes if the operator with ID = i has finished generating
+  // work orders.
+  std::vector<bool> done_gen_;
+
+  // The ith bit denotes if the operator with ID = i has finished its execution.
+  std::vector<bool> execution_finished_;
+
+  // Key is dag_node_index for which rebuild is required. Value is a pair -
+  // first element is a bool (whether rebuild for operator at index i has been
+  // initiated) and if the boolean is true, the second element denotes the
+  // number of pending rebuild workorders for the operator.
+  std::unordered_map<std::size_t, std::pair<bool, std::size_t>> rebuild_status_;
+
+  DISALLOW_COPY_AND_ASSIGN(QueryExecutionState);
+};
+
+/** @} */
+
+}  // namespace quickstep
+
+#endif  // QUICKSTEP_QUERY_EXECUTION_QUERY_EXECUTION_STATE_HPP_
diff --git a/query_execution/Worker.cpp b/query_execution/Worker.cpp
index f049c18..caa2d9e 100644
--- a/query_execution/Worker.cpp
+++ b/query_execution/Worker.cpp
@@ -79,7 +79,7 @@
                                           const bool is_rebuild_work_order) {
   serialization::WorkOrderCompletionMessage proto;
   proto.set_operator_index(op_index);
-  proto.set_worker_id(worker_id_);
+  proto.set_worker_thread_index(worker_thread_index_);
 
   // NOTE(zuyu): Using the heap memory to serialize proto as a c-like string.
   const size_t proto_length = proto.ByteSize();
diff --git a/query_execution/Worker.hpp b/query_execution/Worker.hpp
index 498fa32..90092d7 100644
--- a/query_execution/Worker.hpp
+++ b/query_execution/Worker.hpp
@@ -41,17 +41,18 @@
   /**
    * @brief Constructor
    *
-   * @param worker_id The unique ID of this worker thread.
+   * @param worker_thread_index The unique index of this worker thread in
+   *        WorkerDirectory.
    * @param bus A pointer to the TMB.
    * @param cpu_id The ID of the CPU to which this worker thread can be pinned.
    *
    * @note If cpu_id is not specified, worker thread can be possibly moved
    *       around on different CPUs by the OS.
    **/
-  Worker(std::size_t worker_id,
+  Worker(const std::size_t worker_thread_index,
          MessageBus *bus,
          int cpu_id = -1)
-      : worker_id_(worker_id),
+      : worker_thread_index_(worker_thread_index),
         bus_(bus),
         cpu_id_(cpu_id) {
     DEBUG_ASSERT(bus_ != nullptr);
@@ -102,7 +103,7 @@
                                     const std::size_t op_index,
                                     const bool is_rebuild_work_order);
 
-  const std::size_t worker_id_;
+  const std::size_t worker_thread_index_;
   MessageBus *bus_;
 
   const int cpu_id_;
diff --git a/query_execution/WorkerDirectory.hpp b/query_execution/WorkerDirectory.hpp
index 32164c6..a1f3b02 100644
--- a/query_execution/WorkerDirectory.hpp
+++ b/query_execution/WorkerDirectory.hpp
@@ -1,5 +1,5 @@
 /**
- *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2015-2016 Pivotal Software, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -80,73 +80,73 @@
    *       execution and the workorder being executed by the specified worker
    *       at the time this function is called.
    *
-   * @param worker_id The logical ID of the given worker.
+   * @param worker_thread_index The logical ID of the given worker.
    *
    * @return The number of queued workorders.
    **/
   inline const std::size_t getNumQueuedWorkOrders(
-      const std::size_t worker_id) const {
-    DEBUG_ASSERT(worker_id < num_workers_);
-    return num_queued_workorders_[worker_id];
+      const std::size_t worker_thread_index) const {
+    DEBUG_ASSERT(worker_thread_index < num_workers_);
+    return num_queued_workorders_[worker_thread_index];
   }
 
   /**
    * @brief Increment the number of queued workorders for the given worker by 1.
    *
-   * @param worker_id The logical ID of the given worker.
+   * @param worker_thread_index The logical ID of the given worker.
    **/
-  inline void incrementNumQueuedWorkOrders(const std::size_t worker_id) {
-    DEBUG_ASSERT(worker_id < num_workers_);
-    ++num_queued_workorders_[worker_id];
+  inline void incrementNumQueuedWorkOrders(const std::size_t worker_thread_index) {
+    DEBUG_ASSERT(worker_thread_index < num_workers_);
+    ++num_queued_workorders_[worker_thread_index];
   }
 
   /**
    * @brief Decrement the number of queued workorders for the given worker by 1.
    *
-   * @param worker_id The logical ID of the given worker.
+   * @param worker_thread_index The logical ID of the given worker.
    **/
-  inline void decrementNumQueuedWorkOrders(const std::size_t worker_id) {
-    DEBUG_ASSERT(worker_id < num_workers_);
-    DEBUG_ASSERT(num_queued_workorders_[worker_id] >= 1);
-    --num_queued_workorders_[worker_id];
+  inline void decrementNumQueuedWorkOrders(const std::size_t worker_thread_index) {
+    DEBUG_ASSERT(worker_thread_index < num_workers_);
+    DEBUG_ASSERT(num_queued_workorders_[worker_thread_index] >= 1);
+    --num_queued_workorders_[worker_thread_index];
   }
 
   /**
    * @brief Get the NUMA node where the specified worker is pinned to.
    *
-   * @param worker_id The logical ID of the given worker.
+   * @param worker_thread_index The logical ID of the given worker.
    *
    * @return The NUMA node ID where the given worker is pinned. If the worker
    *         hasn't been pinned to any NUMA node, this value is -1.
    **/
-  inline int getNUMANode(const std::size_t worker_id) const {
-    DEBUG_ASSERT(worker_id < num_workers_);
-    return numa_node_ids_[worker_id];
+  inline int getNUMANode(const std::size_t worker_thread_index) const {
+    DEBUG_ASSERT(worker_thread_index < num_workers_);
+    return numa_node_ids_[worker_thread_index];
   }
 
   /**
    * @brief Get the TMB client ID of the specified worker.
    *
-   * @param worker_id The logical ID of the given worker.
+   * @param worker_thread_index The logical ID of the given worker.
    *
    * @return The TMB client ID of the given worker.
    **/
-  inline const client_id getClientID(const std::size_t worker_id) const {
-    DEBUG_ASSERT(worker_id < num_workers_);
-    return client_ids_[worker_id];
+  inline const client_id getClientID(const std::size_t worker_thread_index) const {
+    DEBUG_ASSERT(worker_thread_index < num_workers_);
+    return client_ids_[worker_thread_index];
   }
 
   /**
    * @brief Generate address of a worker.
    *
-   * @param worker_id The logical ID of the given worker.
+   * @param worker_thread_index The logical ID of the given worker.
    *
    * @return TMB Address of the given worker.
    **/
-  inline Address getWorkerAddress(std::size_t worker_id) const {
-    DEBUG_ASSERT(worker_id < num_workers_);
+  inline Address getWorkerAddress(std::size_t worker_thread_index) const {
+    DEBUG_ASSERT(worker_thread_index < num_workers_);
     Address worker_address;
-    worker_address.AddRecipient(client_ids_[worker_id]);
+    worker_address.AddRecipient(client_ids_[worker_thread_index]);
     return worker_address;
   }
 
@@ -185,9 +185,9 @@
         std::min_element(std::begin(num_queued_workorders_),
                          std::end(num_queued_workorders_));
     DEBUG_ASSERT(min_element_iter != num_queued_workorders_.end());
-    const std::size_t least_loaded_worker_id =
+    const std::size_t least_loaded_worker_thread_index =
         std::distance(num_queued_workorders_.begin(), min_element_iter);
-    return std::make_pair(least_loaded_worker_id, *min_element_iter);
+    return std::make_pair(least_loaded_worker_thread_index, *min_element_iter);
   }
 
   /**
@@ -212,9 +212,9 @@
         std::max_element(std::begin(num_queued_workorders_),
                          std::end(num_queued_workorders_));
     DEBUG_ASSERT(max_element_iter != num_queued_workorders_.end());
-    const std::size_t most_loaded_worker_id =
+    const std::size_t most_loaded_worker_thread_index =
         std::distance(num_queued_workorders_.begin(), max_element_iter);
-    return std::make_pair(most_loaded_worker_id, *max_element_iter);
+    return std::make_pair(most_loaded_worker_thread_index, *max_element_iter);
   }
 
  private:
diff --git a/query_execution/WorkerSelectionPolicy.hpp b/query_execution/WorkerSelectionPolicy.hpp
index 2ee18b8..289b1c4 100644
--- a/query_execution/WorkerSelectionPolicy.hpp
+++ b/query_execution/WorkerSelectionPolicy.hpp
@@ -1,5 +1,5 @@
 /**
- *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2015-2016 Pivotal Software, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -70,7 +70,7 @@
    * @brief Constructor.
    *
    * @param worker_directory The worker directory.
-   * @param start_worker_id The ID of the worker which should be chosen
+   * @param start_worker_thread_index The ID of the worker which should be chosen
    *        initially.
    *
    * @warning If the number of workers change between the constructor and
@@ -78,23 +78,23 @@
    *          getNextWorkerID() initially may not be the same as desired.
    **/
   RoundRobinWorkerSelectionPolicy(const WorkerDirectory &worker_directory,
-                                  const std::size_t start_worker_id)
+                                  const std::size_t start_worker_thread_index)
       : WorkerSelectionPolicy(worker_directory) {
-    if (start_worker_id == 0) {
-      previous_worker_id_ = worker_directory.getNumWorkers() - 1;
+    if (start_worker_thread_index == 0) {
+      previous_worker_thread_index_ = worker_directory.getNumWorkers() - 1;
     } else {
-      previous_worker_id_ = start_worker_id - 1;
+      previous_worker_thread_index_ = start_worker_thread_index - 1;
     }
   }
 
   std::size_t getNextWorkerID() override {
-    previous_worker_id_ =
-        (previous_worker_id_ + 1) % worker_directory_.getNumWorkers();
-    return previous_worker_id_;
+    previous_worker_thread_index_ =
+        (previous_worker_thread_index_ + 1) % worker_directory_.getNumWorkers();
+    return previous_worker_thread_index_;
   }
 
  private:
-  std::size_t previous_worker_id_;
+  std::size_t previous_worker_thread_index_;
 
   DISALLOW_COPY_AND_ASSIGN(RoundRobinWorkerSelectionPolicy);
 };
diff --git a/query_execution/tests/Foreman_unittest.cpp b/query_execution/tests/Foreman_unittest.cpp
index 119a491..47cc641 100644
--- a/query_execution/tests/Foreman_unittest.cpp
+++ b/query_execution/tests/Foreman_unittest.cpp
@@ -26,6 +26,7 @@
 #include "query_execution/Foreman.hpp"
 #include "query_execution/QueryContext.hpp"
 #include "query_execution/QueryContext.pb.h"
+#include "query_execution/QueryExecutionState.hpp"
 #include "query_execution/QueryExecutionTypedefs.hpp"
 #include "query_execution/WorkOrdersContainer.hpp"
 #include "query_execution/WorkerDirectory.hpp"
@@ -251,15 +252,15 @@
   }
 
   inline const int getNumWorkOrdersInExecution(const QueryPlan::DAGNodeIndex index) const {
-    return foreman_->queued_workorders_per_op_[index];
+    return foreman_->query_exec_state_->getNumQueuedWorkOrders(index);
   }
 
   inline const int getNumOperatorsFinished() const {
-    return foreman_->num_operators_finished_;
+    return foreman_->query_exec_state_->getNumOperatorsFinished();
   }
 
   inline bool getOperatorFinishedStatus(const QueryPlan::DAGNodeIndex index) const {
-    return foreman_->execution_finished_[index];
+    return foreman_->query_exec_state_->hasExecutionFinished(index);
   }
 
   inline bool popWorkOrderIfAvailable(MockWorkOrder **workorder) {
@@ -279,19 +280,19 @@
   inline bool placeDataPipelineMessage(const QueryPlan::DAGNodeIndex source_operator_index) {
     VLOG(3) << "Place DataPipeline message for Op[" << source_operator_index << "]";
     foreman_->processDataPipelineMessage(source_operator_index, 0 /* block_id */, 0 /* relation_id */);
-    return foreman_->checkQueryExecutionFinished();
+    return foreman_->query_exec_state_->hasQueryExecutionFinished();
   }
 
   inline bool placeWorkOrderCompleteMessage(const QueryPlan::DAGNodeIndex index) {
     VLOG(3) << "Place WorkOrderComplete message for Op[" << index << "]";
     foreman_->processWorkOrderCompleteMessage(index, 0 /* worker id */);
-    return foreman_->checkQueryExecutionFinished();
+    return foreman_->query_exec_state_->hasQueryExecutionFinished();
   }
 
   inline bool placeRebuildWorkOrderCompleteMessage(const QueryPlan::DAGNodeIndex index) {
     VLOG(3) << "Place RebuildWorkOrderComplete message for Op[" << index << "]";
     foreman_->processRebuildWorkOrderCompleteMessage(index, 0 /* worker id */);
-    return foreman_->checkQueryExecutionFinished();
+    return foreman_->query_exec_state_->hasQueryExecutionFinished();
   }
 
   inline bool placeOutputBlockMessage(const QueryPlan::DAGNodeIndex index) {
@@ -299,12 +300,12 @@
     foreman_->processDataPipelineMessage(index,
                                          BlockIdUtil::GetBlockId(1 /* domain */, 1),
                                          0 /* relation_id */);
-    return foreman_->checkQueryExecutionFinished();
+    return foreman_->query_exec_state_->hasQueryExecutionFinished();
   }
 
   inline bool startForeman() {
     foreman_->initialize();
-    return foreman_->checkQueryExecutionFinished();
+    return foreman_->query_exec_state_->hasQueryExecutionFinished();
   }
 
   inline int getWorkerInputQueueSize() {
diff --git a/query_execution/tests/WorkerDirectory_unittest.cpp b/query_execution/tests/WorkerDirectory_unittest.cpp
index 90cdde5..eb83583 100644
--- a/query_execution/tests/WorkerDirectory_unittest.cpp
+++ b/query_execution/tests/WorkerDirectory_unittest.cpp
@@ -1,5 +1,5 @@
 /**
- *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2015-2016 Pivotal Software, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -62,29 +62,29 @@
     numa_nodes.reserve(kNumWorkers);
     client_ids.reserve(kNumWorkers);
 
-    for (std::size_t worker_id = 0; worker_id < kNumWorkers; ++worker_id) {
-      // NUMA node id = worker_id % 4
-      // Client ID = worker_id * 2 + 1
-      const client_id cid = worker_id * 2 + 1;
-      const int numa_node_id = worker_id % 4;
+    for (std::size_t worker_thread_index = 0; worker_thread_index < kNumWorkers; ++worker_thread_index) {
+      // NUMA node id = worker_thread_index % 4
+      // Client ID = worker_thread_index * 2 + 1
+      const client_id cid = worker_thread_index * 2 + 1;
+      const int numa_node_id = worker_thread_index % 4;
 
       numa_nodes.push_back(numa_node_id);
       client_ids.push_back(cid);
 
-      worker_ids_.push_back(worker_id);
-      actual_workers_[worker_id] = std::make_pair(numa_node_id, cid);
+      worker_thread_indexs_.push_back(worker_thread_index);
+      actual_workers_[worker_thread_index] = std::make_pair(numa_node_id, cid);
     }
     wd_.reset(new WorkerDirectory(kNumWorkers, client_ids, numa_nodes));
 
     // Randomize the order of worker IDs.
-    std::random_shuffle(worker_ids_.begin(), worker_ids_.end());
+    std::random_shuffle(worker_thread_indexs_.begin(), worker_thread_indexs_.end());
   }
 
   // First element is NUMA Node. Second element is client ID.
   // Input is the logical worker ID.
   std::pair<int, client_id> getNUMANodeAndClientIDForWorker(
-      const std::size_t worker_id) {
-    return actual_workers_[worker_id];
+      const std::size_t worker_thread_index) {
+    return actual_workers_[worker_thread_index];
   }
 
   WorkerDirectory* getWorkerDirectory() {
@@ -96,8 +96,8 @@
   }
 
   std::vector<size_t>& getRandomizedWorkerIDs() {
-    std::random_shuffle(worker_ids_.begin(), worker_ids_.end());
-    return worker_ids_;
+    std::random_shuffle(worker_thread_indexs_.begin(), worker_thread_indexs_.end());
+    return worker_thread_indexs_;
   }
 
  private:
@@ -107,7 +107,7 @@
   // Value = pair <NUMA node ID, client ID> for the worker.
   std::unordered_map<std::size_t, std::pair<int, client_id>> actual_workers_;
 
-  std::vector<std::size_t> worker_ids_;
+  std::vector<std::size_t> worker_thread_indexs_;
 
   const std::size_t kNumWorkers = 100;
 };
@@ -119,12 +119,12 @@
 
   EXPECT_EQ(getActualNumWorkers(), wd->getNumWorkers());
 
-  for (std::size_t worker_id : getRandomizedWorkerIDs()) {
+  for (std::size_t worker_thread_index : getRandomizedWorkerIDs()) {
     const std::pair<int, client_id> observed_ids =
-        getNUMANodeAndClientIDForWorker(worker_id);
-    EXPECT_EQ(observed_ids.first, wd->getNUMANode(worker_id));
-    EXPECT_EQ(observed_ids.second, wd->getClientID(worker_id));
-    EXPECT_EQ(0u, wd->getNumQueuedWorkOrders(worker_id));
+        getNUMANodeAndClientIDForWorker(worker_thread_index);
+    EXPECT_EQ(observed_ids.first, wd->getNUMANode(worker_thread_index));
+    EXPECT_EQ(observed_ids.second, wd->getClientID(worker_thread_index));
+    EXPECT_EQ(0u, wd->getNumQueuedWorkOrders(worker_thread_index));
   }
 }
 
@@ -159,38 +159,38 @@
 
   // Perform the increment or decrement operation as determined by the sequence
   // and check the correctness.
-  std::stack<std::size_t> worker_ids_used;
+  std::stack<std::size_t> worker_thread_indexs_used;
   for (bool to_increment : increment_decrement_sequence) {
     if (to_increment) {
       // Pick a random worker ID and increment its number of workorders.
-      const std::size_t chosen_worker_id = dist(mt);
-      worker_ids_used.push(chosen_worker_id);
-      EXPECT_EQ(actual_num_workorders[chosen_worker_id],
-                wd->getNumQueuedWorkOrders(chosen_worker_id));
-      wd->incrementNumQueuedWorkOrders(chosen_worker_id);
-      ++actual_num_workorders[chosen_worker_id];
-      EXPECT_EQ(actual_num_workorders[chosen_worker_id],
-                wd->getNumQueuedWorkOrders(chosen_worker_id));
+      const std::size_t chosen_worker_thread_index = dist(mt);
+      worker_thread_indexs_used.push(chosen_worker_thread_index);
+      EXPECT_EQ(actual_num_workorders[chosen_worker_thread_index],
+                wd->getNumQueuedWorkOrders(chosen_worker_thread_index));
+      wd->incrementNumQueuedWorkOrders(chosen_worker_thread_index);
+      ++actual_num_workorders[chosen_worker_thread_index];
+      EXPECT_EQ(actual_num_workorders[chosen_worker_thread_index],
+                wd->getNumQueuedWorkOrders(chosen_worker_thread_index));
     } else {
       // For the worker with ID = top of stack, decrement a workorder.
-      const std::size_t chosen_worker_id = worker_ids_used.top();
-      worker_ids_used.pop();
-      EXPECT_EQ(actual_num_workorders[chosen_worker_id],
-                wd->getNumQueuedWorkOrders(chosen_worker_id));
-      wd->decrementNumQueuedWorkOrders(chosen_worker_id);
-      --actual_num_workorders[chosen_worker_id];
-      EXPECT_EQ(actual_num_workorders[chosen_worker_id],
-                wd->getNumQueuedWorkOrders(chosen_worker_id));
+      const std::size_t chosen_worker_thread_index = worker_thread_indexs_used.top();
+      worker_thread_indexs_used.pop();
+      EXPECT_EQ(actual_num_workorders[chosen_worker_thread_index],
+                wd->getNumQueuedWorkOrders(chosen_worker_thread_index));
+      wd->decrementNumQueuedWorkOrders(chosen_worker_thread_index);
+      --actual_num_workorders[chosen_worker_thread_index];
+      EXPECT_EQ(actual_num_workorders[chosen_worker_thread_index],
+                wd->getNumQueuedWorkOrders(chosen_worker_thread_index));
     }
   }
 
   // Stack should be empty.
-  EXPECT_TRUE(worker_ids_used.empty());
+  EXPECT_TRUE(worker_thread_indexs_used.empty());
   // Expect no queued up workorders for any worker.
-  for (const std::size_t random_worker_id : getRandomizedWorkerIDs()) {
-    EXPECT_EQ(0u, wd->getNumQueuedWorkOrders(random_worker_id));
-    EXPECT_EQ(actual_num_workorders[random_worker_id],
-              wd->getNumQueuedWorkOrders(random_worker_id));
+  for (const std::size_t random_worker_thread_index : getRandomizedWorkerIDs()) {
+    EXPECT_EQ(0u, wd->getNumQueuedWorkOrders(random_worker_thread_index));
+    EXPECT_EQ(actual_num_workorders[random_worker_thread_index],
+              wd->getNumQueuedWorkOrders(random_worker_thread_index));
   }
 }
 
@@ -204,21 +204,21 @@
   wd->addWorker(new_worker_client_id, new_worker_numa_node);
 
   // The logical ID of the new worker.
-  const std::size_t new_worker_id = getActualNumWorkers();
+  const std::size_t new_worker_thread_index = getActualNumWorkers();
 
   EXPECT_EQ(getActualNumWorkers() + 1, wd->getNumWorkers());
   // Check if the client ID is set correctly.
-  EXPECT_EQ(new_worker_client_id, wd->getClientID(new_worker_id));
+  EXPECT_EQ(new_worker_client_id, wd->getClientID(new_worker_thread_index));
   // Check if the NUMA node ID is set correctly.
-  EXPECT_EQ(new_worker_numa_node, wd->getNUMANode(new_worker_id));
+  EXPECT_EQ(new_worker_numa_node, wd->getNUMANode(new_worker_thread_index));
   // Check if the new worker has no queued up workorders.
-  EXPECT_EQ(0u, wd->getNumQueuedWorkOrders(new_worker_id));
+  EXPECT_EQ(0u, wd->getNumQueuedWorkOrders(new_worker_thread_index));
   // Increment a workorder for the new worker, check if the increment is
   // successful, then perform a decrement and check the correctness.
-  wd->incrementNumQueuedWorkOrders(new_worker_id);
-  EXPECT_EQ(1u, wd->getNumQueuedWorkOrders(new_worker_id));
-  wd->decrementNumQueuedWorkOrders(new_worker_id);
-  EXPECT_EQ(0u, wd->getNumQueuedWorkOrders(new_worker_id));
+  wd->incrementNumQueuedWorkOrders(new_worker_thread_index);
+  EXPECT_EQ(1u, wd->getNumQueuedWorkOrders(new_worker_thread_index));
+  wd->decrementNumQueuedWorkOrders(new_worker_thread_index);
+  EXPECT_EQ(0u, wd->getNumQueuedWorkOrders(new_worker_thread_index));
 }
 
 TEST_F(WorkerDirectoryTest, WorkerLoadTest) {
@@ -231,8 +231,8 @@
   actual_num_workorders.resize(getActualNumWorkers(), 0);
 
   // Loop over workers sequentially and increment workorder of all the workers.
-  for (std::size_t worker_id = 0; worker_id < getActualNumWorkers();
-       ++worker_id) {
+  for (std::size_t worker_thread_index = 0; worker_thread_index < getActualNumWorkers();
+       ++worker_thread_index) {
     const std::pair<std::size_t, std::size_t> &actual_min_loaded_worker =
         getMinElement(actual_num_workorders);
     const std::pair<std::size_t, std::size_t> &actual_max_loaded_worker =
@@ -241,15 +241,15 @@
     EXPECT_EQ(actual_min_loaded_worker, wd->getLeastLoadedWorker());
     EXPECT_EQ(actual_max_loaded_worker, wd->getMostLoadedWorker());
 
-    wd->incrementNumQueuedWorkOrders(worker_id);
-    ++actual_num_workorders[worker_id];
-    EXPECT_EQ(actual_num_workorders[worker_id],
-              wd->getNumQueuedWorkOrders(worker_id));
+    wd->incrementNumQueuedWorkOrders(worker_thread_index);
+    ++actual_num_workorders[worker_thread_index];
+    EXPECT_EQ(actual_num_workorders[worker_thread_index],
+              wd->getNumQueuedWorkOrders(worker_thread_index));
   }
 
   // At this time, every worker has exactly one workorder assigned to it.
   // Now increment workorders in a random order.
-  for (const std::size_t random_worker_id : getRandomizedWorkerIDs()) {
+  for (const std::size_t random_worker_thread_index : getRandomizedWorkerIDs()) {
     const std::pair<std::size_t, std::size_t> actual_min_loaded_worker =
         getMinElement(actual_num_workorders);
     const std::pair<std::size_t, std::size_t> actual_max_loaded_worker =
@@ -258,16 +258,16 @@
     EXPECT_EQ(actual_min_loaded_worker, wd->getLeastLoadedWorker());
     EXPECT_EQ(actual_max_loaded_worker, wd->getMostLoadedWorker());
 
-    wd->incrementNumQueuedWorkOrders(random_worker_id);
-    ++actual_num_workorders[random_worker_id];
-    EXPECT_EQ(actual_num_workorders[random_worker_id],
-              wd->getNumQueuedWorkOrders(random_worker_id));
+    wd->incrementNumQueuedWorkOrders(random_worker_thread_index);
+    ++actual_num_workorders[random_worker_thread_index];
+    EXPECT_EQ(actual_num_workorders[random_worker_thread_index],
+              wd->getNumQueuedWorkOrders(random_worker_thread_index));
   }
 
   // At this time, every worker has two workorders assigned to it.
   // Now decrement workorders in a random order twice.
   for (std::size_t iteration = 0; iteration < 2; ++iteration) {
-    for (const std::size_t random_worker_id : getRandomizedWorkerIDs()) {
+    for (const std::size_t random_worker_thread_index : getRandomizedWorkerIDs()) {
       const std::pair<std::size_t, std::size_t> actual_min_loaded_worker =
           getMinElement(actual_num_workorders);
       const std::pair<std::size_t, std::size_t> actual_max_loaded_worker =
@@ -276,10 +276,10 @@
       EXPECT_EQ(actual_min_loaded_worker, wd->getLeastLoadedWorker());
       EXPECT_EQ(actual_max_loaded_worker, wd->getMostLoadedWorker());
 
-      wd->decrementNumQueuedWorkOrders(random_worker_id);
-      --actual_num_workorders[random_worker_id];
-      EXPECT_EQ(actual_num_workorders[random_worker_id],
-                wd->getNumQueuedWorkOrders(random_worker_id));
+      wd->decrementNumQueuedWorkOrders(random_worker_thread_index);
+      --actual_num_workorders[random_worker_thread_index];
+      EXPECT_EQ(actual_num_workorders[random_worker_thread_index],
+                wd->getNumQueuedWorkOrders(random_worker_thread_index));
     }
   }
   const std::pair<std::size_t, std::size_t> actual_min_loaded_worker =
diff --git a/query_execution/tests/WorkerSelectionPolicy_unittest.cpp b/query_execution/tests/WorkerSelectionPolicy_unittest.cpp
index 32f161e..83d3c78 100644
--- a/query_execution/tests/WorkerSelectionPolicy_unittest.cpp
+++ b/query_execution/tests/WorkerSelectionPolicy_unittest.cpp
@@ -1,5 +1,5 @@
 /**
- *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2015-2016 Pivotal Software, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -49,11 +49,11 @@
 
     std::random_device rd;
     mt_.reset(new std::mt19937_64(rd()));
-    for (std::size_t worker_id = 0; worker_id < kNumWorkers; ++worker_id) {
-      // NUMA node id = worker_id % 4
-      // Client ID = worker_id * 2 + 1
-      numa_nodes.push_back(worker_id % 4);
-      client_ids.push_back(worker_id * 2 + 1);
+    for (std::size_t worker_thread_index = 0; worker_thread_index < kNumWorkers; ++worker_thread_index) {
+      // NUMA node id = worker_thread_index % 4
+      // Client ID = worker_thread_index * 2 + 1
+      numa_nodes.push_back(worker_thread_index % 4);
+      client_ids.push_back(worker_thread_index * 2 + 1);
     }
     directory_.reset(new WorkerDirectory(kNumWorkers, client_ids, numa_nodes));
   }
@@ -72,10 +72,10 @@
 
   const std::size_t kNumIterations =
       (getWorkerDirectory()->getNumWorkers()) * 2;
-  std::size_t expected_next_worker_id = kStartWorkerID;
+  std::size_t expected_next_worker_thread_index = kStartWorkerID;
   for (std::size_t iteration = 0; iteration < kNumIterations; ++iteration) {
-    EXPECT_EQ(expected_next_worker_id, rr_policy.getNextWorkerID());
-    expected_next_worker_id = (expected_next_worker_id + 1) %
+    EXPECT_EQ(expected_next_worker_thread_index, rr_policy.getNextWorkerID());
+    expected_next_worker_thread_index = (expected_next_worker_thread_index + 1) %
                               (getWorkerDirectory()->getNumWorkers());
   }
 }
@@ -90,11 +90,11 @@
   EXPECT_EQ(kStartWorkerID, rr_policy.getNextWorkerID());
 
   // Add a new worker.
-  const std::size_t new_worker_id = getWorkerDirectory()->getNumWorkers();
-  getWorkerDirectory()->addWorker(new_worker_id * 2 + 1 /** client_id **/,
+  const std::size_t new_worker_thread_index = getWorkerDirectory()->getNumWorkers();
+  getWorkerDirectory()->addWorker(new_worker_thread_index * 2 + 1 /** client_id **/,
                                   0 /** NUMA node ID **/);
 
-  EXPECT_EQ(new_worker_id, rr_policy.getNextWorkerID());
+  EXPECT_EQ(new_worker_thread_index, rr_policy.getNextWorkerID());
 }
 
 TEST_F(WorkerSelectionPolicyTest, LoadBalancingTest) {
@@ -107,9 +107,9 @@
   std::mt19937_64 mt(rd());
   std::uniform_int_distribution<std::size_t> dist(0, kMaxLoad);
 
-  for (std::size_t worker_id = 0;
-       worker_id < getWorkerDirectory()->getNumWorkers();
-       ++worker_id) {
+  for (std::size_t worker_thread_index = 0;
+       worker_thread_index < getWorkerDirectory()->getNumWorkers();
+       ++worker_thread_index) {
     // For each worker ..
     const std::size_t worker_load = dist(mt);
     // assign a random load.
@@ -117,7 +117,7 @@
     for (std::size_t workorder_count = 0;
          workorder_count < worker_load;
          ++workorder_count) {
-      getWorkerDirectory()->incrementNumQueuedWorkOrders(worker_id);
+      getWorkerDirectory()->incrementNumQueuedWorkOrders(worker_thread_index);
     }
   }
 
@@ -148,18 +148,18 @@
   const std::size_t kNumIterations = 100;
 
   for (std::size_t iter = 0; iter < kNumIterations; ++iter) {
-    const std::size_t chosen_worker_id = rand_policy.getNextWorkerID();
-    EXPECT_GE(getWorkerDirectory()->getNumWorkers(), chosen_worker_id);
+    const std::size_t chosen_worker_thread_index = rand_policy.getNextWorkerID();
+    EXPECT_GE(getWorkerDirectory()->getNumWorkers(), chosen_worker_thread_index);
   }
 
   // Add a new worker and repeat the test above.
-  const std::size_t new_worker_id = getWorkerDirectory()->getNumWorkers();
-  getWorkerDirectory()->addWorker(new_worker_id * 2 + 1 /** client_id **/,
+  const std::size_t new_worker_thread_index = getWorkerDirectory()->getNumWorkers();
+  getWorkerDirectory()->addWorker(new_worker_thread_index * 2 + 1 /** client_id **/,
                                   0 /** NUMA node ID **/);
 
   for (std::size_t iter = 0; iter < kNumIterations; ++iter) {
-    const std::size_t chosen_worker_id = rand_policy.getNextWorkerID();
-    EXPECT_GE(getWorkerDirectory()->getNumWorkers(), chosen_worker_id);
+    const std::size_t chosen_worker_thread_index = rand_policy.getNextWorkerID();
+    EXPECT_GE(getWorkerDirectory()->getNumWorkers(), chosen_worker_thread_index);
   }
 }
 
diff --git a/query_optimizer/CMakeLists.txt b/query_optimizer/CMakeLists.txt
index 6b7d097..a11a994 100644
--- a/query_optimizer/CMakeLists.txt
+++ b/query_optimizer/CMakeLists.txt
@@ -76,6 +76,7 @@
                       quickstep_queryoptimizer_physical_DeleteTuples
                       quickstep_queryoptimizer_physical_DropTable
                       quickstep_queryoptimizer_physical_HashJoin
+                      quickstep_queryoptimizer_physical_InsertSelection
                       quickstep_queryoptimizer_physical_InsertTuple
                       quickstep_queryoptimizer_physical_NestedLoopsJoin
                       quickstep_queryoptimizer_physical_PatternMatcher
diff --git a/query_optimizer/ExecutionGenerator.cpp b/query_optimizer/ExecutionGenerator.cpp
index 68a07ea..f9d7d98 100644
--- a/query_optimizer/ExecutionGenerator.cpp
+++ b/query_optimizer/ExecutionGenerator.cpp
@@ -58,6 +58,7 @@
 #include "query_optimizer/physical/DeleteTuples.hpp"
 #include "query_optimizer/physical/DropTable.hpp"
 #include "query_optimizer/physical/HashJoin.hpp"
+#include "query_optimizer/physical/InsertSelection.hpp"
 #include "query_optimizer/physical/InsertTuple.hpp"
 #include "query_optimizer/physical/NestedLoopsJoin.hpp"
 #include "query_optimizer/physical/PatternMatcher.hpp"
@@ -213,6 +214,9 @@
     case P::PhysicalType::kHashJoin:
       return convertHashJoin(
           std::static_pointer_cast<const P::HashJoin>(physical_plan));
+    case P::PhysicalType::kInsertSelection:
+      return convertInsertSelection(
+          std::static_pointer_cast<const P::InsertSelection>(physical_plan));
     case P::PhysicalType::kInsertTuple:
       return convertInsertTuple(
           std::static_pointer_cast<const P::InsertTuple>(physical_plan));
@@ -1020,6 +1024,87 @@
                                        false /* is_pipeline_breaker */);
 }
 
+void ExecutionGenerator::convertInsertSelection(
+    const P::InsertSelectionPtr &physical_plan) {
+  // InsertSelection is converted to a Select and a SaveBlocks.
+
+  const CatalogRelationInfo *destination_relation_info =
+      findRelationInfoOutputByPhysical(physical_plan->destination());
+  const CatalogRelation &destination_relation = *destination_relation_info->relation;
+
+  // FIXME(qzeng): A better way is using a traits struct to look up whether a storage
+  //               block supports ad-hoc insertion instead of hard-coding the block types.
+  const StorageBlockLayout &storage_block_layout =
+      destination_relation.getDefaultStorageBlockLayout();
+  if (storage_block_layout.getDescription().tuple_store_description().sub_block_type() ==
+          TupleStorageSubBlockDescription::COMPRESSED_COLUMN_STORE
+      || storage_block_layout.getDescription().tuple_store_description().sub_block_type() ==
+             TupleStorageSubBlockDescription::COMPRESSED_PACKED_ROW_STORE) {
+    THROW_SQL_ERROR() << "INSERT statement is not supported for the relation "
+                      << destination_relation.getName()
+                      << ", because its storage blocks do not support ad-hoc insertion";
+  }
+
+  // Create InsertDestination proto.
+  const QueryContext::insert_destination_id insert_destination_index =
+      query_context_proto_->insert_destinations_size();
+  S::InsertDestination *insert_destination_proto = query_context_proto_->add_insert_destinations();
+
+  insert_destination_proto->set_insert_destination_type(S::InsertDestinationType::BLOCK_POOL);
+  insert_destination_proto->set_relation_id(destination_relation.getID());
+  insert_destination_proto->mutable_layout()->MergeFrom(
+      destination_relation.getDefaultStorageBlockLayout().getDescription());
+
+  const vector<block_id> blocks(destination_relation.getBlocksSnapshot());
+  for (const block_id block : blocks) {
+    insert_destination_proto->AddExtension(S::BlockPoolInsertDestination::blocks, block);
+  }
+
+  const CatalogRelationInfo *selection_relation_info =
+      findRelationInfoOutputByPhysical(physical_plan->selection());
+
+  // Prepare the attributes, which are output columns of the selection relation.
+  std::unique_ptr<std::vector<attribute_id>> attributes(new std::vector<attribute_id>());
+  for (E::AttributeReferencePtr attr_ref : physical_plan->selection()->getOutputAttributes()) {
+    unique_ptr<const Scalar> attribute(attr_ref->concretize(attribute_substitution_map_));
+
+    DCHECK_EQ(Scalar::kAttribute, attribute->getDataSource());
+    attributes->emplace_back(
+        static_cast<const ScalarAttribute*>(attribute.get())->getAttribute().getID());
+  }
+
+  // Create the select operator.
+  // TODO(jianqiao): This select operator is actually redundant. That is,
+  // we may directly set physical_plan_->selection()'s output relation to be
+  // destination_relation, instead of creating an intermediate selection_relation
+  // and then copy the data into destination_relation. One way to achieve this
+  // optimization is to enable specifying a specific output relation for each
+  // physical plan by modifying class Physical.
+  SelectOperator *insert_selection_op =
+      new SelectOperator(*selection_relation_info->relation,
+                         destination_relation,
+                         insert_destination_index,
+                         QueryContext::kInvalidPredicateId,
+                         attributes.release(),
+                         selection_relation_info->isStoredRelation());
+
+  const QueryPlan::DAGNodeIndex insert_selection_index =
+      execution_plan_->addRelationalOperator(insert_selection_op);
+  insert_destination_proto->set_relational_op_index(insert_selection_index);
+
+  const QueryPlan::DAGNodeIndex save_blocks_index =
+      execution_plan_->addRelationalOperator(new SaveBlocksOperator());
+
+  if (!selection_relation_info->isStoredRelation()) {
+    execution_plan_->addDirectDependency(insert_selection_index,
+                                         selection_relation_info->producer_operator_index,
+                                         false /* is_pipeline_breaker */);
+  }
+  execution_plan_->addDirectDependency(save_blocks_index,
+                                       insert_selection_index,
+                                       false /* is_pipeline_breaker */);
+}
+
 void ExecutionGenerator::convertUpdateTable(
     const P::UpdateTablePtr &physical_plan) {
   // UpdateTable is converted to an Update and a SaveBlocks.
@@ -1124,6 +1209,9 @@
       unique_ptr<const Scalar> concretized_argument(argument->concretize(attribute_substitution_map_));
       aggr_proto->add_argument()->CopyFrom(concretized_argument->getProto());
     }
+
+    // Set whether it is a DISTINCT aggregation.
+    aggr_proto->set_is_distinct(unnamed_aggregate_expression->is_distinct());
   }
 
   std::vector<const Type*> group_by_types;
diff --git a/query_optimizer/ExecutionGenerator.hpp b/query_optimizer/ExecutionGenerator.hpp
index 78cecc9..11de106 100644
--- a/query_optimizer/ExecutionGenerator.hpp
+++ b/query_optimizer/ExecutionGenerator.hpp
@@ -40,6 +40,7 @@
 #include "query_optimizer/physical/DeleteTuples.hpp"
 #include "query_optimizer/physical/DropTable.hpp"
 #include "query_optimizer/physical/HashJoin.hpp"
+#include "query_optimizer/physical/InsertSelection.hpp"
 #include "query_optimizer/physical/InsertTuple.hpp"
 #include "query_optimizer/physical/NestedLoopsJoin.hpp"
 #include "query_optimizer/physical/Physical.hpp"
@@ -292,6 +293,13 @@
   void convertDropTable(const physical::DropTablePtr &physical_plan);
 
   /**
+   * @brief Converts an InsertSelection to a Select and a SaveBlocks.
+   *
+   * @param physical_plan The InsertSelection to be converted.
+   */
+  void convertInsertSelection(const physical::InsertSelectionPtr &physical_plan);
+
+  /**
    * @brief Converts an InsertTuple to an Insert and a SaveBlocks.
    *
    * @param physical_plan The InsertTuple to be converted.
diff --git a/query_optimizer/expressions/AggregateFunction.cpp b/query_optimizer/expressions/AggregateFunction.cpp
index 1722450..e061f03 100644
--- a/query_optimizer/expressions/AggregateFunction.cpp
+++ b/query_optimizer/expressions/AggregateFunction.cpp
@@ -1,5 +1,7 @@
 /**
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -59,7 +61,8 @@
 AggregateFunctionPtr AggregateFunction::Create(
     const ::quickstep::AggregateFunction &aggregate,
     const std::vector<ScalarPtr> &arguments,
-    const bool is_vector_aggregate) {
+    const bool is_vector_aggregate,
+    const bool is_distinct) {
 #ifdef QUICKSTEP_DEBUG
   std::vector<const Type*> argument_types;
   for (const ScalarPtr &argument : arguments) {
@@ -69,7 +72,7 @@
 #endif  // QUICKSTEP_DEBUG
 
   return AggregateFunctionPtr(
-      new AggregateFunction(aggregate, arguments, is_vector_aggregate));
+      new AggregateFunction(aggregate, arguments, is_vector_aggregate, is_distinct));
 }
 
 ExpressionPtr AggregateFunction::copyWithNewChildren(
@@ -82,7 +85,7 @@
     new_arguments.emplace_back(std::move(expr_as_scalar));
   }
 
-  return Create(aggregate_, new_arguments, is_vector_aggregate_);
+  return Create(aggregate_, new_arguments, is_vector_aggregate_, is_distinct_);
 }
 
 std::vector<AttributeReferencePtr> AggregateFunction::getReferencedAttributes() const {
@@ -107,6 +110,11 @@
   inline_field_names->push_back("function");
   inline_field_values->push_back(aggregate_.getName());
 
+  if (is_distinct_) {
+    inline_field_names->push_back("is_distinct");
+    inline_field_values->push_back("true");
+  }
+
   container_child_field_names->push_back("");
   container_child_fields->emplace_back(CastSharedPtrVector<OptimizerTreeBase>(arguments_));
 }
diff --git a/query_optimizer/expressions/AggregateFunction.hpp b/query_optimizer/expressions/AggregateFunction.hpp
index dcc09ea..86698fd 100644
--- a/query_optimizer/expressions/AggregateFunction.hpp
+++ b/query_optimizer/expressions/AggregateFunction.hpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -104,6 +106,13 @@
     return arguments_;
   }
 
+  /*
+   * @return Whether this is a DISTINCT aggregation.
+   */
+  inline bool is_distinct() const {
+    return is_distinct_;
+  }
+
   /**
    * @brief Create a new AggregateFunction.
    *
@@ -114,11 +123,13 @@
    *        system.
    * @param arguments A list of arguments to the aggregate function.
    * @param is_vector_aggregate Whether the aggregate has a GROUP BY clause.
+   * @param is_distinct Whether this is a DISTINCT aggregation.
    * @return A new AggregateFunctionPtr.
    **/
   static AggregateFunctionPtr Create(const ::quickstep::AggregateFunction &aggregate,
                                      const std::vector<ScalarPtr> &arguments,
-                                     const bool is_vector_aggregate);
+                                     const bool is_vector_aggregate,
+                                     const bool is_distinct);
 
  protected:
   void getFieldStringItems(
@@ -137,13 +148,16 @@
    * @param arguments The scalar arguments to the aggregate function.
    * @param is_vector_aggregate Indicates whether this aggregation is a vector
    *                            aggregation (i.e. GROUP BY exists).
+   * @param is_distinct Indicates whether this is a DISTINCT aggregation.
    */
   AggregateFunction(const ::quickstep::AggregateFunction &aggregate,
                     const std::vector<ScalarPtr> &arguments,
-                    const bool is_vector_aggregate)
+                    const bool is_vector_aggregate,
+                    const bool is_distinct)
       : aggregate_(aggregate),
         arguments_(arguments),
-        is_vector_aggregate_(is_vector_aggregate) {
+        is_vector_aggregate_(is_vector_aggregate),
+        is_distinct_(is_distinct) {
     for (const ScalarPtr &child : arguments_) {
       addChild(child);
     }
@@ -151,7 +165,8 @@
 
   const ::quickstep::AggregateFunction &aggregate_;
   std::vector<ScalarPtr> arguments_;
-  bool is_vector_aggregate_;
+  const bool is_vector_aggregate_;
+  const bool is_distinct_;
 
   DISALLOW_COPY_AND_ASSIGN(AggregateFunction);
 };
diff --git a/query_optimizer/expressions/UnaryExpression.cpp b/query_optimizer/expressions/UnaryExpression.cpp
index 508ed6c..ae88d57 100644
--- a/query_optimizer/expressions/UnaryExpression.cpp
+++ b/query_optimizer/expressions/UnaryExpression.cpp
@@ -37,8 +37,7 @@
 namespace expressions {
 
 std::string UnaryExpression::getName() const {
-  DCHECK(operation_.getUnaryOperationID() == UnaryOperationID::kNegate);
-  return "Negate";
+  return operation_.getName();
 }
 
 ExpressionPtr UnaryExpression::copyWithNewChildren(
diff --git a/query_optimizer/logical/CMakeLists.txt b/query_optimizer/logical/CMakeLists.txt
index de660a4..38cff8d 100644
--- a/query_optimizer/logical/CMakeLists.txt
+++ b/query_optimizer/logical/CMakeLists.txt
@@ -23,6 +23,7 @@
 add_library(quickstep_queryoptimizer_logical_DropTable DropTable.cpp DropTable.hpp)
 add_library(quickstep_queryoptimizer_logical_Filter Filter.cpp Filter.hpp)
 add_library(quickstep_queryoptimizer_logical_HashJoin ../../empty_src.cpp HashJoin.hpp)
+add_library(quickstep_queryoptimizer_logical_InsertSelection InsertSelection.cpp InsertSelection.hpp)
 add_library(quickstep_queryoptimizer_logical_InsertTuple InsertTuple.cpp InsertTuple.hpp)
 add_library(quickstep_queryoptimizer_logical_Join ../../empty_src.cpp Join.hpp)
 add_library(quickstep_queryoptimizer_logical_Logical ../../empty_src.cpp Logical.hpp)
@@ -123,6 +124,13 @@
                       quickstep_queryoptimizer_logical_LogicalType
                       quickstep_utility_Cast
                       quickstep_utility_Macros)
+target_link_libraries(quickstep_queryoptimizer_logical_InsertSelection
+                      glog
+                      quickstep_queryoptimizer_OptimizerTree
+                      quickstep_queryoptimizer_expressions_AttributeReference
+                      quickstep_queryoptimizer_logical_Logical
+                      quickstep_queryoptimizer_logical_LogicalType
+                      quickstep_utility_Macros)
 target_link_libraries(quickstep_queryoptimizer_logical_InsertTuple
                       glog
                       quickstep_queryoptimizer_OptimizerTree
@@ -249,6 +257,7 @@
                       quickstep_queryoptimizer_logical_DropTable
                       quickstep_queryoptimizer_logical_Filter
                       quickstep_queryoptimizer_logical_HashJoin
+                      quickstep_queryoptimizer_logical_InsertSelection
                       quickstep_queryoptimizer_logical_InsertTuple
                       quickstep_queryoptimizer_logical_Join
                       quickstep_queryoptimizer_logical_Logical
diff --git a/query_optimizer/logical/InsertSelection.cpp b/query_optimizer/logical/InsertSelection.cpp
new file mode 100644
index 0000000..2744b44
--- /dev/null
+++ b/query_optimizer/logical/InsertSelection.cpp
@@ -0,0 +1,45 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#include "query_optimizer/logical/InsertSelection.hpp"
+
+#include <string>
+#include <vector>
+
+#include "query_optimizer/OptimizerTree.hpp"
+
+namespace quickstep {
+namespace optimizer {
+namespace logical {
+
+void InsertSelection::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("destination");
+  non_container_child_fields->push_back(destination_);
+
+  non_container_child_field_names->push_back("selection");
+  non_container_child_fields->push_back(selection_);
+}
+
+}  // namespace logical
+}  // namespace optimizer
+}  // namespace quickstep
diff --git a/query_optimizer/logical/InsertSelection.hpp b/query_optimizer/logical/InsertSelection.hpp
new file mode 100644
index 0000000..c36ecd0
--- /dev/null
+++ b/query_optimizer/logical/InsertSelection.hpp
@@ -0,0 +1,120 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#ifndef QUICKSTEP_QUERY_OPTIMIZER_LOGICAL_INSERT_SELECTION_HPP_
+#define QUICKSTEP_QUERY_OPTIMIZER_LOGICAL_INSERT_SELECTION_HPP_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "query_optimizer/OptimizerTree.hpp"
+#include "query_optimizer/expressions/AttributeReference.hpp"
+#include "query_optimizer/logical/Logical.hpp"
+#include "query_optimizer/logical/LogicalType.hpp"
+#include "utility/Macros.hpp"
+
+#include "glog/logging.h"
+
+namespace quickstep {
+namespace optimizer {
+namespace logical {
+
+/** \addtogroup OptimizerLogical
+ *  @{
+ */
+
+class InsertSelection;
+typedef std::shared_ptr<const InsertSelection> InsertSelectionPtr;
+
+/**
+ * @brief Inserts the results from a SELECT query into a relation.
+ */
+class InsertSelection : public Logical {
+ public:
+  LogicalType getLogicalType() const override { return LogicalType::kInsertSelection; }
+
+  std::string getName() const override { return "InsertSelection"; }
+
+  /**
+   * @return The destination relation to insert the selection to.
+   */
+  const LogicalPtr& destination() const { return destination_; }
+
+  /**
+   * @return The selection to be inserted.
+   */
+  const LogicalPtr& selection() const { return selection_; }
+
+  LogicalPtr copyWithNewChildren(
+      const std::vector<LogicalPtr> &new_children) const override {
+    DCHECK_EQ(getNumChildren(), new_children.size());
+    return Create(new_children[0], new_children[1]);
+  }
+
+  std::vector<expressions::AttributeReferencePtr> getOutputAttributes() const override {
+    return {};
+  }
+
+  std::vector<expressions::AttributeReferencePtr> getReferencedAttributes() const override {
+    return selection_->getOutputAttributes();
+  }
+
+  /**
+   * @brief Creates an InsertSelection logical node.
+   *
+   * @param destination The destination relation to insert the selection to.
+   * @param selection The selection to be inserted.
+   * @return An immutable InsertSelection node.
+   */
+  static InsertSelectionPtr Create(
+      const LogicalPtr &destination,
+      const LogicalPtr &selection) {
+    return InsertSelectionPtr(new InsertSelection(destination, selection));
+  }
+
+ 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:
+  InsertSelection(const LogicalPtr &destination,
+                  const LogicalPtr &selection)
+      : destination_(destination),
+        selection_(selection) {
+    addChild(destination);
+    addChild(selection);
+  }
+
+  LogicalPtr destination_;
+  LogicalPtr selection_;
+
+  DISALLOW_COPY_AND_ASSIGN(InsertSelection);
+};
+
+/** @} */
+
+}  // namespace logical
+}  // namespace optimizer
+}  // namespace quickstep
+
+#endif /* QUICKSTEP_QUERY_OPTIMIZER_LOGICAL_INSERT_SELECTION_HPP_ */
diff --git a/query_optimizer/logical/LogicalType.hpp b/query_optimizer/logical/LogicalType.hpp
index cf5fd58..1b9366e 100644
--- a/query_optimizer/logical/LogicalType.hpp
+++ b/query_optimizer/logical/LogicalType.hpp
@@ -38,6 +38,7 @@
   kDropTable,
   kFilter,
   kHashJoin,
+  kInsertSelection,
   kInsertTuple,
   kMultiwayCartesianJoin,
   kNestedLoopsJoin,
diff --git a/query_optimizer/physical/CMakeLists.txt b/query_optimizer/physical/CMakeLists.txt
index 0bfa717..d833423 100644
--- a/query_optimizer/physical/CMakeLists.txt
+++ b/query_optimizer/physical/CMakeLists.txt
@@ -22,6 +22,7 @@
 add_library(quickstep_queryoptimizer_physical_DeleteTuples DeleteTuples.cpp DeleteTuples.hpp)
 add_library(quickstep_queryoptimizer_physical_DropTable DropTable.cpp DropTable.hpp)
 add_library(quickstep_queryoptimizer_physical_HashJoin HashJoin.cpp HashJoin.hpp)
+add_library(quickstep_queryoptimizer_physical_InsertSelection InsertSelection.cpp InsertSelection.hpp)
 add_library(quickstep_queryoptimizer_physical_InsertTuple InsertTuple.cpp InsertTuple.hpp)
 add_library(quickstep_queryoptimizer_physical_Join ../../empty_src.cpp Join.hpp)
 add_library(quickstep_queryoptimizer_physical_NestedLoopsJoin NestedLoopsJoin.cpp NestedLoopsJoin.hpp)
@@ -121,6 +122,14 @@
                       quickstep_queryoptimizer_physical_PhysicalType
                       quickstep_utility_Cast
                       quickstep_utility_Macros)
+target_link_libraries(quickstep_queryoptimizer_physical_InsertSelection
+                      glog
+                      quickstep_queryoptimizer_OptimizerTree
+                      quickstep_queryoptimizer_expressions_AttributeReference
+                      quickstep_queryoptimizer_expressions_ExpressionUtil
+                      quickstep_queryoptimizer_physical_Physical
+                      quickstep_queryoptimizer_physical_PhysicalType
+                      quickstep_utility_Macros)
 target_link_libraries(quickstep_queryoptimizer_physical_InsertTuple
                       glog
                       quickstep_queryoptimizer_OptimizerTree
@@ -253,6 +262,7 @@
                       quickstep_queryoptimizer_physical_DeleteTuples
                       quickstep_queryoptimizer_physical_DropTable
                       quickstep_queryoptimizer_physical_HashJoin
+                      quickstep_queryoptimizer_physical_InsertSelection
                       quickstep_queryoptimizer_physical_InsertTuple
                       quickstep_queryoptimizer_physical_Join
                       quickstep_queryoptimizer_physical_NestedLoopsJoin
diff --git a/query_optimizer/physical/InsertSelection.cpp b/query_optimizer/physical/InsertSelection.cpp
new file mode 100644
index 0000000..0e45222
--- /dev/null
+++ b/query_optimizer/physical/InsertSelection.cpp
@@ -0,0 +1,45 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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/physical/InsertSelection.hpp"
+
+#include <string>
+#include <vector>
+
+#include "query_optimizer/OptimizerTree.hpp"
+
+namespace quickstep {
+namespace optimizer {
+namespace physical {
+
+void InsertSelection::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("destination");
+  non_container_child_fields->push_back(destination_);
+
+  non_container_child_field_names->push_back("selection");
+  non_container_child_fields->push_back(selection_);
+}
+
+}  // namespace physical
+}  // namespace optimizer
+}  // namespace quickstep
diff --git a/query_optimizer/physical/InsertSelection.hpp b/query_optimizer/physical/InsertSelection.hpp
new file mode 100644
index 0000000..8bdcfcb
--- /dev/null
+++ b/query_optimizer/physical/InsertSelection.hpp
@@ -0,0 +1,129 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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_PHYSICAL_INSERT_SELECTION_HPP_
+#define QUICKSTEP_QUERY_OPTIMIZER_PHYSICAL_INSERT_SELECTION_HPP_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "query_optimizer/OptimizerTree.hpp"
+#include "query_optimizer/expressions/AttributeReference.hpp"
+#include "query_optimizer/expressions/ExpressionUtil.hpp"
+#include "query_optimizer/physical/Physical.hpp"
+#include "query_optimizer/physical/PhysicalType.hpp"
+#include "utility/Macros.hpp"
+
+#include "glog/logging.h"
+
+namespace quickstep {
+namespace optimizer {
+namespace physical {
+
+/** \addtogroup OptimizerPhysical
+ *  @{
+ */
+
+class InsertSelection;
+typedef std::shared_ptr<const InsertSelection> InsertSelectionPtr;
+
+/**
+ * @brief Inserts the results from a SELECT query into a relation.
+ */
+class InsertSelection : public Physical {
+ public:
+  PhysicalType getPhysicalType() const override {
+    return PhysicalType::kInsertSelection;
+  }
+
+  std::string getName() const override { return "InsertSelection"; }
+
+  /**
+   * @return The destination relation to insert the selection to.
+   */
+  const PhysicalPtr& destination() const { return destination_; }
+
+  /**
+   * @return The selection to be inserted.
+   */
+  const PhysicalPtr& selection() const { return selection_; }
+
+  PhysicalPtr copyWithNewChildren(
+      const std::vector<PhysicalPtr> &new_children) const override {
+    DCHECK_EQ(getNumChildren(), new_children.size());
+    return Create(new_children[0], new_children[1]);
+  }
+
+  std::vector<expressions::AttributeReferencePtr> getOutputAttributes() const override {
+    return {};
+  }
+
+  std::vector<expressions::AttributeReferencePtr> getReferencedAttributes() const override {
+    return selection_->getOutputAttributes();
+  }
+
+  bool maybeCopyWithPrunedExpressions(
+      const expressions::UnorderedNamedExpressionSet &referenced_expressions,
+      PhysicalPtr *output) const override {
+    return false;
+  }
+
+  /**
+   * @brief Creates an InsertSelection physical node.
+   *
+   * @param destination The destination relation to insert the selection to.
+   * @param selection The selection to be inserted.
+   * @return An immutable InsertSelection node.
+   */
+  static InsertSelectionPtr Create(
+      const PhysicalPtr &destination,
+      const PhysicalPtr &selection) {
+    return InsertSelectionPtr(new InsertSelection(destination, selection));
+  }
+
+ 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:
+  InsertSelection(const PhysicalPtr &destination,
+                  const PhysicalPtr &selection)
+      : destination_(destination),
+        selection_(selection) {
+    addChild(destination_);
+    addChild(selection_);
+  }
+
+  PhysicalPtr destination_;
+  PhysicalPtr selection_;
+
+  DISALLOW_COPY_AND_ASSIGN(InsertSelection);
+};
+
+/** @} */
+
+}  // namespace physical
+}  // namespace optimizer
+}  // namespace quickstep
+
+#endif /* QUICKSTEP_QUERY_OPTIMIZER_PHYSICAL_INSERT_SELECTION_HPP_ */
diff --git a/query_optimizer/physical/PhysicalType.hpp b/query_optimizer/physical/PhysicalType.hpp
index 1803f54..b036557 100644
--- a/query_optimizer/physical/PhysicalType.hpp
+++ b/query_optimizer/physical/PhysicalType.hpp
@@ -37,6 +37,7 @@
   kDeleteTuples,
   kDropTable,
   kHashJoin,
+  kInsertSelection,
   kInsertTuple,
   kNestedLoopsJoin,
   kSample,
diff --git a/query_optimizer/resolver/CMakeLists.txt b/query_optimizer/resolver/CMakeLists.txt
index 461fbd6..22cf397 100644
--- a/query_optimizer/resolver/CMakeLists.txt
+++ b/query_optimizer/resolver/CMakeLists.txt
@@ -82,6 +82,7 @@
                       quickstep_queryoptimizer_logical_DeleteTuples
                       quickstep_queryoptimizer_logical_DropTable
                       quickstep_queryoptimizer_logical_Filter
+                      quickstep_queryoptimizer_logical_InsertSelection
                       quickstep_queryoptimizer_logical_InsertTuple
                       quickstep_queryoptimizer_logical_Logical
                       quickstep_queryoptimizer_logical_MultiwayCartesianJoin
@@ -104,9 +105,11 @@
                       quickstep_types_operations_comparisons_Comparison
                       quickstep_types_operations_comparisons_ComparisonFactory
                       quickstep_types_operations_comparisons_ComparisonID
+                      quickstep_types_operations_unaryoperations_DateExtractOperation
                       quickstep_types_operations_unaryoperations_UnaryOperation
                       quickstep_utility_Macros
                       quickstep_utility_PtrList
+                      quickstep_utility_PtrVector
                       quickstep_utility_SqlError
                       quickstep_utility_StringUtil)
 
diff --git a/query_optimizer/resolver/Resolver.cpp b/query_optimizer/resolver/Resolver.cpp
index 3161bbf..7fb5a90 100644
--- a/query_optimizer/resolver/Resolver.cpp
+++ b/query_optimizer/resolver/Resolver.cpp
@@ -80,6 +80,7 @@
 #include "query_optimizer/logical/DeleteTuples.hpp"
 #include "query_optimizer/logical/DropTable.hpp"
 #include "query_optimizer/logical/Filter.hpp"
+#include "query_optimizer/logical/InsertSelection.hpp"
 #include "query_optimizer/logical/InsertTuple.hpp"
 #include "query_optimizer/logical/MultiwayCartesianJoin.hpp"
 #include "query_optimizer/logical/Project.hpp"
@@ -101,8 +102,10 @@
 #include "types/operations/comparisons/Comparison.hpp"
 #include "types/operations/comparisons/ComparisonFactory.hpp"
 #include "types/operations/comparisons/ComparisonID.hpp"
+#include "types/operations/unary_operations/DateExtractOperation.hpp"
 #include "types/operations/unary_operations/UnaryOperation.hpp"
 #include "utility/PtrList.hpp"
+#include "utility/PtrVector.hpp"
 #include "utility/SqlError.hpp"
 #include "utility/StringUtil.hpp"
 
@@ -275,38 +278,48 @@
       logical_plan_ = resolveDropTable(
           static_cast<const ParseStatementDropTable&>(parse_query));
       break;
-    case ParseStatement::kInsert:
+    case ParseStatement::kInsert: {
       context_->set_is_catalog_changed();
-      logical_plan_ =
-          resolveInsert(static_cast<const ParseStatementInsert&>(parse_query));
+      const ParseStatementInsert &insert_statement =
+          static_cast<const ParseStatementInsert&>(parse_query);
+      if (insert_statement.getInsertType() == ParseStatementInsert::InsertType::kTuple) {
+        logical_plan_ =
+            resolveInsertTuple(static_cast<const ParseStatementInsertTuple&>(insert_statement));
+      } else {
+        DCHECK(insert_statement.getInsertType() == ParseStatementInsert::InsertType::kSelection);
+        const ParseStatementInsertSelection &insert_selection_statement =
+            static_cast<const ParseStatementInsertSelection&>(insert_statement);
+
+        if (insert_selection_statement.with_clause() != nullptr) {
+          resolveWithClause(*insert_selection_statement.with_clause());
+        }
+        logical_plan_ = resolveInsertSelection(insert_selection_statement);
+
+        if (insert_selection_statement.with_clause() != nullptr) {
+          // Report an error if there is a WITH query that is not actually used.
+          if (!with_queries_info_.unreferenced_query_indexes.empty()) {
+            int unreferenced_with_query_index = *with_queries_info_.unreferenced_query_indexes.begin();
+            const ParseSubqueryTableReference &unreferenced_with_query =
+                (*insert_selection_statement.with_clause())[unreferenced_with_query_index];
+            THROW_SQL_ERROR_AT(&unreferenced_with_query)
+                << "WITH query "
+                << unreferenced_with_query.table_reference_signature()->table_alias()->value()
+                << " is defined but not used";
+          }
+        }
+      }
       break;
+    }
     case ParseStatement::kSelect: {
       const ParseStatementSelect &select_statement =
           static_cast<const ParseStatementSelect&>(parse_query);
       if (select_statement.with_clause() != nullptr) {
-        int index = 0;
-        for (const ParseSubqueryTableReference &with_table_reference : *select_statement.with_clause()) {
-          NameResolver name_resolver;
-          with_queries_info_.with_query_plans.emplace_back(
-              resolveTableReference(with_table_reference, &name_resolver));
-
-          const ParseString *reference_alias = with_table_reference.table_reference_signature()->table_alias();
-          const std::string lower_alias_name = ToLower(reference_alias->value());
-          if (with_queries_info_.with_query_name_to_vector_position.find(lower_alias_name)
-                  != with_queries_info_.with_query_name_to_vector_position.end()) {
-            THROW_SQL_ERROR_AT(reference_alias)
-                << "WITH query name " << reference_alias->value()
-                << " is specified more than once";
-          }
-
-          with_queries_info_.with_query_name_to_vector_position.emplace(lower_alias_name, index);
-          with_queries_info_.unreferenced_query_indexes.insert(index);
-          ++index;
-        }
+        resolveWithClause(*select_statement.with_clause());
       }
       logical_plan_ =
           resolveSelect(*select_statement.select_query(),
-                        "" /* select_name */);
+                        "" /* select_name */,
+                        nullptr /* No Type hints */);
       if (select_statement.with_clause() != nullptr) {
         // Report an error if there is a WITH query that is not actually used.
         if (!with_queries_info_.unreferenced_query_indexes.empty()) {
@@ -687,8 +700,82 @@
       resolveRelationName(drop_table_statement.relation_name()));
 }
 
-L::LogicalPtr Resolver::resolveInsert(
-    const ParseStatementInsert &insert_statement) {
+L::LogicalPtr Resolver::resolveInsertSelection(
+    const ParseStatementInsertSelection &insert_statement) {
+  NameResolver name_resolver;
+
+  // Resolve the destination relation.
+  const L::LogicalPtr destination_logical = resolveSimpleTableReference(
+      *insert_statement.relation_name(), nullptr /* reference alias */);
+  name_resolver.addRelation(insert_statement.relation_name(),
+                            destination_logical);
+  const std::vector<E::AttributeReferencePtr> destination_attributes =
+      destination_logical->getOutputAttributes();
+
+  // Gather type information of the destination relation columns.
+  std::vector<const Type *> type_hints;
+  for (E::AttributeReferencePtr attr : destination_attributes) {
+    type_hints.emplace_back(&attr->getValueType());
+  }
+
+  // Resolve the selection query.
+  const L::LogicalPtr selection_logical =
+      resolveSelect(*insert_statement.select_query(), "", &type_hints);
+  const std::vector<E::AttributeReferencePtr> selection_attributes =
+      selection_logical->getOutputAttributes();
+
+  // Check that number of columns match between the selection relation and
+  // the destination relation.
+  if (selection_attributes.size() != destination_attributes.size()) {
+    THROW_SQL_ERROR_AT(insert_statement.relation_name())
+        << "The relation " << insert_statement.relation_name()->value()
+        << " has " << std::to_string(destination_attributes.size())
+        << " columns, but " << std::to_string(selection_attributes.size())
+        << " columns are generated by the SELECT query";
+  }
+
+  // Add cast operation if the selection column type does not match the destination
+  // column type
+  std::vector<E::NamedExpressionPtr> cast_expressions;
+  for (std::vector<E::AttributeReferencePtr>::size_type aid = 0;
+       aid < destination_attributes.size();
+       ++aid) {
+    const Type& destination_type = destination_attributes[aid]->getValueType();
+    const Type& selection_type = selection_attributes[aid]->getValueType();
+    if (destination_type.equals(selection_type)) {
+      cast_expressions.emplace_back(selection_attributes[aid]);
+    } else {
+      // TODO(jianqiao): implement Cast operation for non-numeric types.
+      if (destination_type.getSuperTypeID() == Type::kNumeric
+          && selection_type.getSuperTypeID() == Type::kNumeric
+          && destination_type.isSafelyCoercibleFrom(selection_type)) {
+        // Add cast operation
+        const E::AttributeReferencePtr attr = selection_attributes[aid];
+        const E::ExpressionPtr cast_expr =
+            E::Cast::Create(attr, destination_type);
+        cast_expressions.emplace_back(
+            E::Alias::Create(context_->nextExprId(),
+                             cast_expr,
+                             attr->attribute_name(),
+                             attr->attribute_alias()));
+      } else {
+        THROW_SQL_ERROR_AT(insert_statement.relation_name())
+            << "The assigned value for the column "
+            << insert_statement.relation_name()->value() << "."
+            << destination_attributes[aid]->attribute_name() << " has type "
+            << selection_attributes[aid]->getValueType().getName()
+            << ", which cannot be safely coerced to the column's type "
+            << destination_attributes[aid]->getValueType().getName();
+     }
+    }
+  }
+  return L::InsertSelection::Create(
+      destination_logical,
+      L::Project::Create(selection_logical, cast_expressions));
+}
+
+L::LogicalPtr Resolver::resolveInsertTuple(
+    const ParseStatementInsertTuple &insert_statement) {
   NameResolver name_resolver;
 
   const L::LogicalPtr input_logical = resolveSimpleTableReference(
@@ -838,7 +925,8 @@
 
 L::LogicalPtr Resolver::resolveSelect(
     const ParseSelect &select_query,
-    const std::string &select_name) {
+    const std::string &select_name,
+    const std::vector<const Type*> *type_hints) {
   // Create a new name scope. We currently do not support correlated query.
   std::unique_ptr<NameResolver> name_resolver(new NameResolver());
 
@@ -865,6 +953,7 @@
   std::vector<bool> has_aggregate_per_expression;
   resolveSelectClause(select_query.selection(),
                       select_name,
+                      type_hints,
                       *name_resolver,
                       &query_aggregation_info,
                       &select_list_expressions,
@@ -1223,6 +1312,29 @@
   }
 }
 
+void Resolver::resolveWithClause(
+    const PtrVector<ParseSubqueryTableReference> &with_list) {
+  int index = 0;
+  for (const ParseSubqueryTableReference &with_table_reference : with_list) {
+    NameResolver name_resolver;
+    with_queries_info_.with_query_plans.emplace_back(
+        resolveTableReference(with_table_reference, &name_resolver));
+
+    const ParseString *reference_alias = with_table_reference.table_reference_signature()->table_alias();
+    const std::string lower_alias_name = ToLower(reference_alias->value());
+    if (with_queries_info_.with_query_name_to_vector_position.find(lower_alias_name)
+            != with_queries_info_.with_query_name_to_vector_position.end()) {
+      THROW_SQL_ERROR_AT(reference_alias)
+          << "WITH query name " << reference_alias->value()
+          << " is specified more than once";
+    }
+
+    with_queries_info_.with_query_name_to_vector_position.emplace(lower_alias_name, index);
+    with_queries_info_.unreferenced_query_indexes.insert(index);
+    ++index;
+  }
+}
+
 L::LogicalPtr Resolver::resolveFromClause(
     const PtrList<ParseTableReference> &from_list,
     NameResolver *name_resolver) {
@@ -1303,7 +1415,8 @@
       reference_alias = reference_signature->table_alias();
       logical_plan = resolveSelect(
           *static_cast<const ParseSubqueryTableReference&>(table_reference).subquery_expr()->query(),
-          reference_alias->value());
+          reference_alias->value(),
+          nullptr /* No Type hints */);
 
       if (reference_signature->column_aliases() != nullptr) {
         logical_plan = RenameOutputColumns(logical_plan, *reference_signature);
@@ -1440,6 +1553,7 @@
 void Resolver::resolveSelectClause(
     const ParseSelectionClause &parse_selection,
     const std::string &select_name,
+    const std::vector<const Type*> *type_hints,
     const NameResolver &name_resolver,
     QueryAggregationInfo *query_aggregation_info,
     std::vector<expressions::NamedExpressionPtr> *project_expressions,
@@ -1457,6 +1571,13 @@
     case ParseSelectionClause::kNonStar: {
       const ParseSelectionList &selection_list =
           static_cast<const ParseSelectionList&>(parse_selection);
+
+      // Ignore type hints if its size does not match the number of columns.
+      if (type_hints != nullptr && type_hints->size() != selection_list.select_item_list().size()) {
+        type_hints = nullptr;
+      }
+
+      std::vector<const Type*>::size_type tid = 0;
       for (const ParseSelectionItem &selection_item :
            selection_list.select_item_list()) {
         const ParseString *parse_alias = selection_item.alias();
@@ -1468,7 +1589,7 @@
             nullptr /* select_list_info */);
         const E::ScalarPtr project_scalar =
             resolveExpression(*parse_project_expression,
-                              nullptr,  // No Type hint.
+                              (type_hints == nullptr ? nullptr : type_hints->at(tid)),
                               &expr_resolution_info);
 
         // If the resolved expression is a named expression,
@@ -1514,6 +1635,7 @@
         project_expressions->push_back(project_named_expression);
         has_aggregate_per_expression->push_back(
             expr_resolution_info.hasAggregate());
+        ++tid;
       }
       break;
     }
@@ -1756,6 +1878,44 @@
       THROW_SQL_ERROR_AT(&parse_expression)
           << "Subquery expression in a non-FROM clause is not supported yet";
     }
+    case ParseExpression::kExtract: {
+      const ParseExtractFunction &parse_extract =
+          static_cast<const ParseExtractFunction&>(parse_expression);
+
+      const ParseString &extract_field = *parse_extract.extract_field();
+      const std::string lowered_unit = ToLower(extract_field.value());
+      DateExtractUnit extract_unit;
+      if (lowered_unit == "year") {
+        extract_unit = DateExtractUnit::kYear;
+      } else if (lowered_unit == "month") {
+        extract_unit = DateExtractUnit::kMonth;
+      } else if (lowered_unit == "day") {
+        extract_unit = DateExtractUnit::kDay;
+      } else if (lowered_unit == "hour") {
+        extract_unit = DateExtractUnit::kHour;
+      } else if (lowered_unit == "minute") {
+        extract_unit = DateExtractUnit::kMinute;
+      } else if (lowered_unit == "second") {
+        extract_unit = DateExtractUnit::kSecond;
+      } else {
+        THROW_SQL_ERROR_AT(&extract_field)
+            << "Invalid extract unit: " << extract_field.value();
+      }
+
+      const DateExtractOperation &op = DateExtractOperation::Instance(extract_unit);
+      const E::ScalarPtr argument = resolveExpression(
+          *parse_extract.date_expression(),
+          op.pushDownTypeHint(type_hint),
+          expression_resolution_info);
+
+      if (!op.canApplyToType(argument->getValueType())) {
+        THROW_SQL_ERROR_AT(parse_extract.date_expression())
+            << "Can not extract from argument of type: "
+            << argument->getValueType().getName();
+      }
+
+      return E::UnaryExpression::Create(op, argument);
+    }
     default:
       LOG(FATAL) << "Unknown scalar type: "
                  << parse_expression.getExpressionType();
@@ -1853,7 +2013,8 @@
   const E::AggregateFunctionPtr aggregate_function
       = E::AggregateFunction::Create(*aggregate,
                                      resolved_arguments,
-                                     expression_resolution_info->query_aggregation_info->has_group_by);
+                                     expression_resolution_info->query_aggregation_info->has_group_by,
+                                     parse_function_call.is_distinct());
   const std::string internal_alias = GenerateAggregateAttributeAlias(
       expression_resolution_info->query_aggregation_info->aggregate_expressions.size());
   const E::AliasPtr aggregate_alias = E::Alias::Create(context_->nextExprId(),
diff --git a/query_optimizer/resolver/Resolver.hpp b/query_optimizer/resolver/Resolver.hpp
index bcbf94d..3b75114 100644
--- a/query_optimizer/resolver/Resolver.hpp
+++ b/query_optimizer/resolver/Resolver.hpp
@@ -30,6 +30,7 @@
 #include "query_optimizer/expressions/Scalar.hpp"
 #include "query_optimizer/logical/Logical.hpp"
 #include "utility/Macros.hpp"
+#include "utility/PtrVector.hpp"
 
 namespace quickstep {
 
@@ -44,13 +45,15 @@
 class ParseSelect;
 class ParseSelectionClause;
 class ParseSimpleTableReference;
+class ParseSubqueryTableReference;
 class ParseStatement;
 class ParseStatementCopyFrom;
 class ParseStatementCreateTable;
 class ParseStatementCreateIndex;
 class ParseStatementDelete;
 class ParseStatementDropTable;
-class ParseStatementInsert;
+class ParseStatementInsertSelection;
+class ParseStatementInsertTuple;
 class ParseStatementSelect;
 class ParseStatementUpdate;
 class ParseString;
@@ -147,11 +150,14 @@
    *
    * @param select_statement The SELECT parse tree.
    * @param select_name The name for the SELECT query.
+   * @param type_hints Type hints for the expressions in the SELECT clause. Can
+   *                   be NULL if there is no expectation.
    * @return A logical plan for the SELECT query.
    */
   logical::LogicalPtr resolveSelect(
       const ParseSelect &select_statement,
-      const std::string &select_name);
+      const std::string &select_name,
+      const std::vector<const Type*> *type_hints);
 
   /**
    * @brief Resolves a CREATE TABLE query and returns a logical plan.
@@ -201,13 +207,22 @@
       const ParseStatementDropTable &drop_table_statement);
 
   /**
-   * @brief Resolves a INSERT query and returns a logical plan.
+   * @brief Resolves an INSERT VALUES query and returns a logical plan.
    *
    * @param insert_statement The INSERT parse tree.
    * @return A logical plan for the INSERT query.
    */
-  logical::LogicalPtr resolveInsert(
-      const ParseStatementInsert &insert_statement);
+  logical::LogicalPtr resolveInsertTuple(
+      const ParseStatementInsertTuple &insert_statement);
+
+  /**
+   * @brief Resolves an INSERT SELECT query and returns a logical plan.
+   *
+   * @param insert_statement The INSERT parse tree.
+   * @return A logical plan for the INSERT query.
+   */
+  logical::LogicalPtr resolveInsertSelection(
+      const ParseStatementInsertSelection &insert_statement);
 
   /**
    * @brief Resolves a COPY FROM query and returns a logical plan.
@@ -228,6 +243,15 @@
       const ParseStatementUpdate &update_statement);
 
   /**
+   * @brief Resolves WITH clause and stores the resolved information into
+   * the member object with_query_info_ of this class.
+   *
+   * @param with_list The list of subqueries in WITH clause.
+   */
+  void resolveWithClause(
+      const PtrVector<ParseSubqueryTableReference> &with_list);
+
+  /**
    * @brief Resolves SELECT-list expressions and returns the resolved
    *        expressions in \p project_expressions.
    * @warning \p project_expressions will be cleared first.
@@ -235,6 +259,8 @@
    * @param parse_selection The SELECT parse tree.
    * @param select_name The name of the SELECT query. It is used to populate the
    *                    relation name in the expressions.
+   * @param type_hints Type hints for the expressions in the SELECT clause. Can
+   *                   be NULL if there is no expectation.
    * @param name_resolver NameResolver to resolve the relation/attribute names.
    * @param query_aggregation_info Passed down to each expression to collects
    *                               aggregate expressions.
@@ -246,6 +272,7 @@
   void resolveSelectClause(
       const ParseSelectionClause &parse_selection,
       const std::string &select_name,
+      const std::vector<const Type*> *type_hints,
       const NameResolver &name_resolver,
       QueryAggregationInfo *query_aggregation_info,
       std::vector<expressions::NamedExpressionPtr> *project_expressions,
diff --git a/query_optimizer/strategy/CMakeLists.txt b/query_optimizer/strategy/CMakeLists.txt
index 3def33d..e4052cf 100644
--- a/query_optimizer/strategy/CMakeLists.txt
+++ b/query_optimizer/strategy/CMakeLists.txt
@@ -78,6 +78,7 @@
                       quickstep_queryoptimizer_logical_CreateTable
                       quickstep_queryoptimizer_logical_DeleteTuples
                       quickstep_queryoptimizer_logical_DropTable
+                      quickstep_queryoptimizer_logical_InsertSelection
                       quickstep_queryoptimizer_logical_InsertTuple
                       quickstep_queryoptimizer_logical_Logical
                       quickstep_queryoptimizer_logical_Logical
@@ -94,6 +95,7 @@
                       quickstep_queryoptimizer_physical_CreateTable
                       quickstep_queryoptimizer_physical_DeleteTuples
                       quickstep_queryoptimizer_physical_DropTable
+                      quickstep_queryoptimizer_physical_InsertSelection
                       quickstep_queryoptimizer_physical_InsertTuple
                       quickstep_queryoptimizer_physical_Physical
                       quickstep_queryoptimizer_physical_Sample
diff --git a/query_optimizer/strategy/OneToOne.cpp b/query_optimizer/strategy/OneToOne.cpp
index aff0d90..d4d79f9 100644
--- a/query_optimizer/strategy/OneToOne.cpp
+++ b/query_optimizer/strategy/OneToOne.cpp
@@ -31,6 +31,7 @@
 #include "query_optimizer/logical/CreateTable.hpp"
 #include "query_optimizer/logical/DeleteTuples.hpp"
 #include "query_optimizer/logical/DropTable.hpp"
+#include "query_optimizer/logical/InsertSelection.hpp"
 #include "query_optimizer/logical/InsertTuple.hpp"
 #include "query_optimizer/logical/LogicalType.hpp"
 #include "query_optimizer/logical/Sample.hpp"
@@ -45,6 +46,7 @@
 #include "query_optimizer/physical/CreateTable.hpp"
 #include "query_optimizer/physical/DeleteTuples.hpp"
 #include "query_optimizer/physical/DropTable.hpp"
+#include "query_optimizer/physical/InsertSelection.hpp"
 #include "query_optimizer/physical/InsertTuple.hpp"
 #include "query_optimizer/physical/Sample.hpp"
 #include "query_optimizer/physical/SharedSubplanReference.hpp"
@@ -133,6 +135,14 @@
       *physical_output = P::DropTable::Create(drop_table->catalog_relation());
       return true;
     }
+    case L::LogicalType::kInsertSelection: {
+      const L::InsertSelectionPtr insert_selection =
+          std::static_pointer_cast<const L::InsertSelection>(logical_input);
+      *physical_output = P::InsertSelection::Create(
+          physical_mapper_->createOrGetPhysicalFromLogical(insert_selection->destination()),
+          physical_mapper_->createOrGetPhysicalFromLogical(insert_selection->selection()));
+      return true;
+    }
     case L::LogicalType::kInsertTuple: {
       const L::InsertTuplePtr insert_tuple =
           std::static_pointer_cast<const L::InsertTuple>(logical_input);
diff --git a/query_optimizer/strategy/tests/Aggregate_unittest.cpp b/query_optimizer/strategy/tests/Aggregate_unittest.cpp
index 193435b..1f4eb95 100644
--- a/query_optimizer/strategy/tests/Aggregate_unittest.cpp
+++ b/query_optimizer/strategy/tests/Aggregate_unittest.cpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -64,13 +66,15 @@
   }
 
   E::AggregateFunctionPtr createSum(const E::ScalarPtr &argument,
-                                    const bool is_vector_aggregate) {
+                                    const bool is_vector_aggregate,
+                                    const bool is_distinct) {
     std::vector<E::ScalarPtr> args(1, argument);
 
     return E::AggregateFunction::Create(
         AggregateFunctionFactory::Get(AggregationID::kSum),
         args,
-        is_vector_aggregate);
+        is_vector_aggregate,
+        is_distinct);
   }
 
  private:
@@ -78,54 +82,63 @@
 };
 
 TEST_F(AggregateTest, BasicTest) {
-  const E::AggregateFunctionPtr sum = createSum(add_literal_0_, true);
-  const E::AliasPtr sum_alias = createAlias(sum,
-                                            "sum" /* attribute_name */,
-                                            "test_relation" /* relation_name */);
-  input_logical_ = L::Aggregate::Create(
-      logical_table_reference_0_,
-      {alias_0_} /* grouping_expressions */,
-      {sum_alias} /* aggregate_expressions */);
-  expected_physical_ = P::Aggregate::Create(
-      physical_table_reference_0_,
-      {alias_0_} /* grouping_expressions */,
-      {sum_alias} /* aggregate_expressions */,
-      nullptr /* filter_predicate */);
-  EXPECT_CORRECT_PHYSICAL();
+  for (const bool is_distinct : {true, false}) {
+    const E::AggregateFunctionPtr sum = createSum(add_literal_0_,
+                                                  true /* is_vector_attribute */,
+                                                  is_distinct);
+    const E::AliasPtr sum_alias = createAlias(sum,
+                                              "sum" /* attribute_name */,
+                                              "test_relation" /* relation_name */);
+    input_logical_ = L::Aggregate::Create(
+        logical_table_reference_0_,
+        {alias_0_} /* grouping_expressions */,
+        {sum_alias} /* aggregate_expressions */);
+    expected_physical_ = P::Aggregate::Create(
+        physical_table_reference_0_,
+        {alias_0_} /* grouping_expressions */,
+        {sum_alias} /* aggregate_expressions */,
+        nullptr /* filter_predicate */);
+    EXPECT_CORRECT_PHYSICAL();
+  }
 }
 
 TEST_F(AggregateTest, PullupSelection) {
-  const E::AggregateFunctionPtr sum = createSum(E::ToRef(alias_add_literal_0_), true);
-  const E::AliasPtr sum_alias = createAlias(sum,
-                                            "sum" /* attribute_name */,
-                                            "test_relation" /* relation_name */);
-  const E::AliasPtr alias_on_alias_reference = E::Alias::Create(
-      optimizer_context()->nextExprId(),
-      E::ToRef(alias_add_literal_0_),
-      "alias_on_alias_reference" /* attribute_name */,
-      "alias_on_alias_reference" /* attribute_alias */,
-      "test_relation" /* relation_name */);
+  for (const bool is_distinct : {true, false}) {
+    const E::AggregateFunctionPtr sum = createSum(E::ToRef(alias_add_literal_0_),
+                                                  true /* is_vector_attribute */,
+                                                  is_distinct);
+    const E::AliasPtr sum_alias = createAlias(sum,
+                                              "sum" /* attribute_name */,
+                                              "test_relation" /* relation_name */);
+    const E::AliasPtr alias_on_alias_reference = E::Alias::Create(
+        optimizer_context()->nextExprId(),
+        E::ToRef(alias_add_literal_0_),
+        "alias_on_alias_reference" /* attribute_name */,
+        "alias_on_alias_reference" /* attribute_alias */,
+        "test_relation" /* relation_name */);
 
-  input_logical_ = L::Aggregate::Create(
-      logical_project_on_filter_0_,
-      {E::ToRef(alias_0_), alias_on_alias_reference} /* grouping_expressions */,
-      {sum_alias} /* aggregate_expressions */);
+    input_logical_ = L::Aggregate::Create(
+        logical_project_on_filter_0_,
+        {E::ToRef(alias_0_), alias_on_alias_reference} /* grouping_expressions */,
+        {sum_alias} /* aggregate_expressions */);
 
-  const E::AggregateFunctionPtr sum_after_pullup = std::static_pointer_cast<const E::AggregateFunction>(
-      sum->copyWithNewChildren({alias_add_literal_0_->expression()}));
-  const E::AliasPtr sum_alias_after_pullup =
-      std::static_pointer_cast<const E::Alias>(sum_alias->copyWithNewChildren({sum_after_pullup}));
-  const E::AliasPtr alias_on_alias_reference_after_pullup =
-      std::static_pointer_cast<const E::Alias>(alias_on_alias_reference->copyWithNewChildren(
-          {alias_add_literal_0_->expression()} /* new_children */));
-  expected_physical_ = P::Aggregate::Create(
-      physical_table_reference_0_,
-      {alias_0_,
-       alias_on_alias_reference_after_pullup} /* grouping_expressions */,
-      {sum_alias_after_pullup} /* aggregate_expressions */,
-      logical_filter_0_->filter_predicate());
+    const E::AggregateFunctionPtr sum_after_pullup =
+        std::static_pointer_cast<const E::AggregateFunction>(
+            sum->copyWithNewChildren({alias_add_literal_0_->expression()}));
+    const E::AliasPtr sum_alias_after_pullup =
+        std::static_pointer_cast<const E::Alias>(sum_alias->copyWithNewChildren({sum_after_pullup}));
+    const E::AliasPtr alias_on_alias_reference_after_pullup =
+        std::static_pointer_cast<const E::Alias>(alias_on_alias_reference->copyWithNewChildren(
+            {alias_add_literal_0_->expression()} /* new_children */));
+    expected_physical_ = P::Aggregate::Create(
+        physical_table_reference_0_,
+        {alias_0_,
+         alias_on_alias_reference_after_pullup} /* grouping_expressions */,
+        {sum_alias_after_pullup} /* aggregate_expressions */,
+        logical_filter_0_->filter_predicate());
 
-  EXPECT_CORRECT_PHYSICAL();
+    EXPECT_CORRECT_PHYSICAL();
+  }
 }
 
 }  // namespace strategy
diff --git a/query_optimizer/tests/execution_generator/CMakeLists.txt b/query_optimizer/tests/execution_generator/CMakeLists.txt
index 3191a28..d70ea4c 100644
--- a/query_optimizer/tests/execution_generator/CMakeLists.txt
+++ b/query_optimizer/tests/execution_generator/CMakeLists.txt
@@ -23,16 +23,21 @@
          "${CMAKE_CURRENT_SOURCE_DIR}/Delete.test"
          "${CMAKE_CURRENT_BINARY_DIR}/Delete.test"
          "${CMAKE_CURRENT_BINARY_DIR}/Delete/")
+add_test(quickstep_queryoptimizer_tests_executiongenerator_distinct
+         "../quickstep_queryoptimizer_tests_ExecutionGeneratorTest"
+         "${CMAKE_CURRENT_SOURCE_DIR}/Distinct.test"
+         "${CMAKE_CURRENT_BINARY_DIR}/Distinct.test"
+         "${CMAKE_CURRENT_BINARY_DIR}/Distinct/")
 add_test(quickstep_queryoptimizer_tests_executiongenerator_drop
          "../quickstep_queryoptimizer_tests_ExecutionGeneratorTest"
          "${CMAKE_CURRENT_SOURCE_DIR}/Drop.test"
          "${CMAKE_CURRENT_BINARY_DIR}/Drop.test"
          "${CMAKE_CURRENT_BINARY_DIR}/Drop/")
- add_test(quickstep_queryoptimizer_tests_executiongenerator_index
-          "../quickstep_queryoptimizer_tests_ExecutionGeneratorTest"
-          "${CMAKE_CURRENT_SOURCE_DIR}/Index.test"
-          "${CMAKE_CURRENT_BINARY_DIR}/Index.test"
-          "${CMAKE_CURRENT_BINARY_DIR}/Index/")
+add_test(quickstep_queryoptimizer_tests_executiongenerator_index
+         "../quickstep_queryoptimizer_tests_ExecutionGeneratorTest"
+         "${CMAKE_CURRENT_SOURCE_DIR}/Index.test"
+         "${CMAKE_CURRENT_BINARY_DIR}/Index.test"
+         "${CMAKE_CURRENT_BINARY_DIR}/Index/")
 add_test(quickstep_queryoptimizer_tests_executiongenerator_insert
          "../quickstep_queryoptimizer_tests_ExecutionGeneratorTest"
          "${CMAKE_CURRENT_SOURCE_DIR}/Insert.test"
@@ -63,6 +68,7 @@
 # duration of their test.
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Create)
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Delete)
+file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Distinct)
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Drop)
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Index)
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/Insert)
diff --git a/query_optimizer/tests/execution_generator/Distinct.test b/query_optimizer/tests/execution_generator/Distinct.test
new file mode 100644
index 0000000..feab898
--- /dev/null
+++ b/query_optimizer/tests/execution_generator/Distinct.test
@@ -0,0 +1,70 @@
+#   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+#     University of Wisconsin—Madison.
+#
+#   Licensed 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.
+
+CREATE TABLE foo(x INT, y DOUBLE, z INT);
+
+INSERT INTO foo
+SELECT i,
+       (i + 0.5) % 100,
+       i % 3
+FROM generate_series(0, 29999) AS gs(i);
+
+
+SELECT COUNT(*),
+       COUNT(DISTINCT x),
+       COUNT(DISTINCT y),
+       COUNT(DISTINCT z)
+FROM foo;
+--
++--------------------+--------------------+--------------------+--------------------+
+|COUNT(*)            |COUNT(DISTINCT x)   |COUNT(DISTINCT y)   |COUNT(DISTINCT z)   |
++--------------------+--------------------+--------------------+--------------------+
+|               30000|               30000|                 100|                   3|
++--------------------+--------------------+--------------------+--------------------+
+==
+
+SELECT SUM(y),
+       SUM(DISTINCT y),
+       COUNT(DISTINCT y),
+       AVG(DISTINCT y),
+       z
+FROM foo
+GROUP BY z
+ORDER BY z;
+--
++------------------------+------------------------+--------------------+------------------------+-----------+
+|SUM(y)                  |SUM(DISTINCT y)         |COUNT(DISTINCT y)   |AVG(DISTINCT y)         |z          |
++------------------------+------------------------+--------------------+------------------------+-----------+
+|                  500000|                    5000|                 100|                      50|          0|
+|                  500000|                    5000|                 100|                      50|          1|
+|                  500000|                    5000|                 100|                      50|          2|
++------------------------+------------------------+--------------------+------------------------+-----------+
+==
+
+SELECT MAX(x) * SUM(DISTINCT y),
+       COUNT(DISTINCT x % y) + z,
+       z
+FROM foo
+GROUP BY z
+ORDER BY z;
+--
++------------------------+-------------------------+-----------+
+|(MAX(x)*SUM(DISTINCT y))|(COUNT(DISTINCT (x%y))+z)|z          |
++------------------------+-------------------------+-----------+
+|               149985000|                      196|          0|
+|               149990000|                      197|          1|
+|               149995000|                      195|          2|
++------------------------+-------------------------+-----------+
+==
diff --git a/query_optimizer/tests/execution_generator/Insert.test b/query_optimizer/tests/execution_generator/Insert.test
index 09fe9bf..fd4cfde 100644
--- a/query_optimizer/tests/execution_generator/Insert.test
+++ b/query_optimizer/tests/execution_generator/Insert.test
@@ -13,9 +13,9 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
-INSERT INTO TEST VALUES (100, 2, 1.1, 1.3, 'foo');
-INSERT INTO TEST VALUES (100, 3, 1.2, 1.4, 'foofoo');
-INSERT INTO TEST VALUES (NULL, 3, 1.2, NULL, 'foofoo');
+INSERT INTO test VALUES (100, 2, 1.1, 1.3, 'foo');
+INSERT INTO test VALUES (100, 3, 1.2, 1.4, 'foofoo');
+INSERT INTO test VALUES (NULL, 3, 1.2, NULL, 'foofoo');
 SELECT * FROM test WHERE int_col = 100;
 --
 +-----------+--------------------+---------------+------------------------+--------------------+
@@ -24,3 +24,90 @@
 |        100|                   2|     1.10000002|                     1.3|                 foo|
 |        100|                   3|     1.20000005|      1.3999999999999999|              foofoo|
 +-----------+--------------------+---------------+------------------------+--------------------+
+==
+
+CREATE TABLE bar1 (x INT NULL, y DOUBLE);
+
+INSERT INTO bar1
+SELECT int_col, long_col
+FROM test;
+
+SELECT *
+FROM bar1
+WHERE x = 100;
+--
++-----------+------------------------+
+|x          |y                       |
++-----------+------------------------+
+|        100|                       2|
+|        100|                       3|
++-----------+------------------------+
+==
+
+INSERT INTO bar1
+SELECT int_col, long_col
+FROM test;
+
+SELECT *
+FROM bar1
+WHERE x = 100;
+--
++-----------+------------------------+
+|x          |y                       |
++-----------+------------------------+
+|        100|                       2|
+|        100|                       3|
+|        100|                       2|
+|        100|                       3|
++-----------+------------------------+
+==
+
+CREATE TABLE bar2 (x INT, y INT, z FLOAT);
+
+WITH s(i) AS
+  ( SELECT *
+   FROM generate_series(1, 5)),
+     t(j) AS
+  ( SELECT *
+   FROM generate_series(1, 5))
+INSERT INTO bar2
+SELECT i, j, i*j
+FROM s, t
+WHERE i < j;
+
+SELECT * FROM bar2;
+--
++-----------+-----------+---------------+
+|x          |y          |z              |
++-----------+-----------+---------------+
+|          1|          2|              2|
+|          1|          3|              3|
+|          1|          4|              4|
+|          1|          5|              5|
+|          2|          3|              6|
+|          2|          4|              8|
+|          2|          5|             10|
+|          3|          4|             12|
+|          3|          5|             15|
+|          4|          5|             20|
++-----------+-----------+---------------+
+==
+
+CREATE TABLE bar3 (x INT, y DATE, z DOUBLE NULL, w VARCHAR(32));
+
+INSERT INTO bar3
+SELECT i, DATE '2016-1-1', NULL, 'abc'
+FROM generate_series(1, 5) AS gs(i);
+
+SELECT * FROM bar3;
+--
++-----------+-----------------------------------------+------------------------+--------------------------------+
+|x          |y                                        |z                       |w                               |
++-----------+-----------------------------------------+------------------------+--------------------------------+
+|          1|                      2016-01-01T00:00:00|                    NULL|                             abc|
+|          2|                      2016-01-01T00:00:00|                    NULL|                             abc|
+|          3|                      2016-01-01T00:00:00|                    NULL|                             abc|
+|          4|                      2016-01-01T00:00:00|                    NULL|                             abc|
+|          5|                      2016-01-01T00:00:00|                    NULL|                             abc|
++-----------+-----------------------------------------+------------------------+--------------------------------+
+==
diff --git a/query_optimizer/tests/execution_generator/Select.test b/query_optimizer/tests/execution_generator/Select.test
index a9067da..82f7816 100644
--- a/query_optimizer/tests/execution_generator/Select.test
+++ b/query_optimizer/tests/execution_generator/Select.test
@@ -632,6 +632,48 @@
 +--------------------+--------------------+--------------------+
 ==
 
+
+CREATE TABLE dates (value DATETIME);
+INSERT INTO dates VALUES (DATE '2016-01-02 10:20:30');
+INSERT INTO dates VALUES (DATE '2016-02-03 11:21:31');
+INSERT INTO dates VALUES (DATE '2016-03-04 12:22:32');
+
+SELECT EXTRACT(YEAR FROM value) * 10000 +
+       EXTRACT(MONTH FROM value) * 100 +
+       EXTRACT(DAY FROM value) AS date_digits
+FROM dates;
+--
++--------------------+
+|date_digits         |
++--------------------+
+|            20160102|
+|            20160203|
+|            20160304|
++--------------------+
+==
+
+SELECT SUM(EXTRACT(SECOND FROM value))
+FROM dates;
+--
++-------------------------------+
+|SUM(EXTRACT(SECOND FROM value))|
++-------------------------------+
+|                             93|
++-------------------------------+
+==
+
+SELECT EXTRACT(hour FROM value + INTERVAL '1 hour')
+FROM dates;
+--
++-----------------------------------------------------+
+|EXTRACT(hour FROM (value+DatetimeInterval('1 hour')))|
++-----------------------------------------------------+
+|                                                   11|
+|                                                   12|
+|                                                   13|
++-----------------------------------------------------+
+==
+
 # TODO(team): Support uncorrelated queries.
 # SELECT COUNT(*)
 # FROM test
diff --git a/query_optimizer/tests/execution_generator/StringPatternMatching.test b/query_optimizer/tests/execution_generator/StringPatternMatching.test
index de69aa6..122deeb 100644
--- a/query_optimizer/tests/execution_generator/StringPatternMatching.test
+++ b/query_optimizer/tests/execution_generator/StringPatternMatching.test
@@ -144,7 +144,8 @@
 SELECT name, email, organization
 FROM foo, bar
 WHERE email LIKE pattern
-  AND name NOT LIKE 'd%';
+  AND name NOT LIKE 'd%'
+ORDER BY name ASC;
 --
 +------------------------+------------------------+------------------------+
 |name                    |email                   |organization            |
diff --git a/query_optimizer/tests/logical_generator/Select.test b/query_optimizer/tests/logical_generator/Select.test
index 2129de1..2709ce3 100644
--- a/query_optimizer/tests/logical_generator/Select.test
+++ b/query_optimizer/tests/logical_generator/Select.test
@@ -596,3 +596,60 @@
 +-output_attributes=
   +-AttributeReference[id=7,name=,alias=(int_col+2),relation=subquery,
     type=Int NULL]
+==
+
+SELECT COUNT(DISTINCT int_col), SUM(float_col)
+FROM test
+GROUP BY long_col
+HAVING AVG(DISTINCT int_col + double_col) > AVG(DISTINCT float_col);
+--
+TopLevelPlan
++-plan=Project
+| +-input=Filter
+| | +-input=Aggregate
+| | | +-input=TableReference[relation_name=Test,relation_alias=test]
+| | | | +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | | | +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | | | +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | | | +-AttributeReference[id=3,name=double_col,relation=test,type=Double NULL]
+| | | | +-AttributeReference[id=4,name=char_col,relation=test,type=Char(20)]
+| | | | +-AttributeReference[id=5,name=vchar_col,relation=test,
+| | | |   type=VarChar(20) NULL]
+| | | +-grouping_expressions=
+| | | | +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | | +-aggregate_expressions=
+| | |   +-Alias[id=6,name=,alias=$aggregate0,relation=$aggregate,type=Long]
+| | |   | +-AggregateFunction[function=COUNT,is_distinct=true]
+| | |   |   +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | |   +-Alias[id=7,name=,alias=$aggregate1,relation=$aggregate,
+| | |   | type=Double NULL]
+| | |   | +-AggregateFunction[function=SUM]
+| | |   |   +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | |   +-Alias[id=8,name=,alias=$aggregate2,relation=$aggregate,
+| | |   | type=Double NULL]
+| | |   | +-AggregateFunction[function=AVG,is_distinct=true]
+| | |   |   +-Add
+| | |   |     +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | |   |     +-AttributeReference[id=3,name=double_col,relation=test,
+| | |   |       type=Double NULL]
+| | |   +-Alias[id=9,name=,alias=$aggregate3,relation=$aggregate,
+| | |     type=Double NULL]
+| | |     +-AggregateFunction[function=AVG,is_distinct=true]
+| | |       +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | +-filter_predicate=Greater
+| |   +-AttributeReference[id=8,name=,alias=$aggregate2,relation=$aggregate,
+| |   | type=Double NULL]
+| |   +-AttributeReference[id=9,name=,alias=$aggregate3,relation=$aggregate,
+| |     type=Double NULL]
+| +-project_list=
+|   +-Alias[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,type=Long]
+|   | +-AttributeReference[id=6,name=,alias=$aggregate0,relation=$aggregate,
+|   |   type=Long]
+|   +-Alias[id=7,name=,alias=SUM(float_col),relation=,type=Double NULL]
+|     +-AttributeReference[id=7,name=,alias=$aggregate1,relation=$aggregate,
+|       type=Double NULL]
++-output_attributes=
+  +-AttributeReference[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,
+  | type=Long]
+  +-AttributeReference[id=7,name=,alias=SUM(float_col),relation=,
+    type=Double NULL]
diff --git a/query_optimizer/tests/physical_generator/Select.test b/query_optimizer/tests/physical_generator/Select.test
index 69911ec..d653a9b 100644
--- a/query_optimizer/tests/physical_generator/Select.test
+++ b/query_optimizer/tests/physical_generator/Select.test
@@ -1586,3 +1586,108 @@
 |     +-AttributeReference[id=3,name=double_col,relation=test,type=Double NULL]
 +-output_attributes=
   +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+==
+
+SELECT COUNT(DISTINCT int_col), SUM(float_col)
+FROM test
+GROUP BY long_col
+HAVING AVG(DISTINCT int_col + double_col) > AVG(DISTINCT float_col);
+--
+[Optimized Logical Plan]
+TopLevelPlan
++-plan=Project
+| +-input=Filter
+| | +-input=Aggregate
+| | | +-input=TableReference[relation_name=Test,relation_alias=test]
+| | | | +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | | | +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | | | +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | | | +-AttributeReference[id=3,name=double_col,relation=test,type=Double NULL]
+| | | | +-AttributeReference[id=4,name=char_col,relation=test,type=Char(20)]
+| | | | +-AttributeReference[id=5,name=vchar_col,relation=test,
+| | | |   type=VarChar(20) NULL]
+| | | +-grouping_expressions=
+| | | | +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | | +-aggregate_expressions=
+| | |   +-Alias[id=6,name=,alias=$aggregate0,relation=$aggregate,type=Long]
+| | |   | +-AggregateFunction[function=COUNT,is_distinct=true]
+| | |   |   +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | |   +-Alias[id=7,name=,alias=$aggregate1,relation=$aggregate,
+| | |   | type=Double NULL]
+| | |   | +-AggregateFunction[function=SUM]
+| | |   |   +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | |   +-Alias[id=8,name=,alias=$aggregate2,relation=$aggregate,
+| | |   | type=Double NULL]
+| | |   | +-AggregateFunction[function=AVG,is_distinct=true]
+| | |   |   +-Add
+| | |   |     +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | |   |     +-AttributeReference[id=3,name=double_col,relation=test,
+| | |   |       type=Double NULL]
+| | |   +-Alias[id=9,name=,alias=$aggregate3,relation=$aggregate,
+| | |     type=Double NULL]
+| | |     +-AggregateFunction[function=AVG,is_distinct=true]
+| | |       +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | +-filter_predicate=Greater
+| |   +-AttributeReference[id=8,name=,alias=$aggregate2,relation=$aggregate,
+| |   | type=Double NULL]
+| |   +-AttributeReference[id=9,name=,alias=$aggregate3,relation=$aggregate,
+| |     type=Double NULL]
+| +-project_list=
+|   +-Alias[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,type=Long]
+|   | +-AttributeReference[id=6,name=,alias=$aggregate0,relation=$aggregate,
+|   |   type=Long]
+|   +-Alias[id=7,name=,alias=SUM(float_col),relation=,type=Double NULL]
+|     +-AttributeReference[id=7,name=,alias=$aggregate1,relation=$aggregate,
+|       type=Double NULL]
++-output_attributes=
+  +-AttributeReference[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,
+  | type=Long]
+  +-AttributeReference[id=7,name=,alias=SUM(float_col),relation=,
+    type=Double NULL]
+[Physical Plan]
+TopLevelPlan
++-plan=Selection
+| +-input=Aggregate
+| | +-input=TableReference[relation=Test,alias=test]
+| | | +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | | +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | | +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | | +-AttributeReference[id=3,name=double_col,relation=test,type=Double NULL]
+| | | +-AttributeReference[id=4,name=char_col,relation=test,type=Char(20)]
+| | | +-AttributeReference[id=5,name=vchar_col,relation=test,
+| | |   type=VarChar(20) NULL]
+| | +-grouping_expressions=
+| | | +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | +-aggregate_expressions=
+| |   +-Alias[id=6,name=,alias=$aggregate0,relation=$aggregate,type=Long]
+| |   | +-AggregateFunction[function=COUNT,is_distinct=true]
+| |   |   +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| |   +-Alias[id=7,name=,alias=$aggregate1,relation=$aggregate,type=Double NULL]
+| |   | +-AggregateFunction[function=SUM]
+| |   |   +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| |   +-Alias[id=8,name=,alias=$aggregate2,relation=$aggregate,type=Double NULL]
+| |   | +-AggregateFunction[function=AVG,is_distinct=true]
+| |   |   +-Add
+| |   |     +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| |   |     +-AttributeReference[id=3,name=double_col,relation=test,
+| |   |       type=Double NULL]
+| |   +-Alias[id=9,name=,alias=$aggregate3,relation=$aggregate,type=Double NULL]
+| |     +-AggregateFunction[function=AVG,is_distinct=true]
+| |       +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| +-filter_predicate=Greater
+| | +-AttributeReference[id=8,name=,alias=$aggregate2,relation=$aggregate,
+| | | type=Double NULL]
+| | +-AttributeReference[id=9,name=,alias=$aggregate3,relation=$aggregate,
+| |   type=Double NULL]
+| +-project_expressions=
+|   +-Alias[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,type=Long]
+|   | +-AttributeReference[id=6,name=,alias=$aggregate0,relation=$aggregate,
+|   |   type=Long]
+|   +-Alias[id=7,name=,alias=SUM(float_col),relation=,type=Double NULL]
+|     +-AttributeReference[id=7,name=,alias=$aggregate1,relation=$aggregate,
+|       type=Double NULL]
++-output_attributes=
+  +-AttributeReference[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,
+  | type=Long]
+  +-AttributeReference[id=7,name=,alias=SUM(float_col),relation=,
+    type=Double NULL]
diff --git a/query_optimizer/tests/resolver/Aggregate.test b/query_optimizer/tests/resolver/Aggregate.test
index 39ca8e0..318378b 100644
--- a/query_optimizer/tests/resolver/Aggregate.test
+++ b/query_optimizer/tests/resolver/Aggregate.test
@@ -877,3 +877,63 @@
 |   +-AttributeReference[id=6,name=alias_col,relation=,type=Int NULL]
 +-output_attributes=
   +-AttributeReference[id=6,name=alias_col,relation=,type=Int NULL]
+==
+
+# DISTINCT aggregation
+SELECT COUNT(DISTINCT int_col),
+       SUM(DISTINCT long_col * float_col)
+FROM test
+GROUP BY char_col
+HAVING AVG(double_col) > MIN(DISTINCT int_col);
+--
+TopLevelPlan
++-plan=Project
+| +-input=Filter
+| | +-input=Aggregate
+| | | +-input=TableReference[relation_name=Test,relation_alias=test]
+| | | | +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | | | +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | | | +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | | | +-AttributeReference[id=3,name=double_col,relation=test,type=Double NULL]
+| | | | +-AttributeReference[id=4,name=char_col,relation=test,type=Char(20)]
+| | | | +-AttributeReference[id=5,name=vchar_col,relation=test,
+| | | |   type=VarChar(20) NULL]
+| | | +-grouping_expressions=
+| | | | +-AttributeReference[id=4,name=char_col,relation=test,type=Char(20)]
+| | | +-aggregate_expressions=
+| | |   +-Alias[id=6,name=,alias=$aggregate0,relation=$aggregate,type=Long]
+| | |   | +-AggregateFunction[function=COUNT,is_distinct=true]
+| | |   |   +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | |   +-Alias[id=7,name=,alias=$aggregate1,relation=$aggregate,
+| | |   | type=Double NULL]
+| | |   | +-AggregateFunction[function=SUM,is_distinct=true]
+| | |   |   +-Multiply
+| | |   |     +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | |   |     +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | |   +-Alias[id=8,name=,alias=$aggregate2,relation=$aggregate,
+| | |   | type=Double NULL]
+| | |   | +-AggregateFunction[function=AVG]
+| | |   |   +-AttributeReference[id=3,name=double_col,relation=test,
+| | |   |     type=Double NULL]
+| | |   +-Alias[id=9,name=,alias=$aggregate3,relation=$aggregate,type=Int NULL]
+| | |     +-AggregateFunction[function=MIN,is_distinct=true]
+| | |       +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | +-filter_predicate=Greater
+| |   +-AttributeReference[id=8,name=,alias=$aggregate2,relation=$aggregate,
+| |   | type=Double NULL]
+| |   +-AttributeReference[id=9,name=,alias=$aggregate3,relation=$aggregate,
+| |     type=Int NULL]
+| +-project_list=
+|   +-Alias[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,type=Long]
+|   | +-AttributeReference[id=6,name=,alias=$aggregate0,relation=$aggregate,
+|   |   type=Long]
+|   +-Alias[id=7,name=,alias=SUM(DISTINCT (long_col*float_col)),relation=,
+|     type=Double NULL]
+|     +-AttributeReference[id=7,name=,alias=$aggregate1,relation=$aggregate,
+|       type=Double NULL]
++-output_attributes=
+  +-AttributeReference[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,
+  | type=Long]
+  +-AttributeReference[id=7,name=,alias=SUM(DISTINCT (long_col*float_col)),
+    relation=,type=Double NULL]
+==
\ No newline at end of file
diff --git a/query_optimizer/tests/resolver/Select.test b/query_optimizer/tests/resolver/Select.test
index cbfe7c9..1290d5e 100644
--- a/query_optimizer/tests/resolver/Select.test
+++ b/query_optimizer/tests/resolver/Select.test
@@ -2242,6 +2242,91 @@
     relation=,type=YearMonthInterval]
 ==
 
+SELECT EXTRACT(YEAR FROM DATE '2016-01-02 10:20:30') * 10000 +
+       EXTRACT(MONTH FROM DATE '2016-01-02 10:20:30') * 100 +
+       EXTRACT(DAY FROM DATE '2016-01-02 10:20:30') AS date_digits
+FROM generate_series(1, 1);
+--
+TopLevelPlan
++-plan=Project
+| +-input=TableGenerator[function_name=generate_series]
+| | +-AttributeReference[id=0,name=generate_series,relation=generate_series,
+| |   type=Int]
+| +-project_list=
+|   +-Alias[id=1,name=date_digits,relation=,type=Long]
+|     +-Add
+|       +-Add
+|       | +-Multiply
+|       | | +-DateExtract(YEAR)
+|       | | | +-Operand=Literal[value=2016-01-02T10:20:30,type=Datetime]
+|       | | +-Literal[value=10000,type=Int]
+|       | +-Multiply
+|       |   +-DateExtract(MONTH)
+|       |   | +-Operand=Literal[value=2016-01-02T10:20:30,type=Datetime]
+|       |   +-Literal[value=100,type=Int]
+|       +-DateExtract(DAY)
+|         +-Operand=Literal[value=2016-01-02T10:20:30,type=Datetime]
++-output_attributes=
+  +-AttributeReference[id=1,name=date_digits,relation=,type=Long]
+==
+
+SELECT COUNT(DISTINCT int_col), SUM(float_col)
+FROM test
+GROUP BY long_col
+HAVING AVG(DISTINCT int_col + double_col) > AVG(DISTINCT float_col);
+--
+TopLevelPlan
++-plan=Project
+| +-input=Filter
+| | +-input=Aggregate
+| | | +-input=TableReference[relation_name=Test,relation_alias=test]
+| | | | +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | | | +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | | | +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | | | +-AttributeReference[id=3,name=double_col,relation=test,type=Double NULL]
+| | | | +-AttributeReference[id=4,name=char_col,relation=test,type=Char(20)]
+| | | | +-AttributeReference[id=5,name=vchar_col,relation=test,
+| | | |   type=VarChar(20) NULL]
+| | | +-grouping_expressions=
+| | | | +-AttributeReference[id=1,name=long_col,relation=test,type=Long]
+| | | +-aggregate_expressions=
+| | |   +-Alias[id=6,name=,alias=$aggregate0,relation=$aggregate,type=Long]
+| | |   | +-AggregateFunction[function=COUNT,is_distinct=true]
+| | |   |   +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | |   +-Alias[id=7,name=,alias=$aggregate1,relation=$aggregate,
+| | |   | type=Double NULL]
+| | |   | +-AggregateFunction[function=SUM]
+| | |   |   +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | |   +-Alias[id=8,name=,alias=$aggregate2,relation=$aggregate,
+| | |   | type=Double NULL]
+| | |   | +-AggregateFunction[function=AVG,is_distinct=true]
+| | |   |   +-Add
+| | |   |     +-AttributeReference[id=0,name=int_col,relation=test,type=Int NULL]
+| | |   |     +-AttributeReference[id=3,name=double_col,relation=test,
+| | |   |       type=Double NULL]
+| | |   +-Alias[id=9,name=,alias=$aggregate3,relation=$aggregate,
+| | |     type=Double NULL]
+| | |     +-AggregateFunction[function=AVG,is_distinct=true]
+| | |       +-AttributeReference[id=2,name=float_col,relation=test,type=Float]
+| | +-filter_predicate=Greater
+| |   +-AttributeReference[id=8,name=,alias=$aggregate2,relation=$aggregate,
+| |   | type=Double NULL]
+| |   +-AttributeReference[id=9,name=,alias=$aggregate3,relation=$aggregate,
+| |     type=Double NULL]
+| +-project_list=
+|   +-Alias[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,type=Long]
+|   | +-AttributeReference[id=6,name=,alias=$aggregate0,relation=$aggregate,
+|   |   type=Long]
+|   +-Alias[id=7,name=,alias=SUM(float_col),relation=,type=Double NULL]
+|     +-AttributeReference[id=7,name=,alias=$aggregate1,relation=$aggregate,
+|       type=Double NULL]
++-output_attributes=
+  +-AttributeReference[id=6,name=,alias=COUNT(DISTINCT int_col),relation=,
+  | type=Long]
+  +-AttributeReference[id=7,name=,alias=SUM(float_col),relation=,
+    type=Double NULL]
+==
+
 select interval '4 day' + interval '5 year'
 from test
 --
diff --git a/relational_operators/tests/AggregationOperator_unittest.cpp b/relational_operators/tests/AggregationOperator_unittest.cpp
index 3bbccf0..eca429c 100644
--- a/relational_operators/tests/AggregationOperator_unittest.cpp
+++ b/relational_operators/tests/AggregationOperator_unittest.cpp
@@ -210,6 +210,7 @@
     // Add an aggregate.
     serialization::Aggregate *aggr_proto = aggr_state_proto->add_aggregates();
     aggr_proto->mutable_function()->CopyFrom(AggregateFunctionFactory::Get(agg_type).getProto());
+    aggr_proto->set_is_distinct(false);
     if (is_expression) {
       unique_ptr<ScalarBinaryExpression> exp(
           new ScalarBinaryExpression(BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd),
@@ -224,6 +225,7 @@
     // Add another aggregate.
     aggr_proto = aggr_state_proto->add_aggregates();
     aggr_proto->mutable_function()->CopyFrom(AggregateFunctionFactory::Get(agg_type).getProto());
+    aggr_proto->set_is_distinct(false);
     if (is_expression) {
       unique_ptr<ScalarBinaryExpression> exp(
           new ScalarBinaryExpression(BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kMultiply),
@@ -260,7 +262,7 @@
 
     // Set up the QueryContext.
     query_context_.reset(new QueryContext(query_context_proto,
-                                          db_.get(),
+                                          *db_,
                                           storage_manager_.get(),
                                           foreman_client_id_,
                                           &bus_));
@@ -296,6 +298,7 @@
     // Add an aggregate.
     serialization::Aggregate *aggr_proto = aggr_state_proto->add_aggregates();
     aggr_proto->mutable_function()->CopyFrom(AggregateFunctionFactory::Get(agg_type).getProto());
+    aggr_proto->set_is_distinct(false);
 
     unique_ptr<ScalarAttribute> attr(new ScalarAttribute(*table_->getAttributeByName(stem + "-0")));
     aggr_proto->add_argument()->CopyFrom(attr->getProto());
@@ -303,6 +306,7 @@
     // Add another aggregate.
     aggr_proto = aggr_state_proto->add_aggregates();
     aggr_proto->mutable_function()->CopyFrom(AggregateFunctionFactory::Get(agg_type).getProto());
+    aggr_proto->set_is_distinct(false);
     attr.reset(new ScalarAttribute(*table_->getAttributeByName(stem + "-1")));
     aggr_proto->add_argument()->CopyFrom(attr->getProto());
 
@@ -340,7 +344,7 @@
 
     // Set up the QueryContext.
     query_context_.reset(new QueryContext(query_context_proto,
-                                          db_.get(),
+                                          *db_,
                                           storage_manager_.get(),
                                           foreman_client_id_,
                                           &bus_));
diff --git a/relational_operators/tests/HashJoinOperator_unittest.cpp b/relational_operators/tests/HashJoinOperator_unittest.cpp
index e5afe69..11540d1 100644
--- a/relational_operators/tests/HashJoinOperator_unittest.cpp
+++ b/relational_operators/tests/HashJoinOperator_unittest.cpp
@@ -342,7 +342,7 @@
 
   // Set up the QueryContext.
   query_context_.reset(new QueryContext(query_context_proto,
-                                        db_.get(),
+                                        *db_,
                                         storage_manager_.get(),
                                         foreman_client_id_,
                                         &bus_));
@@ -484,7 +484,7 @@
 
   // Set up the QueryContext.
   query_context_.reset(new QueryContext(query_context_proto,
-                                        db_.get(),
+                                        *db_,
                                         storage_manager_.get(),
                                         foreman_client_id_,
                                         &bus_));
@@ -634,7 +634,7 @@
 
   // Set up the QueryContext.
   query_context_.reset(new QueryContext(query_context_proto,
-                                        db_.get(),
+                                        *db_,
                                         storage_manager_.get(),
                                         foreman_client_id_,
                                         &bus_));
@@ -769,7 +769,7 @@
 
   // Set up the QueryContext.
   query_context_.reset(new QueryContext(query_context_proto,
-                                        db_.get(),
+                                        *db_,
                                         storage_manager_.get(),
                                         foreman_client_id_,
                                         &bus_));
@@ -938,7 +938,7 @@
 
   // Set up the QueryContext.
   query_context_.reset(new QueryContext(query_context_proto,
-                                        db_.get(),
+                                        *db_,
                                         storage_manager_.get(),
                                         foreman_client_id_,
                                         &bus_));
@@ -1118,7 +1118,7 @@
 
   // Set up the QueryContext.
   query_context_.reset(new QueryContext(query_context_proto,
-                                        db_.get(),
+                                        *db_,
                                         storage_manager_.get(),
                                         foreman_client_id_,
                                         &bus_));
diff --git a/relational_operators/tests/SortMergeRunOperator_unittest.cpp b/relational_operators/tests/SortMergeRunOperator_unittest.cpp
index 680bd25..8406c0a 100644
--- a/relational_operators/tests/SortMergeRunOperator_unittest.cpp
+++ b/relational_operators/tests/SortMergeRunOperator_unittest.cpp
@@ -1272,7 +1272,7 @@
 
     // Set up the QueryContext.
     query_context_.reset(new QueryContext(query_context_proto_,
-                                          db_.get(),
+                                          *db_,
                                           storage_manager_.get(),
                                           foreman_client_id_,
                                           &bus_));
@@ -1537,7 +1537,7 @@
 
     // Set up the QueryContext.
     query_context_.reset(new QueryContext(query_context_proto_,
-                                          db_.get(),
+                                          *db_,
                                           storage_manager_.get(),
                                           foreman_client_id_,
                                           &bus_));
@@ -1580,7 +1580,7 @@
 
     // Set up the QueryContext.
     query_context_.reset(new QueryContext(query_context_proto_,
-                                          db_.get(),
+                                          *db_,
                                           storage_manager_.get(),
                                           foreman_client_id_,
                                           &bus_));
diff --git a/relational_operators/tests/SortRunGenerationOperator_unittest.cpp b/relational_operators/tests/SortRunGenerationOperator_unittest.cpp
index 74efd26..df88e91 100644
--- a/relational_operators/tests/SortRunGenerationOperator_unittest.cpp
+++ b/relational_operators/tests/SortRunGenerationOperator_unittest.cpp
@@ -351,7 +351,7 @@
 
     // Set up the QueryContext.
     query_context_.reset(new QueryContext(query_context_proto,
-                                          db_.get(),
+                                          *db_,
                                           storage_manager_.get(),
                                           thread_client_id_,
                                           &bus_));
diff --git a/relational_operators/tests/TextScanOperator_unittest.cpp b/relational_operators/tests/TextScanOperator_unittest.cpp
index dbfb17f..292794f 100644
--- a/relational_operators/tests/TextScanOperator_unittest.cpp
+++ b/relational_operators/tests/TextScanOperator_unittest.cpp
@@ -179,7 +179,7 @@
 
   // Setup query_context_.
   query_context_.reset(new QueryContext(query_context_proto,
-                                        db_.get(),
+                                        *db_,
                                         storage_manager_.get(),
                                         foreman_client_id_,
                                         &bus_));
diff --git a/storage/AggregationOperationState.cpp b/storage/AggregationOperationState.cpp
index a129cc7..a3a669c 100644
--- a/storage/AggregationOperationState.cpp
+++ b/storage/AggregationOperationState.cpp
@@ -59,6 +59,7 @@
     const CatalogRelationSchema &input_relation,
     const std::vector<const AggregateFunction*> &aggregate_functions,
     std::vector<std::vector<std::unique_ptr<const Scalar>>> &&arguments,
+    std::vector<bool> &&is_distinct,
     std::vector<std::unique_ptr<const Scalar>> &&group_by,
     const Predicate *predicate,
     const std::size_t estimated_num_entries,
@@ -68,6 +69,7 @@
       predicate_(predicate),
       group_by_list_(std::move(group_by)),
       arguments_(std::move(arguments)),
+      is_distinct_(std::move(is_distinct)),
       storage_manager_(storage_manager) {
   // Sanity checks: each aggregate has a corresponding list of arguments.
   DCHECK(aggregate_functions.size() == arguments_.size());
@@ -85,6 +87,7 @@
 
     handles_.emplace_back(new AggregationHandleDistinct());
     arguments_.push_back({});
+    is_distinct_.emplace_back(false);
 
     group_by_hashtables_.emplace_back(handles_.back()->createGroupByHashTable(
         hash_table_impl_type,
@@ -97,7 +100,8 @@
         = aggregate_functions.begin();
     std::vector<std::vector<std::unique_ptr<const Scalar>>>::const_iterator args_it
         = arguments_.begin();
-    for (; agg_func_it != aggregate_functions.end(); ++agg_func_it, ++args_it) {
+    std::vector<bool>::const_iterator is_distinct_it = is_distinct_.begin();
+    for (; agg_func_it != aggregate_functions.end(); ++agg_func_it, ++args_it, ++is_distinct_it) {
       // Get the Types of this aggregate's arguments so that we can create an
       // AggregationHandle.
       std::vector<const Type*> argument_types;
@@ -145,6 +149,25 @@
         arguments_as_attributes_.emplace_back(std::move(local_arguments_as_attributes));
 #endif
       }
+
+      // Initialize the corresponding distinctify hash table if this is a DISTINCT
+      // aggregation.
+      if (*is_distinct_it) {
+        std::vector<const Type*> key_types(group_by_types);
+        key_types.insert(key_types.end(), argument_types.begin(), argument_types.end());
+        // TODO(jianqiao): estimated_num_entries is quite inaccurate for estimating
+        // the number of entries in the distinctify hash table. We may estimate
+        // for each distinct aggregation an estimated_num_distinct_keys value during
+        // query optimization, if it worths.
+        distinctify_hashtables_.emplace_back(
+            handles_.back()->createDistinctifyHashTable(
+                hash_table_impl_type,
+                key_types,
+                estimated_num_entries,
+                storage_manager));
+      } else {
+        distinctify_hashtables_.emplace_back(nullptr);
+      }
     }
   }
 }
@@ -158,6 +181,7 @@
   // Rebuild contructor arguments from their representation in 'proto'.
   std::vector<const AggregateFunction*> aggregate_functions;
   std::vector<std::vector<std::unique_ptr<const Scalar>>> arguments;
+  std::vector<bool> is_distinct;
   for (int agg_idx = 0; agg_idx < proto.aggregates_size(); ++agg_idx) {
     const serialization::Aggregate &agg_proto = proto.aggregates(agg_idx);
 
@@ -171,6 +195,8 @@
           agg_proto.argument(argument_idx),
           database));
     }
+
+    is_distinct.emplace_back(agg_proto.is_distinct());
   }
 
   std::vector<std::unique_ptr<const Scalar>> group_by_expressions;
@@ -192,6 +218,7 @@
   return new AggregationOperationState(database.getRelationSchemaById(proto.relation_id()),
                                        aggregate_functions,
                                        std::move(arguments),
+                                       std::move(is_distinct),
                                        std::move(group_by_expressions),
                                        predicate.release(),
                                        proto.estimated_num_entries(),
@@ -256,7 +283,7 @@
   }
 }
 
-void AggregationOperationState::finalizeAggregate(InsertDestination *output_destination) const {
+void AggregationOperationState::finalizeAggregate(InsertDestination *output_destination) {
   if (group_by_list_.empty()) {
     finalizeSingleState(output_destination);
   } else {
@@ -268,8 +295,10 @@
     const std::vector<std::unique_ptr<AggregationState>> &local_state) {
   DEBUG_ASSERT(local_state.size() == single_states_.size());
   for (std::size_t agg_idx = 0; agg_idx < handles_.size(); ++agg_idx) {
-    handles_[agg_idx]->mergeStates(*local_state[agg_idx],
-                                   single_states_[agg_idx].get());
+    if (!is_distinct_[agg_idx]) {
+      handles_[agg_idx]->mergeStates(*local_state[agg_idx],
+                                     single_states_[agg_idx].get());
+    }
   }
 }
 
@@ -293,13 +322,28 @@
       local_arguments_as_attributes = &(arguments_as_attributes_[agg_idx]);
     }
 #endif
-    // Call StorageBlock::aggregate() to actually do the aggregation.
-    local_state.emplace_back(
-        block->aggregate(*handles_[agg_idx],
-                         arguments_[agg_idx],
-                         local_arguments_as_attributes,
-                         predicate_.get(),
-                         &reuse_matches));
+    if (is_distinct_[agg_idx]) {
+      // Call StorageBlock::aggregateDistinct() to put the arguments as keys
+      // directly into the (threadsafe) shared global distinctify HashTable
+      // for this aggregate.
+      block->aggregateDistinct(*handles_[agg_idx],
+                               arguments_[agg_idx],
+                               local_arguments_as_attributes,
+                               {}, /* group_by */
+                               predicate_.get(),
+                               distinctify_hashtables_[agg_idx].get(),
+                               &reuse_matches,
+                               nullptr /* reuse_group_by_vectors */);
+      local_state.emplace_back(nullptr);
+    } else {
+      // Call StorageBlock::aggregate() to actually do the aggregation.
+      local_state.emplace_back(
+          block->aggregate(*handles_[agg_idx],
+                           arguments_[agg_idx],
+                           local_arguments_as_attributes,
+                           predicate_.get(),
+                           &reuse_matches));
+    }
   }
 
   // Merge per-block aggregation states back with global state.
@@ -322,24 +366,38 @@
   for (std::size_t agg_idx = 0;
        agg_idx < handles_.size();
        ++agg_idx) {
-    // Call StorageBlock::aggregateGroupBy() to aggregate this block's values
-    // directly into the (threadsafe) shared global HashTable for this
-    // aggregate.
-    //
-    // TODO(shoban): Implement optional code path for using local hash table per
-    // block, which can be merged with global hash table for all blocks
-    // aggregated on.
-    block->aggregateGroupBy(*handles_[agg_idx],
-                            arguments_[agg_idx],
-                            group_by_list_,
-                            predicate_.get(),
-                            group_by_hashtables_[agg_idx].get(),
-                            &reuse_matches,
-                            &reuse_group_by_vectors);
+    if (is_distinct_[agg_idx]) {
+      // Call StorageBlock::aggregateDistinct() to insert the GROUP BY expression
+      // values and the aggregation arguments together as keys directly into the
+      // (threadsafe) shared global distinctify HashTable for this aggregate.
+      block->aggregateDistinct(*handles_[agg_idx],
+                               arguments_[agg_idx],
+                               nullptr, /* arguments_as_attributes */
+                               group_by_list_,
+                               predicate_.get(),
+                               distinctify_hashtables_[agg_idx].get(),
+                               &reuse_matches,
+                               &reuse_group_by_vectors);
+    } else {
+      // Call StorageBlock::aggregateGroupBy() to aggregate this block's values
+      // directly into the (threadsafe) shared global HashTable for this
+      // aggregate.
+      //
+      // TODO(shoban): Implement optional code path for using local hash table per
+      // block, which can be merged with global hash table for all blocks
+      // aggregated on.
+      block->aggregateGroupBy(*handles_[agg_idx],
+                              arguments_[agg_idx],
+                              group_by_list_,
+                              predicate_.get(),
+                              group_by_hashtables_[agg_idx].get(),
+                              &reuse_matches,
+                              &reuse_group_by_vectors);
+    }
   }
 }
 
-void AggregationOperationState::finalizeSingleState(InsertDestination *output_destination) const {
+void AggregationOperationState::finalizeSingleState(InsertDestination *output_destination) {
   // Simply build up a Tuple from the finalized values for each aggregate and
   // insert it in '*output_destination'.
   std::vector<TypedValue> attribute_values;
@@ -347,13 +405,18 @@
   for (std::size_t agg_idx = 0;
        agg_idx < handles_.size();
        ++agg_idx) {
+    if (is_distinct_[agg_idx]) {
+      single_states_[agg_idx].reset(
+          handles_[agg_idx]->aggregateOnDistinctifyHashTableForSingle(*distinctify_hashtables_[agg_idx]));
+    }
+
     attribute_values.emplace_back(handles_[agg_idx]->finalize(*single_states_[agg_idx]));
   }
 
   output_destination->insertTuple(Tuple(std::move(attribute_values)));
 }
 
-void AggregationOperationState::finalizeHashTable(InsertDestination *output_destination) const {
+void AggregationOperationState::finalizeHashTable(InsertDestination *output_destination) {
   // Each element of 'group_by_keys' is a vector of values for a particular
   // group (which is also the prefix of the finalized Tuple for that group).
   std::vector<std::vector<TypedValue>> group_by_keys;
@@ -363,11 +426,17 @@
   for (std::size_t agg_idx = 0;
        agg_idx < handles_.size();
        ++agg_idx) {
-    ColumnVector* col =
+    if (is_distinct_[agg_idx]) {
+      handles_[agg_idx]->aggregateOnDistinctifyHashTableForGroupBy(
+          *distinctify_hashtables_[agg_idx],
+          group_by_hashtables_[agg_idx].get());
+    }
+
+    ColumnVector* agg_result_col =
         handles_[agg_idx]->finalizeHashTable(*group_by_hashtables_[agg_idx],
                                              &group_by_keys);
-    if (col != nullptr) {
-      final_values.emplace_back(col);
+    if (agg_result_col != nullptr) {
+      final_values.emplace_back(agg_result_col);
     }
   }
 
diff --git a/storage/AggregationOperationState.hpp b/storage/AggregationOperationState.hpp
index 565d1f8..b883ed1 100644
--- a/storage/AggregationOperationState.hpp
+++ b/storage/AggregationOperationState.hpp
@@ -18,6 +18,7 @@
 #ifndef QUICKSTEP_RELATIONAL_OPERATORS_AGGREGATION_OPERATION_HPP_
 #define QUICKSTEP_RELATIONAL_OPERATORS_AGGREGATION_OPERATION_HPP_
 
+#include <cstddef>
 #include <memory>
 #include <vector>
 
@@ -79,6 +80,8 @@
    * @param arguments For each entry in aggregate_functions, a corresponding
    *        list of argument expressions to that aggregate. This is moved-from,
    *        with AggregationOperationState taking ownership.
+   * @param is_distinct For each entry in aggregate_functions, whether DISTINCT
+   *        should be applied to the entry's arguments.
    * @param group_by A list of expressions to compute the GROUP BY values. If
    *        empty, no grouping is used. This is moved-from, with
    *        AggregationOperationState taking ownership.
@@ -97,6 +100,7 @@
   AggregationOperationState(const CatalogRelationSchema &input_relation,
                             const std::vector<const AggregateFunction*> &aggregate_functions,
                             std::vector<std::vector<std::unique_ptr<const Scalar>>> &&arguments,
+                            std::vector<bool> &&is_distinct,
                             std::vector<std::unique_ptr<const Scalar>> &&group_by,
                             const Predicate *predicate,
                             const std::size_t estimated_num_entries,
@@ -153,7 +157,7 @@
    * @param output_destination An InsertDestination where the finalized output
    *        tuple(s) from this aggregate are to be written.
    **/
-  void finalizeAggregate(InsertDestination *output_destination) const;
+  void finalizeAggregate(InsertDestination *output_destination);
 
  private:
   // Merge locally (per storage block) aggregated states with global aggregation
@@ -164,8 +168,8 @@
   void aggregateBlockSingleState(const block_id input_block);
   void aggregateBlockHashTable(const block_id input_block);
 
-  void finalizeSingleState(InsertDestination *output_destination) const;
-  void finalizeHashTable(InsertDestination *output_destination) const;
+  void finalizeSingleState(InsertDestination *output_destination);
+  void finalizeHashTable(InsertDestination *output_destination);
 
   // Common state for all aggregates in this operation: the input relation, the
   // filter predicate (if any), and the list of GROUP BY expressions (if any).
@@ -178,6 +182,13 @@
   std::vector<std::unique_ptr<AggregationHandle>> handles_;
   std::vector<std::vector<std::unique_ptr<const Scalar>>> arguments_;
 
+  // For each aggregate, whether DISTINCT should be applied to the aggregate's
+  // arguments.
+  std::vector<bool> is_distinct_;
+
+  // Hash table for obtaining distinct (i.e. unique) arguments.
+  std::vector<std::unique_ptr<AggregationStateHashTableBase>> distinctify_hashtables_;
+
 #ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION
   // If all an aggregate's argument expressions are simply attributes in
   // 'input_relation_', then this caches the attribute IDs of those arguments.
diff --git a/storage/AggregationOperationState.proto b/storage/AggregationOperationState.proto
index 13836a3..031f782 100644
--- a/storage/AggregationOperationState.proto
+++ b/storage/AggregationOperationState.proto
@@ -1,5 +1,5 @@
 //   Copyright 2011-2015 Quickstep Technologies LLC.
-//   Copyright 2015 Pivotal Software, Inc.
+//   Copyright 2015-2016 Pivotal Software, Inc.
 //
 //   Licensed under the Apache License, Version 2.0 (the "License");
 //   you may not use this file except in compliance with the License.
@@ -24,6 +24,7 @@
 message Aggregate {
   required AggregateFunction function = 1;
   repeated Scalar argument = 2;
+  required bool is_distinct = 3;
 }
 
 message AggregationOperationState {
diff --git a/storage/CMakeLists.txt b/storage/CMakeLists.txt
index 918a348..0ba699b 100644
--- a/storage/CMakeLists.txt
+++ b/storage/CMakeLists.txt
@@ -1,5 +1,7 @@
 #   Copyright 2011-2015 Quickstep Technologies LLC.
 #   Copyright 2015-2016 Pivotal Software, Inc.
+#   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+#     University of Wisconsin—Madison.
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -609,6 +611,7 @@
 target_link_libraries(quickstep_storage_PackedRowStoreTupleStorageSubBlock
                       quickstep_catalog_CatalogAttribute
                       quickstep_catalog_CatalogRelationSchema
+                      quickstep_catalog_CatalogTypedefs
                       quickstep_expressions_predicate_PredicateCost
                       quickstep_storage_PackedRowStoreValueAccessor
                       quickstep_storage_StorageBlockInfo
diff --git a/storage/PackedRowStoreTupleStorageSubBlock.cpp b/storage/PackedRowStoreTupleStorageSubBlock.cpp
index 1328826..4cb6d02 100644
--- a/storage/PackedRowStoreTupleStorageSubBlock.cpp
+++ b/storage/PackedRowStoreTupleStorageSubBlock.cpp
@@ -1,6 +1,8 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -23,6 +25,7 @@
 
 #include "catalog/CatalogAttribute.hpp"
 #include "catalog/CatalogRelationSchema.hpp"
+#include "catalog/CatalogTypedefs.hpp"
 #include "storage/PackedRowStoreValueAccessor.hpp"
 #include "storage/StorageBlockInfo.hpp"
 #include "storage/StorageBlockLayout.pb.h"
@@ -143,46 +146,55 @@
   InvokeOnAnyValueAccessor(
       accessor,
       [&](auto *accessor) -> void {  // NOLINT(build/c++11)
+    const std::size_t num_attrs = relation_.size();
+    const std::vector<std::size_t> &attrs_max_size =
+        relation_.getMaximumAttributeByteLengths();
+
     if (num_nullable_attrs != 0) {
       while (this->hasSpaceToInsert<true>(1) && accessor->next()) {
-        attribute_id accessor_attr_id = 0;
-        for (CatalogRelationSchema::const_iterator attr_it = relation_.begin();
-             attr_it != relation_.end();
-             ++attr_it) {
-          const std::size_t attr_size = attr_it->getType().maximumByteLength();
-          const int nullable_idx = relation_.getNullableAttributeIndex(
-              attr_it->getID());
-          if (nullable_idx != -1) {
+        for (std::size_t curr_attr = 0; curr_attr < num_attrs; ++curr_attr) {
+          const std::size_t attr_size = attrs_max_size[curr_attr];
+          const attribute_id nullable_idx = relation_.getNullableAttributeIndex(curr_attr);
+          // If this attribute is nullable, check for a returned null value.
+          if (nullable_idx != kInvalidCatalogId) {
             const void *attr_value
-                = accessor->template getUntypedValue<true>(accessor_attr_id);
+                = accessor->template getUntypedValue<true>(curr_attr);
             if (attr_value == nullptr) {
-              null_bitmap_->setBit(header_->num_tuples * num_nullable_attrs + nullable_idx,
-                                   true);
+              null_bitmap_->setBit(
+                  header_->num_tuples * num_nullable_attrs + nullable_idx,
+                  true);
             } else {
               memcpy(dest_addr, attr_value, attr_size);
             }
           } else {
             memcpy(dest_addr,
-                   accessor->template getUntypedValue<false>(accessor_attr_id),
+                   accessor->template getUntypedValue<false>(curr_attr),
                    attr_size);
           }
-          ++accessor_attr_id;
           dest_addr += attr_size;
         }
         ++(header_->num_tuples);
       }
     } else {
+      // If the accessor is from a packed row store, we can optimize the
+      // memcpy by avoiding iterating over each attribute.
+      const bool fast_copy =
+          (accessor->getImplementationType() ==
+              ValueAccessor::Implementation::kCompressedPackedRowStore);
+      const std::size_t attrs_total_size = relation_.getMaximumByteLength();
       while (this->hasSpaceToInsert<false>(1) && accessor->next()) {
-        attribute_id accessor_attr_id = 0;
-        for (CatalogRelationSchema::const_iterator attr_it = relation_.begin();
-             attr_it != relation_.end();
-             ++attr_it) {
-          const std::size_t attr_size = attr_it->getType().maximumByteLength();
+        if (fast_copy) {
           memcpy(dest_addr,
-                 accessor->template getUntypedValue<false>(accessor_attr_id),
-                 attr_size);
-          ++accessor_attr_id;
-          dest_addr += attr_size;
+                 accessor->template getUntypedValue<false>(0),
+                 attrs_total_size);
+        } else {
+          for (std::size_t curr_attr = 0; curr_attr < num_attrs; ++curr_attr) {
+            const std::size_t attr_size = attrs_max_size[curr_attr];
+            memcpy(dest_addr,
+                   accessor->template getUntypedValue<false>(curr_attr),
+                   attr_size);
+            dest_addr += attr_size;
+          }
         }
         ++(header_->num_tuples);
       }
@@ -205,45 +217,42 @@
   InvokeOnAnyValueAccessor(
       accessor,
       [&](auto *accessor) -> void {  // NOLINT(build/c++11)
+    const std::size_t num_attrs = relation_.size();
+    const std::vector<std::size_t> &attrs_max_size =
+        relation_.getMaximumAttributeByteLengths();
+
     if (num_nullable_attrs != 0) {
       while (this->hasSpaceToInsert<true>(1) && accessor->next()) {
-        std::vector<attribute_id>::const_iterator attribute_map_it = attribute_map.begin();
-        for (CatalogRelationSchema::const_iterator attr_it = relation_.begin();
-             attr_it != relation_.end();
-             ++attr_it) {
-          const std::size_t attr_size = attr_it->getType().maximumByteLength();
-          const int nullable_idx = relation_.getNullableAttributeIndex(
-              attr_it->getID());
-          if (nullable_idx != -1) {
+        for (std::size_t curr_attr = 0; curr_attr < num_attrs; ++curr_attr) {
+          const std::size_t attr_size = attrs_max_size[curr_attr];
+          const attribute_id nullable_idx = relation_.getNullableAttributeIndex(curr_attr);
+          // If this attribute is nullable, check for a returned null value.
+          if (nullable_idx != kInvalidCatalogId) {
             const void *attr_value
-                = accessor->template getUntypedValue<true>(*attribute_map_it);
+                = accessor->template getUntypedValue<true>(attribute_map[curr_attr]);
             if (attr_value == nullptr) {
-              null_bitmap_->setBit(header_->num_tuples * num_nullable_attrs + nullable_idx,
-                                   true);
+              null_bitmap_->setBit(
+                  header_->num_tuples * num_nullable_attrs + nullable_idx,
+                  true);
             } else {
               memcpy(dest_addr, attr_value, attr_size);
             }
           } else {
             memcpy(dest_addr,
-                   accessor->template getUntypedValue<false>(*attribute_map_it),
+                   accessor->template getUntypedValue<false>(attribute_map[curr_attr]),
                    attr_size);
           }
-          ++attribute_map_it;
           dest_addr += attr_size;
         }
         ++(header_->num_tuples);
       }
     } else {
       while (this->hasSpaceToInsert<false>(1) && accessor->next()) {
-        std::vector<attribute_id>::const_iterator attribute_map_it = attribute_map.begin();
-        for (CatalogRelationSchema::const_iterator attr_it = relation_.begin();
-             attr_it != relation_.end();
-             ++attr_it) {
-          const std::size_t attr_size = attr_it->getType().maximumByteLength();
+        for (std::size_t curr_attr = 0; curr_attr < num_attrs; ++curr_attr) {
+          const std::size_t attr_size = attrs_max_size[curr_attr];
           memcpy(dest_addr,
-                 accessor->template getUntypedValue<false>(*attribute_map_it),
+                 accessor->template getUntypedValue<false>(attribute_map[curr_attr]),
                  attr_size);
-          ++attribute_map_it;
           dest_addr += attr_size;
         }
         ++(header_->num_tuples);
diff --git a/storage/StorageBlock.cpp b/storage/StorageBlock.cpp
index 6fd6bb2..e9ddb70 100644
--- a/storage/StorageBlock.cpp
+++ b/storage/StorageBlock.cpp
@@ -1,6 +1,6 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
- *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2015-2016 Pivotal Software, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -486,6 +486,95 @@
                                              hash_table);
 }
 
+void StorageBlock::aggregateDistinct(
+    const AggregationHandle &handle,
+    const std::vector<std::unique_ptr<const Scalar>> &arguments,
+    const std::vector<attribute_id> *arguments_as_attributes,
+    const std::vector<std::unique_ptr<const Scalar>> &group_by,
+    const Predicate *predicate,
+    AggregationStateHashTableBase *distinctify_hash_table,
+    std::unique_ptr<TupleIdSequence> *reuse_matches,
+    std::vector<std::unique_ptr<ColumnVector>> *reuse_group_by_vectors) const {
+  DCHECK_GT(arguments.size(), 0u)
+      << "Called aggregateDistinct() with zero argument expressions";
+  DCHECK((group_by.size() == 0 || reuse_group_by_vectors != nullptr));
+
+  std::vector<attribute_id> key_ids;
+
+  // An intermediate ValueAccessor that stores the materialized 'arguments' for
+  // this aggregate, as well as the GROUP BY expression values.
+  ColumnVectorsValueAccessor temp_result;
+  {
+    std::unique_ptr<ValueAccessor> accessor;
+    if (predicate) {
+      if (!*reuse_matches) {
+        // If there is a filter predicate that hasn't already been evaluated,
+        // evaluate it now and save the results for other aggregates on this
+        // same block.
+        reuse_matches->reset(getMatchesForPredicate(predicate));
+      }
+
+      // Create a filtered ValueAccessor that only iterates over predicate
+      // matches.
+      accessor.reset(tuple_store_->createValueAccessor(reuse_matches->get()));
+    } else {
+      // Create a ValueAccessor that iterates over all tuples in this block
+      accessor.reset(tuple_store_->createValueAccessor());
+    }
+
+#ifdef QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION
+    // If all the arguments to this aggregate are plain relation attributes,
+    // aggregate directly on a ValueAccessor from this block to avoid a copy.
+    if ((arguments_as_attributes != nullptr) && (!arguments_as_attributes->empty())) {
+      DCHECK_EQ(arguments.size(), arguments_as_attributes->size())
+          << "Mismatch between number of arguments and number of attribute_ids";
+      DCHECK_EQ(group_by.size(), 0u);
+      handle.insertValueAccessorIntoDistinctifyHashTable(
+          accessor.get(), *arguments_as_attributes, distinctify_hash_table);
+      return;
+    }
+#endif
+
+    SubBlocksReference sub_blocks_ref(*tuple_store_,
+                                      indices_,
+                                      indices_consistent_);
+    attribute_id attr_id = 0;
+
+    if (!group_by.empty()) {
+      // Put GROUP BY keys into 'temp_result'.
+      if (reuse_group_by_vectors->empty()) {
+        // Compute GROUP BY values from group_by Scalars, and store them in
+        // reuse_group_by_vectors for reuse by other aggregates on this same
+        // block.
+        reuse_group_by_vectors->reserve(group_by.size());
+        for (const std::unique_ptr<const Scalar> &group_by_element : group_by) {
+          reuse_group_by_vectors->emplace_back(
+              group_by_element->getAllValues(accessor.get(), &sub_blocks_ref));
+          temp_result.addColumn(reuse_group_by_vectors->back().get(), false);
+          key_ids.push_back(attr_id++);
+        }
+      } else {
+        // Reuse precomputed GROUP BY values from reuse_group_by_vectors.
+        DCHECK_EQ(group_by.size(), reuse_group_by_vectors->size())
+            << "Wrong number of reuse_group_by_vectors";
+        for (const std::unique_ptr<ColumnVector> &reuse_cv : *reuse_group_by_vectors) {
+          temp_result.addColumn(reuse_cv.get(), false);
+          key_ids.push_back(attr_id++);
+        }
+      }
+    }
+    // Compute argument vectors and add them to 'temp_result'.
+    for (const std::unique_ptr<const Scalar> &argument : arguments) {
+      temp_result.addColumn(argument->getAllValues(accessor.get(), &sub_blocks_ref));
+      key_ids.push_back(attr_id++);
+    }
+  }
+
+  handle.insertValueAccessorIntoDistinctifyHashTable(
+      &temp_result, key_ids, distinctify_hash_table);
+}
+
+
 // TODO(chasseur): Vectorization for updates.
 StorageBlock::UpdateResult StorageBlock::update(
     const unordered_map<attribute_id, unique_ptr<const Scalar>> &assignments,
diff --git a/storage/StorageBlock.hpp b/storage/StorageBlock.hpp
index 3b45998..97813e2 100644
--- a/storage/StorageBlock.hpp
+++ b/storage/StorageBlock.hpp
@@ -1,6 +1,6 @@
 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
- *   Copyright 2015 Pivotal Software, Inc.
+ *   Copyright 2015-2016 Pivotal Software, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -467,6 +467,50 @@
                             *reuse_group_by_vectors) const;
 
   /**
+   * @brief Inserts the GROUP BY expressions and aggregation arguments together
+   *        as keys into the distinctify hash table.
+   *
+   * This is the first step for DISTINCT aggregation. It populates the distinctify
+   * hash table so that arguments are distinctified within each GROUP BY group.
+   * Later, a second-round aggregation on the distinctify hash table will be
+   * performed to actually compute the aggregated result for each GROUP BY group.
+   *
+   * @param handle Aggregation handle to compute aggregates with.
+   * @param arguments The arguments to the aggregation function as Scalars.
+   * @param arguments_as_attributes If non-NULL, indicates a valid attribute_id
+   *        for each of the elements in arguments, and is used to elide a copy.
+   *        Has no effect if NULL, or if VECTOR_COPY_ELISION_LEVEL is NONE.
+   * @param group_by The list of GROUP BY attributes/expressions.
+   * @param predicate A predicate for selection. \c nullptr indicates that all
+   *        tuples should be aggregated on.
+   * @param distinctify_hash_table Hash table to store the arguments and GROUP
+   *        BY expressions together as hash table key and a bool constant \c true
+   *        as hash table value. (So the hash table actually serves as a hash set.)
+   * @param reuse_matches This parameter is used to store and reuse tuple-id
+   *        sequence of matches pre-computed in an earlier invocations of
+   *        aggregateGroupBy(). \c reuse_matches is never \c nullptr for ease of
+   *        use.  Current invocation of aggregateGroupBy() will reuse
+   *        TupleIdSequence if passed, otherwise computes a TupleIdSequence based
+   *        on \c predicate and stores in \c reuse_matches. We use
+   *        std::unique_ptr for each of use, since the caller will not have to
+   *        selective free.
+   * @param reuse_group_by_vectors This parameter is used to store and reuse
+   *        GROUP BY attribute vectors pre-computed in an earlier invocation of
+   *        aggregateGroupBy(). \c reuse_group_by_vectors is never \c nullptr
+   *        for ease of use. Current invocation of aggregateGroupBy() will reuse
+   *        ColumnVectors if non-empty, otherwise computes ColumnVectors based
+   *        on \c group_by and stores them in \c reuse_group_by_vectors.
+   */
+  void aggregateDistinct(const AggregationHandle &handle,
+                         const std::vector<std::unique_ptr<const Scalar>> &arguments,
+                         const std::vector<attribute_id> *arguments_as_attributes,
+                         const std::vector<std::unique_ptr<const Scalar>> &group_by,
+                         const Predicate *predicate,
+                         AggregationStateHashTableBase *distinctify_hash_table,
+                         std::unique_ptr<TupleIdSequence> *reuse_matches,
+                         std::vector<std::unique_ptr<ColumnVector>> *reuse_group_by_vectors) const;
+
+  /**
    * @brief Perform an UPDATE query over the tuples in this StorageBlock.
    * @warning In some edge cases, calling this method may cause IndexSubBlocks
    *          in this block to become inconsistent (the TupleStorageSubBlock
diff --git a/transaction/AccessMode.cpp b/transaction/AccessMode.cpp
new file mode 100644
index 0000000..3618bfd
--- /dev/null
+++ b/transaction/AccessMode.cpp
@@ -0,0 +1,34 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "AccessMode.hpp"
+
+namespace quickstep {
+namespace transaction {
+
+const bool AccessMode::kLockCompatibilityMatrix[kNumberLocks][kNumberLocks] = {
+/*           NL     IS     IX      S     SIX     X    */
+/*  NL  */ {true , true , true , true , true , true },
+/*  IS  */ {true , true , true , true , true , false},
+/*  IX  */ {true , true , true , false, false, false},
+/*  S   */ {true , true , false, true , false, false},
+/*  SIX */ {true , true , false, false, false, false},
+/*  X   */ {true , false, false, false, false, false}
+};
+
+}  // namespace transaction
+}  // namespace quickstep
diff --git a/transaction/AccessMode.hpp b/transaction/AccessMode.hpp
new file mode 100644
index 0000000..34ace36
--- /dev/null
+++ b/transaction/AccessMode.hpp
@@ -0,0 +1,158 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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_TRANSACTION_ACCESS_MODE_HPP_
+#define QUICKSTEP_TRANSACTION_ACCESS_MODE_HPP_
+
+#include <cstdint>
+#include <type_traits>
+
+namespace quickstep {
+namespace transaction {
+
+/** \addtogroup Transaction
+ *  @{
+ */
+
+/**
+ * @brief Represents mode type. Possible options are NL, IS, IX, S, SIX, X.
+ **/
+enum class AccessModeType : std::uint8_t {
+  kNoLock = 0,
+  kIsLock,
+  kIxLock,
+  kSLock,
+  kSixLock,
+  kXLock,
+  kNumAccessModeTypes,
+};
+
+/**
+ * @brief Class for representing resource lock's access mode
+ **/
+class AccessMode {
+ public:
+  /**
+   * @brief Only constructor for access mode.
+   *
+   * @param access_mode Mode type of the object.
+   **/
+  explicit AccessMode(const AccessModeType access_mode)
+      : access_mode_(access_mode) {}
+
+  /**
+   * @brief Checks whether this access mode is compatible with the other.
+   *
+   * @param other Other access mode that will be checked against to this one.
+   * @return True if they are compatible, otherwise false.
+   **/
+  inline bool isCompatible(const AccessMode &other) const {
+    const access_mode_underlying_type this_mode =
+        static_cast<access_mode_underlying_type>(access_mode_);
+    const access_mode_underlying_type other_mode =
+        static_cast<access_mode_underlying_type>(other.access_mode_);
+    return AccessMode::kLockCompatibilityMatrix[this_mode][other_mode];
+  }
+
+  /**
+   * @brief Checks whether this access mode is IS mode.
+   *
+   * @return True if it is IS mode, false otherwise.
+   **/
+  inline bool isIntentionShareLock() const {
+    return access_mode_ == AccessModeType::kIsLock;
+  }
+
+  /**
+   * @brief Checks whether this access mode is IX mode.
+   *
+   * @return True if it is IX mode, false otherwise.
+   **/
+  inline bool isIntentionExclusiveLock() const {
+    return access_mode_ == AccessModeType::kIxLock;
+  }
+
+  /**
+   * @brief Checks whether this access mdoe is SIX mode.
+   *
+   * @return True if it is SIX mode, false otherwise.
+   **/
+  inline bool isShareAndIntentionExclusiveLock() const {
+    return access_mode_ == AccessModeType::kSixLock;
+  }
+
+  /**
+   * @brief Checks whether this access mode is S mode.
+   *
+   * @return True if it is S mode, false otherwise.
+   **/
+  inline bool isShareLock() const {
+    return access_mode_ == AccessModeType::kSLock;
+  }
+
+  /**
+   * @brief Checks whether this access mode is X mode.
+   *
+   * @return True if it is X mode, false otherwise.
+   **/
+  inline bool isExclusiveLock() const {
+    return access_mode_ == AccessModeType::kXLock;
+  }
+
+  /**
+   * @brief Checks whether this access mode is in
+   *        the same level with other mode.
+   *
+   * @return True if both modes have the same level.
+   **/
+  inline bool operator==(const AccessMode &other) const {
+    return access_mode_ == other.access_mode_;
+  }
+
+  /**
+   * @brief Checks whether this access mode is in
+   *        the different level with other mode.
+   *
+   * @return True if the modes have different levels.
+   **/
+  inline bool operator!=(const AccessMode &other) const {
+    return access_mode_ != other.access_mode_;
+  }
+
+ private:
+  typedef std::underlying_type<AccessModeType>::type
+      access_mode_underlying_type;
+
+  // The compatibility matrix should be N by N. kNumberLocks == N.
+  static constexpr std::uint64_t kNumberLocks =
+      static_cast<access_mode_underlying_type>(
+          AccessModeType::kNumAccessModeTypes);
+
+  // Compatibility matrix for checking access modes.
+  // True means they are compatible.
+  static const bool kLockCompatibilityMatrix[kNumberLocks][kNumberLocks];
+  // Type of access, the possible values are
+  // NoLock, IsLock, IxLock, SLock, SixLock, XLock
+  AccessModeType access_mode_;
+};
+
+/** @} */
+
+}  // namespace transaction
+}  // namespace quickstep
+
+#endif  // QUICKSTEP_TRANSACTION_ACCESS_MODE_HPP_
diff --git a/transaction/CMakeLists.txt b/transaction/CMakeLists.txt
index 2babf51..05fc96a 100644
--- a/transaction/CMakeLists.txt
+++ b/transaction/CMakeLists.txt
@@ -13,31 +13,89 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+add_library(quickstep_transaction_AccessMode
+            AccessMode.cpp
+            AccessMode.hpp)
 add_library(quickstep_transaction_DirectedGraph
             ../empty_src.cpp
             DirectedGraph.hpp)
+add_library(quickstep_transaction_Lock
+            ../empty_src.cpp
+            Lock.hpp)
+add_library(quickstep_transaction_LockRequest
+            ../empty_src.cpp
+            LockRequest.hpp)
+add_library(quickstep_transaction_LockTable
+            LockTable.cpp
+            LockTable.hpp)
+add_library(quickstep_transaction_ResourceId
+            ResourceId.cpp
+            ResourceId.hpp)
 add_library(quickstep_transaction_StronglyConnectedComponents
             StronglyConnectedComponents.cpp
             StronglyConnectedComponents.hpp)
 add_library(quickstep_transaction_Transaction
             ../empty_src.cpp
             Transaction.hpp)
-
+add_library(quickstep_transaction_TransactionTable
+            TransactionTable.cpp
+            TransactionTable.hpp)
+          
 target_link_libraries(quickstep_transaction_DirectedGraph
-	              glog
+                      glog
                       quickstep_transaction_Transaction
                       quickstep_utility_Macros)
+target_link_libraries(quickstep_transaction_Lock
+                      quickstep_transaction_AccessMode
+                      quickstep_transaction_ResourceId)
+target_link_libraries(quickstep_transaction_LockRequest
+                      quickstep_transaction_AccessMode
+                      quickstep_transaction_ResourceId
+                      quickstep_transaction_Transaction)
+target_link_libraries(quickstep_transaction_LockTable
+                      quickstep_threading_SharedMutex
+                      quickstep_transaction_AccessMode
+                      quickstep_transaction_Lock
+                      quickstep_transaction_ResourceId
+                      quickstep_transaction_Transaction
+                      quickstep_utility_Macros)
+target_link_libraries(quickstep_transaction_ResourceId
+                      quickstep_catalog_CatalogTypedefs
+                      quickstep_storage_StorageBlockInfo
+                      quickstep_utility_HashPair)
+target_link_libraries(quickstep_transaction_ResourceId
+                      glog)
 target_link_libraries(quickstep_transaction_StronglyConnectedComponents
                       quickstep_transaction_DirectedGraph
                       quickstep_utility_Macros)
+target_link_libraries(quickstep_transaction_TransactionTable
+                      quickstep_transaction_AccessMode
+                      quickstep_transaction_Lock
+                      quickstep_transaction_ResourceId
+                      quickstep_transaction_Transaction
+                      quickstep_utility_Macros)
 
 add_library(quickstep_transaction
             ../empty_src.cpp
             TransactionModule.hpp)
 target_link_libraries(quickstep_transaction
+                      quickstep_transaction_AccessMode
                       quickstep_transaction_DirectedGraph
+                      quickstep_transaction_Lock
+                      quickstep_transaction_LockRequest
+                      quickstep_transaction_LockTable
+                      quickstep_transaction_ResourceId
                       quickstep_transaction_StronglyConnectedComponents
-                      quickstep_transaction_Transaction)
+                      quickstep_transaction_Transaction
+                      quickstep_transaction_TransactionTable)
+
+add_executable(AccessMode_unittest
+               "${CMAKE_CURRENT_SOURCE_DIR}/tests/AccessMode_unittest.cpp")
+target_link_libraries(AccessMode_unittest
+                      gtest
+                      gtest_main
+                      quickstep_transaction_AccessMode)
+add_test(AccessMode_unittest AccessMode_unittest)
 
 add_executable(DirectedGraph_unittest
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/DirectedGraph_unittest.cpp")
@@ -48,6 +106,45 @@
                       quickstep_transaction_Transaction)
 add_test(DirectedGraph_unittest DirectedGraph_unittest)
 
+add_executable(Lock_unittest
+               "${CMAKE_CURRENT_SOURCE_DIR}/tests/Lock_unittest.cpp")
+target_link_libraries(Lock_unittest
+                      gtest
+                      gtest_main
+                      quickstep_transaction_AccessMode
+                      quickstep_transaction_Lock
+                      quickstep_transaction_ResourceId)
+add_test(Lock_unittest Lock_unittest)
+
+add_executable(LockRequest_unittest
+               "${CMAKE_CURRENT_SOURCE_DIR}/tests/LockRequest_unittest.cpp")
+target_link_libraries(LockRequest_unittest
+                      gtest
+                      gtest_main
+                      quickstep_transaction_AccessMode
+                      quickstep_transaction_ResourceId
+                      quickstep_transaction_Transaction)
+add_test(LockRequest_unittest LockRequest_unittest)
+
+add_executable(LockTable_unittest
+               "${CMAKE_CURRENT_SOURCE_DIR}/tests/LockTable_unittest.cpp")
+target_link_libraries(LockTable_unittest
+                      gtest
+                      gtest_main
+                      quickstep_transaction_AccessMode
+                      quickstep_transaction_LockTable
+                      quickstep_transaction_ResourceId
+                      quickstep_transaction_Transaction)
+add_test(LockTable_unittest LockTable_unittest)
+
+add_executable(ResourceId_unittest
+               "${CMAKE_CURRENT_SOURCE_DIR}/tests/ResourceId_unittest.cpp")
+target_link_libraries(ResourceId_unittest
+                      gtest
+                      gtest_main
+                      quickstep_transaction_ResourceId)
+add_test(ResourceId_unittest ResourceId_unittest)
+
 add_executable(StronglyConnectedComponents_unittest
                "${CMAKE_CURRENT_SOURCE_DIR}/tests/StronglyConnectedComponents_unittest.cpp")
 target_link_libraries(StronglyConnectedComponents_unittest
@@ -56,3 +153,14 @@
                       quickstep_transaction_DirectedGraph
                       quickstep_transaction_StronglyConnectedComponents)
 add_test(StronglyConnectedComponents_unittest StronglyConnectedComponents_unittest)
+
+add_executable(TransactionTable_unittest
+               "${CMAKE_CURRENT_SOURCE_DIR}/tests/TransactionTable_unittest.cpp")
+target_link_libraries(TransactionTable_unittest
+                      gtest
+                      gtest_main
+                      quickstep_transaction_AccessMode
+                      quickstep_transaction_ResourceId
+                      quickstep_transaction_Transaction
+                      quickstep_transaction_TransactionTable)
+add_test(TransactionTable_unittest TransactionTable_unittest)
diff --git a/transaction/DirectedGraph.hpp b/transaction/DirectedGraph.hpp
index 5c62425..89ce9c6 100644
--- a/transaction/DirectedGraph.hpp
+++ b/transaction/DirectedGraph.hpp
@@ -19,6 +19,8 @@
 #define QUICKSTEP_TRANSACTION_DIRECTED_GRAPH_HPP_
 
 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
 #include <memory>
 #include <stack>
 #include <unordered_set>
@@ -30,7 +32,6 @@
 #include "glog/logging.h"
 
 namespace quickstep {
-
 namespace transaction {
 
 /** \addtogroup Transaction
@@ -200,7 +201,6 @@
 /** @} */
 
 }  // namespace transaction
-
 }  // namespace quickstep
 
 #endif  // QUICKSTEP_TRANSACTION_DIRECTED_GRAPH_HPP_
diff --git a/transaction/Lock.hpp b/transaction/Lock.hpp
new file mode 100644
index 0000000..27fe93a
--- /dev/null
+++ b/transaction/Lock.hpp
@@ -0,0 +1,103 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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_TRANSACTION_LOCK_HPP_
+#define QUICKSTEP_TRANSACTION_LOCK_HPP_
+
+#include "transaction/AccessMode.hpp"
+#include "transaction/ResourceId.hpp"
+
+namespace quickstep {
+namespace transaction {
+
+/** \addtogroup Transaction
+ *  @{
+ */
+
+/**
+ * @brief Class for representing resource locks.
+ **/
+class Lock {
+ public:
+  /**
+   * @brief Constructor.
+   *
+   * @param rid Resource id of the resource on which the lock is taken.
+   * @param access_mode Mode of the lock access.
+   **/
+  Lock(const ResourceId &rid, const AccessMode &access_mode)
+      : rid_(rid),
+        access_mode_(access_mode) {
+  }
+
+  /**
+   * @brief Equality operator for lock.
+   *
+   * @param other Reference to the other Lock object that will be
+   *        compared against to this.
+   * @return True if both locks have equal resource ids
+   *         and access modes, false otherwise.
+   **/
+  inline bool operator==(const Lock &other) const {
+    return rid_ == other.rid_ && access_mode_ == other.access_mode_;
+  }
+
+  /**
+   * @brief Inequality operator for lock.
+   *
+   * @param other Reference to the other Lock object that will be
+   *        compared against to this.
+   * @return False if one of them has different resource id
+   *         or access mode, true otherwise.
+   **/
+  inline bool operator!=(const Lock &other) const {
+    return !(*this == other);
+  }
+
+  /**
+   * @brief Getter for resource id.
+   *
+   * @return Resource id of the lock.
+   **/
+  inline const ResourceId& getResourceId() const {
+    return rid_;
+  }
+
+  /**
+   * @brief Getter for access mode.
+   *
+   * @return Access mode of the lock.
+   **/
+  inline const AccessMode& getAccessMode() const {
+    return access_mode_;
+  }
+
+ private:
+  // Id of the resource that is locked.
+  const ResourceId rid_;
+
+  // Lock's access type.
+  AccessMode access_mode_;
+};
+
+/** @} */
+
+}  // namespace transaction
+
+}  // namespace quickstep
+
+#endif  // QUICKSTEP_TRANSACTION_LOCK_HPP_
diff --git a/transaction/LockRequest.hpp b/transaction/LockRequest.hpp
new file mode 100644
index 0000000..80daa4d
--- /dev/null
+++ b/transaction/LockRequest.hpp
@@ -0,0 +1,112 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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_TRANSACTION_LOCK_REQUEST_HPP_
+#define QUICKSTEP_TRANSACTION_LOCK_REQUEST_HPP_
+
+#include "transaction/AccessMode.hpp"
+#include "transaction/ResourceId.hpp"
+#include "transaction/Transaction.hpp"
+
+namespace quickstep {
+namespace transaction {
+
+/** \addtogroup Transaction
+ *  @{
+ */
+
+/**
+ * @brief Enum class for representing request types.
+ **/
+enum class RequestType {
+  kAcquireLock = 0,
+  kReleaseLocks,
+};
+
+/**
+ * @brief Class for encapsulate lock request put into
+ *        the buffers.
+ **/
+class LockRequest {
+ public:
+  /**
+   * @brief Constructor for LockRequest.
+   *
+   * @param tid Id of the transaction that requests the lock.
+   * @param rid Id of the resource that is requested.
+   * @param access_mode Access mode of the request.
+   * @param type Type of the request.
+   */
+  LockRequest(const transaction_id tid,
+              const ResourceId &rid,
+              const AccessMode access_mode,
+              const RequestType request_type)
+      : tid_(tid),
+        rid_(rid),
+        access_mode_(access_mode),
+        request_type_(request_type) {
+  }
+
+  /**
+   * @brief Getter for transaction id.
+   *
+   * @return Transaction id of the request.
+   **/
+  inline transaction_id getTransactionId() const {
+    return tid_;
+  }
+
+  /**
+   * @brief Getter for resource id.
+   *
+   * @return Resource id of the request.
+   **/
+  inline const ResourceId& getResourceId() const {
+    return rid_;
+  }
+
+  /**
+   * @brief Getter for access mode.
+   *
+   * @return Access mode of the request.
+   **/
+  inline AccessMode getAccessMode() const {
+    return access_mode_;
+  }
+
+  /**
+   * @brief Getter for request type.
+   *
+   * @return Type of the request.
+   **/
+  inline RequestType getRequestType() const {
+    return request_type_;
+  }
+
+ private:
+  transaction_id tid_;
+  ResourceId rid_;
+  AccessMode access_mode_;
+  RequestType request_type_;
+};
+
+/** @} */
+
+}  // namespace transaction
+}  // namespace quickstep
+
+#endif
diff --git a/transaction/LockTable.cpp b/transaction/LockTable.cpp
new file mode 100644
index 0000000..77986f6
--- /dev/null
+++ b/transaction/LockTable.cpp
@@ -0,0 +1,206 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/LockTable.hpp"
+
+#include <list>
+#include <unordered_map>
+#include <utility>
+
+#include "threading/SharedMutex.hpp"
+#include "transaction/AccessMode.hpp"
+#include "transaction/Lock.hpp"
+#include "transaction/ResourceId.hpp"
+#include "transaction/Transaction.hpp"
+#include "utility/Macros.hpp"
+
+namespace quickstep {
+namespace transaction {
+
+LockTableResult
+LockTable::putLock(const transaction_id tid,
+                   const ResourceId &rid,
+                   const AccessMode access_mode) {
+  // TODO(hakan): Lock upgrade is not supported.
+  lock_list_pair &lock_list_pair = internal_map_[rid];
+
+  // Each resource id entry has own list and pending list.
+  lock_own_list &lock_own_list = lock_list_pair.first;
+  lock_pending_list &lock_pending_list = lock_list_pair.second;
+
+  // Check this resource id already has the same lock request from
+  // the same transaction in the own list.
+  for (lock_own_list::const_iterator it = lock_own_list.cbegin();
+       it != lock_own_list.cend(); ++it) {
+    if (it->first == tid && it->second.getAccessMode() == access_mode) {
+      return LockTableResult::kALREADY_IN_OWNED;
+    }
+  }
+
+  // Check this resource id already has the same lock request from
+  // the same transaction in the pending list.
+  for (lock_pending_list::const_iterator it = lock_pending_list.cbegin();
+       it != lock_pending_list.cend(); ++it) {
+    if (it->first == tid && it->second.getAccessMode() == access_mode) {
+      return LockTableResult::kALREADY_IN_PENDING;
+    }
+  }
+
+  // If the execution can reach this point, it means the resource id
+  // does not have duplicate lock record (for both in owned and pending).
+  if (lock_pending_list.empty()) {
+    for (lock_own_list::const_iterator it = lock_own_list.cbegin();
+         it != lock_own_list.cend(); ++it) {
+      if (!access_mode.isCompatible(it->second.getAccessMode())) {
+        lock_pending_list.push_back(std::make_pair(tid,
+                                                   Lock(rid, access_mode)));
+        return LockTableResult::kPLACED_IN_PENDING;
+      }
+    }
+
+    lock_own_list.push_back(std::make_pair(tid, Lock(rid, access_mode)));
+    return LockTableResult::kPLACED_IN_OWNED;
+  } else {
+    // If the pending list is not empty, even if the lock request is compatible
+    // with other owned lock entries, we put the new request into the pending
+    // list to eliminate starvation.
+    lock_pending_list.push_back(std::make_pair(tid, Lock(rid, access_mode)));
+    return LockTableResult::kPLACED_IN_PENDING;
+  }
+}
+
+LockTableResult
+LockTable::deleteLock(const transaction_id tid,
+                      const ResourceId &rid) {
+  lock_list_pair &lock_list_pair = internal_map_[rid];
+
+  // Each resource id has its own and pending locks list.
+  lock_own_list &lock_own_list = lock_list_pair.first;
+  lock_pending_list &lock_pending_list = lock_list_pair.second;
+
+  // Iterate over owned locks list to see the lock entry of the transaction
+  // on the resource id exists.
+  for (lock_own_list::const_iterator it = lock_own_list.begin();
+       it != lock_own_list.cend(); ++it) {
+    if (it->first == tid) {
+      // If it exists, erase it from the owned list.
+      lock_own_list.erase(it);
+
+      // Since we erased a lock entry from owned list, the first entries
+      // in the pending list can be pushed to owned list if they are
+      // compatible with the remaining owned entries.
+      movePendingToOwned(rid);
+
+      return LockTableResult::kDEL_FROM_OWNED;
+    }
+  }
+
+  // Iterate over pending locks list to check the lock entry of the transaction
+  // on this resource id exists.
+  for (lock_pending_list::const_iterator it = lock_pending_list.begin();
+         it != lock_pending_list.cend(); ++it) {
+    if (it->first == tid) {
+      // If it exists, erase it from pending list.
+      lock_pending_list.erase(it);
+      return LockTableResult::kDEL_FROM_PENDING;
+    }
+  }
+
+  // Execution reaches here, if we cannot find the corresponding lock entry
+  // in the both list.
+  return LockTableResult::kDEL_ERROR;
+}
+
+void LockTable::movePendingToOwned(const ResourceId &rid) {
+  lock_list_pair &lock_list_pair = internal_map_[rid];
+  lock_own_list &lock_own_list = lock_list_pair.first;
+  lock_pending_list &lock_pending_list = lock_list_pair.second;
+
+  // Iterate over pending list to pending requests compatible with the
+  // all entries in the resource ids owned lock list.
+  for (lock_pending_list::const_iterator pending_it = lock_pending_list.cbegin();
+         pending_it != lock_pending_list.cend(); ++pending_it) {
+    transaction_id pending_tid = pending_it->first;
+    AccessMode pending_mode = pending_it->second.getAccessMode();
+    bool is_compatible_with_own_list = true;
+
+    // Now compare against the all entries in the owned lock list.
+    for (lock_own_list::const_iterator owned_it = lock_own_list.cbegin();
+           owned_it != lock_pending_list.cend(); ++owned_it) {
+      AccessMode owned_mode = owned_it->second.getAccessMode();
+      if (!pending_mode.isCompatible(owned_mode)) {
+        // If it is not compatible, we will not move this entry.
+        is_compatible_with_own_list = false;
+        break;
+      }
+    }
+
+    // If this pending lock entry is compatible with the all entries in the
+    // owned lock list, we should move it from pending list to owned list.
+    if (is_compatible_with_own_list) {
+      // Erase the entry from the list. Get the new iterator.
+      pending_it = lock_pending_list.erase(pending_it);
+
+      // Put the corresponding entry to the own list.
+      lock_own_list.emplace_back(pending_tid, Lock(rid, pending_mode));
+
+      // Move iterator one step backward because erasing an element moves the
+      // iterator to the next element.
+      --pending_it;
+    } else {
+      // There is no need to iterate pending list anymore since
+      // we found first incompatible one. Checking, and accepting other pending
+      // entries may cause starvation.
+      break;
+    }
+  }
+}
+
+LockTable::iterator LockTable::begin() {
+  return internal_map_.begin();
+}
+
+LockTable::iterator LockTable::end() {
+  return internal_map_.end();
+}
+
+LockTable::const_iterator LockTable::begin() const {
+  return internal_map_.begin();
+}
+
+LockTable::const_iterator LockTable::end() const {
+  return internal_map_.end();
+}
+
+void LockTable::latchShared() {
+  mutex_.lockShared();
+}
+
+void LockTable::unlatchShared() {
+  mutex_.unlockShared();
+}
+
+void LockTable::latchExclusive() {
+  mutex_.lock();
+}
+
+void LockTable::unlatchExclusive() {
+  mutex_.unlock();
+}
+
+}  // namespace transaction
+}  // namespace quickstep
diff --git a/transaction/LockTable.hpp b/transaction/LockTable.hpp
new file mode 100644
index 0000000..5a0612e
--- /dev/null
+++ b/transaction/LockTable.hpp
@@ -0,0 +1,179 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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_TRANSACTION_LOCK_TABLE_HPP_
+#define QUICKSTEP_TRANSACTION_LOCK_TABLE_HPP_
+
+#include <list>
+#include <unordered_map>
+#include <utility>
+
+#include "threading/SharedMutex.hpp"
+#include "transaction/AccessMode.hpp"
+#include "transaction/Lock.hpp"
+#include "transaction/ResourceId.hpp"
+#include "transaction/Transaction.hpp"
+#include "utility/Macros.hpp"
+
+namespace quickstep {
+namespace transaction {
+
+/** \addtogroup Transaction
+ * @{
+ */
+
+/**
+ * @brief Represents different results for LockTable's methods.
+ **/
+enum class LockTableResult {
+  kPLACED_IN_OWNED = 0,
+  kPLACED_IN_PENDING,
+  kALREADY_IN_OWNED,
+  kALREADY_IN_PENDING,
+  kDEL_FROM_OWNED,
+  kDEL_FROM_PENDING,
+  kDEL_ERROR,
+  kPUT_ERROR,
+};
+
+/**
+ * @brief LockTable class represents the hash map for RID and
+ *        list of locks on RID.
+ **/
+class LockTable {
+ public:
+  typedef std::pair<transaction_id, Lock> lock_entry;
+  typedef std::list<lock_entry> lock_own_list;
+  typedef std::list<lock_entry> lock_pending_list;
+  typedef std::pair<lock_own_list, lock_pending_list> lock_list_pair;
+  typedef std::unordered_map<ResourceId,
+                             lock_list_pair,
+                             ResourceId::ResourceIdHasher> internal_map_type;
+  typedef internal_map_type::iterator iterator;
+  typedef internal_map_type::const_iterator const_iterator;
+
+  /**
+   * @brief Constructor for LockTable.
+   **/
+  LockTable() {
+  }
+
+  /**
+   * @brief Puts the lock entry into the lock table for corresponding resource.
+   *
+   * @param tid Id of the transaction that requests the lock.
+   * @param rid Id of the resource to be locked.
+   * @param access_mode Access mode of the lock.
+   *
+   * @return LockTableResult::kPLACED_IN_OWNED if lock is granted,
+   *         LockTableResult::kPLACED_IN_PENDING if lock is not granted,
+   *         LockTableResult::kALREADY_IN_OWNED if lock has been
+   *         already granted,
+   *         LockTableResult::kALREADY_IN_PENDING if lock has been
+   *         already pending.
+   **/
+  LockTableResult putLock(const transaction_id tid,
+                          const ResourceId &rid,
+                          const AccessMode access_mode);
+  /**
+   * @brief Deletes the lock entry.
+   *
+   * @param tid Id of the transaction that owns or awaits.
+   * @param rid Id of resource that the lock covers.
+   *
+   * @return LockTableResult::kDEL_FROM_OWNED if the lock is deleted from
+   *         owned list,
+   *         LockTableResult::kDEL_FROM_PENDING if the lock is deleted from
+   *         pending list,
+   *         LockTableResult::kDEL_ERROR if the lock cannot be found
+   **/
+  LockTableResult deleteLock(const transaction_id tid,
+                             const ResourceId &rid);
+
+
+  /**
+   * @brief Iterator for begin position.
+   *
+   * @return Non-const Iterator which points to begin point
+   *         of the lock table.
+   **/
+  iterator begin();
+
+  /**
+   * @brief Iterator for end position.
+   *
+   * @return Non-const iterator which points to end point
+   *         of the lock table.
+   **/
+  iterator end();
+
+  /**
+   * @brief Iterator for begin position.
+   *
+   * @return Const iterator which points to the begin
+   *         point of the lock table.
+   **/
+  const_iterator begin() const;
+
+  /**
+   * @brief Iterator for end position.
+   *
+   * @return Const iterator which points to the end
+   *         point of the lock table.
+   **/
+  const_iterator end() const;
+
+  /**
+   * @brief Latch mutex in shared mode. Multiple shared mode
+   *        latch acquisition is compatible.
+   **/
+  void latchShared();
+
+  /**
+   * @brief Unlatch mutex in shared mode.
+   **/
+  void unlatchShared();
+
+  /**
+   * @brief Latch mutex in exclusive mode.
+   */
+  void latchExclusive();
+
+  /**
+   * @brief Unlatch mutex in exclusive mode.
+   */
+  void unlatchExclusive();
+
+ private:
+  // This method will be called after deletion of locks.
+  // After delete, some pending locks might be acquired.
+  void movePendingToOwned(const ResourceId &rid);
+
+  internal_map_type internal_map_;
+
+  // Mutex protects whole lock table.
+  SharedMutex mutex_;
+
+  DISALLOW_COPY_AND_ASSIGN(LockTable);
+};
+
+/** @} */
+
+}  // namespace transaction
+}  // namespace quickstep
+
+#endif
diff --git a/transaction/ResourceId.cpp b/transaction/ResourceId.cpp
new file mode 100644
index 0000000..bae92f8
--- /dev/null
+++ b/transaction/ResourceId.cpp
@@ -0,0 +1,74 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/ResourceId.hpp"
+
+#include <cstddef>
+#include <functional>
+#include <string>
+
+#include "catalog/CatalogTypedefs.hpp"
+#include "storage/StorageBlockInfo.hpp"
+#include "utility/HashPair.hpp"
+
+#include "glog/logging.h"
+
+namespace quickstep {
+namespace transaction {
+
+bool ResourceId::operator==(const ResourceId &other) const {
+  return db_id_ == other.db_id_
+      && rel_id_ == other.rel_id_
+      && block_id_ == other.block_id_
+      && tuple_id_ == other.tuple_id_;
+}
+
+ResourceId ResourceId::getParentResourceId() const {
+  if (isRelationAccess()) {
+    return ResourceId(db_id_);
+  } else if (isBlockAccess()) {
+    return ResourceId(db_id_, rel_id_);
+  } else if (isTupleAccess()) {
+    return ResourceId(db_id_, rel_id_, block_id_);
+  } else {
+    LOG(FATAL) << "Database level does not have any parent level.";
+  }
+}
+
+std::string ResourceId::toString() const {
+  return "ResourceId(" +
+    std::to_string(db_id_) + ", " +
+    std::to_string(rel_id_) + ", " +
+    std::to_string(block_id_) + ", " +
+    std::to_string(tuple_id_) + ")";
+}
+
+std::size_t
+ResourceId::ResourceIdHasher::operator()(const ResourceId &rid) const {
+  const std::size_t hash1 = std::hash<database_id>()(rid.db_id_);
+  const std::size_t hash2 = std::hash<relation_id>()(rid.rel_id_);
+  const std::size_t hash3 = std::hash<block_id>()(rid.block_id_);
+  const std::size_t hash4 = std::hash<tuple_id>()(rid.tuple_id_);
+
+  const std::size_t comb1 = CombineHashes(hash1, hash2);
+  const std::size_t comb2 = CombineHashes(hash3, hash4);
+
+  return CombineHashes(comb1, comb2);
+}
+
+}  // namespace transaction
+}  // namespace quickstep
diff --git a/transaction/ResourceId.hpp b/transaction/ResourceId.hpp
new file mode 100644
index 0000000..b9d1cdf
--- /dev/null
+++ b/transaction/ResourceId.hpp
@@ -0,0 +1,216 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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_TRANSACTION_RESOURCE_ID_HPP_
+#define QUICKSTEP_TRANSACTION_RESOURCE_ID_HPP_
+
+#include <cstddef>
+#include <limits>
+#include <string>
+
+#include "catalog/CatalogTypedefs.hpp"
+#include "storage/StorageBlockInfo.hpp"
+
+namespace quickstep {
+namespace transaction {
+
+/** \addtogroup Transaction
+ *  @{
+ */
+
+/**
+ * @brief Class for representing unique id for each database resource
+ *        e.g Tuple, block, relation, database etc...
+ **/
+class ResourceId {
+ public:
+  /**
+   * @brief Constructor
+   *
+   * @param db_id Unique id of the database resource.
+   * @param rel_id Unique id of the relation resource in the database.
+   * @param block_id Unique id of the block resource in the relation.
+   * @param tuple_id Unique id of the tuple resource in the block.
+   **/
+  explicit ResourceId(const database_id db_id = kDatabaseIdPlaceholder,
+                      const relation_id rel_id = kRelationIdPlaceholder,
+                      const block_id block_id = kBlockIdPlaceholder,
+                      const tuple_id tuple_id = kTupleIdPlaceholder)
+      : db_id_(db_id),
+        rel_id_(rel_id),
+        block_id_(block_id),
+        tuple_id_(tuple_id) {
+  }
+
+  /**
+   * @brief Copy constructor.
+   *
+   * @param other The ResourceId that will be copied.
+   **/
+  ResourceId(const ResourceId &other)
+      : db_id_(other.db_id_),
+        rel_id_(other.rel_id_),
+        block_id_(other.block_id_),
+        tuple_id_(other.tuple_id_) {
+  }
+
+  /**
+   * @brief Hasher class for ResourceId class to use it in the hash map.
+   **/
+  struct ResourceIdHasher {
+    /**
+     * @brief Functor of the class.
+     *
+     * @param rid Resource id to be hashed.
+     * @return Hash of the resource id.
+     **/
+    std::size_t operator()(const ResourceId &rid) const;
+  };
+
+  /**
+   * @brief Equality operator for ResourceId class.
+   *
+   * @param other Resource to be compared.
+   * @return True if this and other are the id of the same
+   *         resource, false otherwise.
+   **/
+  bool operator==(const ResourceId &other) const;
+
+   /**
+   * @brief Inequality operator for ResourceId class.
+   *
+   * @param other Resource to be compared.
+   * @return True if this and other are the ids of the different
+   *         resources, false otherwise.
+   **/
+  inline bool operator!=(const ResourceId &other) const {
+    return !(*this == other);
+  }
+
+  /**
+   * @brief Checks whether this resource id has a parent in resource hierarchy.
+   *
+   * @return False if this resource id is database level, true otherwise.
+   **/
+  inline bool hasParent() const {
+    return !isDatabaseAccess();
+  }
+
+  /**
+   * @brief Getter for this resource id's parent in the hierarchy.
+   *
+   * @return The resource id of this resource id's parent.
+   **/
+  ResourceId getParentResourceId() const;
+
+  /**
+   * @brief Checks whether this is a database level resource id.
+   *
+   * @return True if this is a database level access, false otherwise.
+   **/
+  inline bool isDatabaseAccess() const {
+    return !isDatabaseIdPlaceholder()
+        && isRelationIdPlaceholder()
+        && isBlockIdPlaceholder()
+        && isTupleIdPlaceholder();
+  }
+
+  /**
+   * @brief Checks whether this is a relation level resource id.
+   *
+   * @return True if this is a relation level access, false otherwise.
+   **/
+  bool isRelationAccess() const {
+    return !isDatabaseIdPlaceholder()
+        && !isRelationIdPlaceholder()
+        && isBlockIdPlaceholder()
+        && isTupleIdPlaceholder();
+  }
+
+  /**
+   * @brief Checks whether this is a block level resource id.
+   *
+   * @return True if this is a block level access, false otherwise.
+   **/
+  bool isBlockAccess() const {
+    return !isDatabaseIdPlaceholder()
+        && !isRelationIdPlaceholder()
+        && !isBlockIdPlaceholder()
+        && isTupleIdPlaceholder();
+  }
+
+  /**
+   * @brief Checks whether this is a tuple level resource id.
+   *
+   * @return True if this is a tuple level access, false otherwise.
+   **/
+  bool isTupleAccess() const {
+    return !isDatabaseIdPlaceholder()
+        && !isRelationIdPlaceholder()
+        && !isBlockIdPlaceholder()
+        && !isTupleIdPlaceholder();
+  }
+
+  /**
+   * @brief This is a helper method for string representation
+   *        of the resource id.
+   *
+   * @return String representation of the reosurce id.
+   **/
+  std::string toString() const;
+
+ private:
+  // Negative value is invalid id for database id. Use -1 as placeholder.
+  static constexpr database_id kDatabaseIdPlaceholder = kInvalidCatalogId;
+
+  // Negative value is invalid id for relation id. Use -1 as placeholder.
+  static constexpr relation_id kRelationIdPlaceholder = kInvalidCatalogId;
+
+  // Zero is invalid id for block id. Use zero as the placeholder.
+  static constexpr block_id kBlockIdPlaceholder = kInvalidBlockId;
+
+  // Negative tuple id os invalid, therefore use a negative value.
+  static constexpr tuple_id kTupleIdPlaceholder = kInvalidCatalogId;
+
+  inline bool isDatabaseIdPlaceholder() const {
+    return db_id_ == kDatabaseIdPlaceholder;
+  }
+
+  inline bool isRelationIdPlaceholder() const {
+    return rel_id_ == kRelationIdPlaceholder;
+  }
+
+  inline bool isBlockIdPlaceholder() const {
+    return block_id_ == kBlockIdPlaceholder;
+  }
+
+  inline bool isTupleIdPlaceholder() const {
+    return tuple_id_ == kTupleIdPlaceholder;
+  }
+
+  const database_id db_id_;
+  const relation_id rel_id_;
+  const block_id block_id_;
+  const tuple_id tuple_id_;
+};
+
+/** @} */
+
+}  // namespace transaction
+}  // namespace quickstep
+
+#endif  // QUICKSTEP_RESOURCE_ID_HPP_
diff --git a/transaction/StronglyConnectedComponents.cpp b/transaction/StronglyConnectedComponents.cpp
index 76da4bc..89daf46 100644
--- a/transaction/StronglyConnectedComponents.cpp
+++ b/transaction/StronglyConnectedComponents.cpp
@@ -17,13 +17,15 @@
 
 #include "transaction/StronglyConnectedComponents.hpp"
 
+#include <cstddef>
 #include <cstdint>
 #include <stack>
 #include <unordered_map>
 #include <vector>
 
-namespace quickstep {
+#include "transaction/DirectedGraph.hpp"
 
+namespace quickstep {
 namespace transaction {
 
 StronglyConnectedComponents::StronglyConnectedComponents(
@@ -118,5 +120,4 @@
 }
 
 }  // namespace transaction
-
 }  // namespace quickstep
diff --git a/transaction/StronglyConnectedComponents.hpp b/transaction/StronglyConnectedComponents.hpp
index 57a8d59..ca58a68 100644
--- a/transaction/StronglyConnectedComponents.hpp
+++ b/transaction/StronglyConnectedComponents.hpp
@@ -28,7 +28,6 @@
 #include "utility/Macros.hpp"
 
 namespace quickstep {
-
 namespace transaction {
 
 /** \addtogroup Transaction
@@ -115,7 +114,6 @@
 /** @} */
 
 }  // namespace transaction
-
 }  // namespace quickstep
 
 #endif  // QUICKSTEP_TRANSACTION_STRONGLY_CONNECTED_COMPONENTS_HPP_
diff --git a/transaction/Transaction.cpp b/transaction/Transaction.cpp
new file mode 100644
index 0000000..3478d01
--- /dev/null
+++ b/transaction/Transaction.cpp
@@ -0,0 +1,48 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/Transaction.hpp"
+
+#include <functional>
+
+namespace quickstep {
+
+namespace transaction {
+
+TransactionId Transaction::getTransactionId() const {
+  return tid_;
+}
+
+void Transaction::setStatus(TransactionStatus status) {
+  status_ = status;
+}
+
+TransactionStatus Transaction::getStatus() const {
+  return status_;
+}
+
+bool Transaction::operator==(const Transaction &other) const {
+  return tid_ == other.tid_;
+}
+
+std::size_t Transaction::TransactionHasher::operator()(const Transaction &transaction) const {
+  return std::hash<TransactionId>()(transaction.tid_);
+}
+
+}  // namespace transaction
+
+}  // namespace quickstep
diff --git a/transaction/Transaction.hpp b/transaction/Transaction.hpp
index 82ca436..69d4311 100644
--- a/transaction/Transaction.hpp
+++ b/transaction/Transaction.hpp
@@ -23,7 +23,6 @@
 #include <functional>
 
 namespace quickstep {
-
 namespace transaction {
 
 /** \addtogroup Transaction
@@ -115,7 +114,6 @@
 /** @} */
 
 }  // namespace transaction
-
 }  // namespace quickstep
 
 #endif  // QUICKSTEP_TRANSACTION_TRANSACTION_HPP_
diff --git a/transaction/TransactionTable.cpp b/transaction/TransactionTable.cpp
new file mode 100644
index 0000000..993703a
--- /dev/null
+++ b/transaction/TransactionTable.cpp
@@ -0,0 +1,140 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/TransactionTable.hpp"
+
+#include <cstddef>
+#include <list>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "transaction/AccessMode.hpp"
+#include "transaction/ResourceId.hpp"
+#include "transaction/Transaction.hpp"
+
+namespace quickstep {
+namespace transaction {
+
+TransactionTableResult
+TransactionTable::putOwnEntry(const transaction_id tid,
+                              const ResourceId &rid,
+                              const AccessMode access_mode) {
+  transaction_list_pair &transaction_list_pair = internal_map_[tid];
+  transaction_own_list &transaction_own_list = transaction_list_pair.first;
+
+  transaction_own_list.push_back(std::make_pair(rid, Lock(rid, access_mode)));
+
+  return TransactionTableResult::kPlacedInOwned;
+}
+
+TransactionTableResult
+TransactionTable::putPendingEntry(const transaction_id tid,
+                                  const ResourceId &rid,
+                                  const AccessMode access_mode) {
+  transaction_list_pair &transaction_list_pair = internal_map_[tid];
+  transaction_pending_list &transaction_pending_list
+      = transaction_list_pair.second;
+
+  transaction_pending_list.push_back(std::make_pair(rid,
+                                                    Lock(rid, access_mode)));
+
+  return TransactionTableResult::kPlacedInPending;
+}
+
+TransactionTableResult
+TransactionTable::deleteOwnEntry(const transaction_id tid,
+                                 const ResourceId &rid,
+                                 const AccessMode access_mode) {
+  transaction_list_pair &transaction_list_pair = internal_map_[tid];
+  transaction_own_list &transaction_own_list = transaction_list_pair.first;
+
+  std::size_t original_size = transaction_own_list.size();
+  transaction_own_list.remove_if(
+      [&rid, &access_mode](transaction_entry &entry) {
+        return entry.second.getResourceId() == rid
+        && entry.second.getAccessMode() == access_mode;
+      });
+  if (transaction_own_list.size() == original_size) {
+    return TransactionTableResult::kDelError;
+  } else {
+    return TransactionTableResult::kDelFromOwned;
+  }
+}
+
+TransactionTableResult
+TransactionTable::deletePendingEntry(const transaction_id tid,
+                                     const ResourceId &rid,
+                                     const AccessMode access_mode) {
+  transaction_list_pair &transaction_list_pair = internal_map_[tid];
+  transaction_pending_list &transaction_pending_list
+      = transaction_list_pair.second;
+
+  std::size_t original_size = transaction_pending_list.size();
+  transaction_pending_list.remove_if(
+     [&rid, &access_mode] (transaction_entry &entry) {
+       return entry.second.getResourceId() == rid
+         && entry.second.getAccessMode() == access_mode;
+     });
+
+  if (transaction_pending_list.size() == original_size) {
+    return TransactionTableResult::kDelError;
+  } else {
+    return TransactionTableResult::kDelFromPending;
+  }
+}
+
+std::vector<ResourceId>
+TransactionTable::getResourceIdList(const transaction_id tid) {
+  std::vector<ResourceId> result;
+  const transaction_list_pair &transaction_list_pair = internal_map_[tid];
+  const transaction_own_list &transaction_own_list =
+      transaction_list_pair.second;
+  const transaction_pending_list
+      &transaction_pending_list = transaction_list_pair.first;
+
+  for (transaction_own_list::const_iterator it = transaction_own_list.begin();
+       it != transaction_own_list.end();
+       ++it) {
+    result.push_back(it->first);
+  }
+
+  for (transaction_pending_list::const_iterator
+           it = transaction_pending_list.begin();
+       it != transaction_pending_list.end();
+       ++it) {
+    result.push_back(it->first);
+  }
+
+  return result;
+}
+
+TransactionTableResult
+TransactionTable::deleteTransaction(const transaction_id tid) {
+  std::size_t original_size = internal_map_.size();
+  internal_map_.erase(tid);
+  std::size_t size_after_delete = internal_map_.size();
+
+  if (original_size == size_after_delete) {
+    return  TransactionTableResult::kTransactionDeleteError;
+  }
+
+  return TransactionTableResult::kTransactionDeleteOk;
+}
+
+}  // namespace transaction
+}  // namespace quickstep
diff --git a/transaction/TransactionTable.hpp b/transaction/TransactionTable.hpp
new file mode 100644
index 0000000..a5e1da4
--- /dev/null
+++ b/transaction/TransactionTable.hpp
@@ -0,0 +1,161 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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_TRANSACTION_TRANSACTION_TABLE_HPP_
+#define QUICKSTEP_TRANSACTION_TRANSACTION_TABLE_HPP_
+
+#include <list>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "transaction/AccessMode.hpp"
+#include "transaction/Lock.hpp"
+#include "transaction/ResourceId.hpp"
+#include "transaction/Transaction.hpp"
+#include "utility/Macros.hpp"
+
+namespace quickstep {
+namespace transaction {
+
+/** \addtogroup Transaction
+ *  @{
+ */
+
+/**
+ * @brief Represents different result for TransactionTable's methods.
+ **/
+enum class TransactionTableResult {
+  kPlacedInOwned = 0,
+  kPlacedInPending,
+  kAlreadyInOwned,
+  kAlreadyInPending,
+  kDelFromOwned,
+  kDelFromPending,
+  kDelError,
+  kTransactionDeleteOk,
+  kTransactionDeleteError,
+};
+
+/**
+ * @brief Class for keeping track of the owner and pending list of transactions.
+ **/
+class TransactionTable {
+ public:
+  typedef std::pair<ResourceId, Lock> transaction_entry;
+  typedef std::list<transaction_entry> transaction_own_list;
+  typedef std::list<transaction_entry> transaction_pending_list;
+  typedef std::pair<transaction_own_list, transaction_pending_list>
+      transaction_list_pair;
+
+  /**
+   * @brief Contructor for TransactionTable.
+   **/
+  TransactionTable() {
+  }
+
+  /**
+   * @brief Puts a owned entry of the given resource id in the given
+   *        transaction's owned list.
+   *
+   * @param tid Transaction id of the requestor.
+   * @param rid Resource id of the corresponding lock.
+   * @param access_mode Access mode of the lock.
+   *
+   * @return TransactionTableResult::kPLACED_IN_OWNED since it is
+   *         always a successful operation on owned list.
+   **/
+  TransactionTableResult putOwnEntry(const transaction_id tid,
+                                     const ResourceId &rid,
+                                     const AccessMode access_mode);
+
+  /**
+   * @brief Puts a pending entry of the given resource id in the given
+   *        transaction's pending list.
+   *
+   * @param tid Transaction id of the requestor.
+   * @param rid Resource id of the corresponding lock.
+   * @param access_mode Access mode of the lock.
+   *
+   * @return TransactionTableResult::kPLACED_IN_PENDING
+   **/
+  TransactionTableResult putPendingEntry(const transaction_id tid,
+                                         const ResourceId &rid,
+                                         const AccessMode access_mode);
+
+  /**
+   * @brief Deletes the owned entry corresponding to the resource id
+   *        in the transaction's owned list.
+   *
+   * @param tid Transaction id of the owner.
+   * @param rid Resource id of the corresponding lock.
+   * @param access_mode Access mode of the lock.
+   *
+   * @return TransactionTableResult::kDEL_FROM_OWNED if the entry is deleted,
+   *         otherwise TransactionTable::kDEL_ERROR.
+   **/
+  TransactionTableResult deleteOwnEntry(const transaction_id tid,
+                                        const ResourceId &rid,
+                                        const AccessMode access_mode);
+
+  /**
+   * @brief Deletes the pending entry corresponding to the resource id
+   *        in the transaction's pending list.
+   * @param tid Transaction id of the owner.
+   * @param rid Resource id of the corresponding lock.
+   * @param access_mode Access mode of the lock.
+   *
+   * @return TransactionTableResult::kDEL_FROM_PENDING if the entry is
+   *         successfuly deleted, otherwise TransactionTableResult::k_DEL_ERROR.
+   **/
+  TransactionTableResult deletePendingEntry(const transaction_id tid,
+                                            const ResourceId &rid,
+                                            const AccessMode access_mode);
+
+  /**
+   * @brief Returns a vector of resource ids which the corresponding transaction
+   *        owns or pends.
+   *
+   * @param tid Transaction id of the corresponding transaction
+   *
+   * @return Vector of resource id that the transaction owns or pends.
+   **/
+  std::vector<ResourceId> getResourceIdList(const transaction_id tid);
+
+  /**
+   * @brief Deletes the transaction entry from transaction table.
+   *
+   * @param tid Transaction id of the corresponding transaction.
+   *
+   * @return TransactionTableResult::kTRANSACTION_DELETE_ERROR if there is no
+   *         entry for the transaction, otherwise
+   *         TransactionTableResult::kTRANSACTION_DELETE_OK.
+   **/
+  TransactionTableResult deleteTransaction(const transaction_id tid);
+
+ private:
+  std::unordered_map<transaction_id, transaction_list_pair> internal_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(TransactionTable);
+};
+
+/** @} */
+
+}  // namespace transaction
+}  // namespace quickstep
+
+#endif
diff --git a/transaction/tests/AccessMode_unittest.cpp b/transaction/tests/AccessMode_unittest.cpp
new file mode 100644
index 0000000..fa51525
--- /dev/null
+++ b/transaction/tests/AccessMode_unittest.cpp
@@ -0,0 +1,171 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/AccessMode.hpp"
+
+#include "gtest/gtest.h"
+
+namespace quickstep {
+namespace transaction {
+
+class AccessModeTest : public ::testing::Test {
+ protected:
+  AccessModeTest()
+      : nl_mode_(AccessModeType::kNoLock),
+        is_mode_(AccessModeType::kIsLock),
+        ix_mode_(AccessModeType::kIxLock),
+        s_mode_(AccessModeType::kSLock),
+        six_mode_(AccessModeType::kSixLock),
+        x_mode_(AccessModeType::kXLock) {
+  }
+
+  const AccessMode nl_mode_;
+  const AccessMode is_mode_;
+  const AccessMode ix_mode_;
+  const AccessMode s_mode_;
+  const AccessMode six_mode_;
+  const AccessMode x_mode_;
+};
+
+TEST_F(AccessModeTest, ModeCompatibilty) {
+  EXPECT_TRUE(nl_mode_.isCompatible(nl_mode_));
+  EXPECT_TRUE(nl_mode_.isCompatible(is_mode_));
+  EXPECT_TRUE(nl_mode_.isCompatible(ix_mode_));
+  EXPECT_TRUE(nl_mode_.isCompatible(s_mode_));
+  EXPECT_TRUE(nl_mode_.isCompatible(six_mode_));
+  EXPECT_TRUE(nl_mode_.isCompatible(x_mode_));
+
+  EXPECT_TRUE(is_mode_.isCompatible(nl_mode_));
+  EXPECT_TRUE(is_mode_.isCompatible(is_mode_));
+  EXPECT_TRUE(is_mode_.isCompatible(ix_mode_));
+  EXPECT_TRUE(is_mode_.isCompatible(s_mode_));
+  EXPECT_TRUE(is_mode_.isCompatible(six_mode_));
+  EXPECT_FALSE(is_mode_.isCompatible(x_mode_));
+
+  EXPECT_TRUE(ix_mode_.isCompatible(nl_mode_));
+  EXPECT_TRUE(ix_mode_.isCompatible(is_mode_));
+  EXPECT_TRUE(ix_mode_.isCompatible(ix_mode_));
+  EXPECT_FALSE(ix_mode_.isCompatible(s_mode_));
+  EXPECT_FALSE(ix_mode_.isCompatible(six_mode_));
+  EXPECT_FALSE(ix_mode_.isCompatible(x_mode_));
+
+  EXPECT_TRUE(s_mode_.isCompatible(nl_mode_));
+  EXPECT_TRUE(s_mode_.isCompatible(is_mode_));
+  EXPECT_FALSE(s_mode_.isCompatible(ix_mode_));
+  EXPECT_TRUE(s_mode_.isCompatible(s_mode_));
+  EXPECT_FALSE(s_mode_.isCompatible(six_mode_));
+  EXPECT_FALSE(s_mode_.isCompatible(x_mode_));
+
+  EXPECT_TRUE(six_mode_.isCompatible(nl_mode_));
+  EXPECT_TRUE(six_mode_.isCompatible(is_mode_));
+  EXPECT_FALSE(six_mode_.isCompatible(ix_mode_));
+  EXPECT_FALSE(six_mode_.isCompatible(s_mode_));
+  EXPECT_FALSE(six_mode_.isCompatible(six_mode_));
+  EXPECT_FALSE(six_mode_.isCompatible(x_mode_));
+
+  EXPECT_TRUE(x_mode_.isCompatible(nl_mode_));
+  EXPECT_FALSE(x_mode_.isCompatible(is_mode_));
+  EXPECT_FALSE(x_mode_.isCompatible(ix_mode_));
+  EXPECT_FALSE(x_mode_.isCompatible(s_mode_));
+  EXPECT_FALSE(x_mode_.isCompatible(six_mode_));
+  EXPECT_FALSE(x_mode_.isCompatible(x_mode_));
+}
+
+TEST_F(AccessModeTest, ModeQueryChecks) {
+  EXPECT_FALSE(nl_mode_.isIntentionShareLock());
+  EXPECT_FALSE(nl_mode_.isIntentionExclusiveLock());
+  EXPECT_FALSE(nl_mode_.isShareLock());
+  EXPECT_FALSE(nl_mode_.isShareAndIntentionExclusiveLock());
+  EXPECT_FALSE(nl_mode_.isExclusiveLock());
+
+  EXPECT_TRUE(is_mode_.isIntentionShareLock());
+  EXPECT_FALSE(is_mode_.isIntentionExclusiveLock());
+  EXPECT_FALSE(is_mode_.isShareLock());
+  EXPECT_FALSE(is_mode_.isShareAndIntentionExclusiveLock());
+  EXPECT_FALSE(is_mode_.isExclusiveLock());
+
+  EXPECT_FALSE(ix_mode_.isIntentionShareLock());
+  EXPECT_TRUE(ix_mode_.isIntentionExclusiveLock());
+  EXPECT_FALSE(ix_mode_.isShareLock());
+  EXPECT_FALSE(ix_mode_.isShareAndIntentionExclusiveLock());
+  EXPECT_FALSE(ix_mode_.isExclusiveLock());
+
+  EXPECT_FALSE(s_mode_.isIntentionShareLock());
+  EXPECT_FALSE(s_mode_.isIntentionExclusiveLock());
+  EXPECT_TRUE(s_mode_.isShareLock());
+  EXPECT_FALSE(s_mode_.isShareAndIntentionExclusiveLock());
+  EXPECT_FALSE(s_mode_.isExclusiveLock());
+
+  EXPECT_FALSE(six_mode_.isIntentionShareLock());
+  EXPECT_FALSE(six_mode_.isIntentionExclusiveLock());
+  EXPECT_FALSE(six_mode_.isShareLock());
+  EXPECT_TRUE(six_mode_.isShareAndIntentionExclusiveLock());
+  EXPECT_FALSE(six_mode_.isExclusiveLock());
+
+  EXPECT_FALSE(x_mode_.isIntentionShareLock());
+  EXPECT_FALSE(x_mode_.isIntentionExclusiveLock());
+  EXPECT_FALSE(x_mode_.isShareLock());
+  EXPECT_FALSE(x_mode_.isShareAndIntentionExclusiveLock());
+  EXPECT_TRUE(x_mode_.isExclusiveLock());
+}
+
+TEST_F(AccessModeTest, Equality) {
+  EXPECT_EQ(nl_mode_, nl_mode_);
+  EXPECT_NE(nl_mode_, is_mode_);
+  EXPECT_NE(nl_mode_, ix_mode_);
+  EXPECT_NE(nl_mode_, s_mode_);
+  EXPECT_NE(nl_mode_, six_mode_);
+  EXPECT_NE(nl_mode_, x_mode_);
+
+  EXPECT_NE(is_mode_, nl_mode_);
+  EXPECT_EQ(is_mode_, is_mode_);
+  EXPECT_NE(is_mode_, ix_mode_);
+  EXPECT_NE(is_mode_, s_mode_);
+  EXPECT_NE(is_mode_, six_mode_);
+  EXPECT_NE(is_mode_, x_mode_);
+
+  EXPECT_NE(ix_mode_, nl_mode_);
+  EXPECT_NE(ix_mode_, is_mode_);
+  EXPECT_EQ(ix_mode_, ix_mode_);
+  EXPECT_NE(ix_mode_, s_mode_);
+  EXPECT_NE(ix_mode_, six_mode_);
+  EXPECT_NE(ix_mode_, x_mode_);
+
+  EXPECT_NE(s_mode_, nl_mode_);
+  EXPECT_NE(s_mode_, is_mode_);
+  EXPECT_NE(s_mode_, ix_mode_);
+  EXPECT_EQ(s_mode_, s_mode_);
+  EXPECT_NE(s_mode_, six_mode_);
+  EXPECT_NE(s_mode_, x_mode_);
+
+  EXPECT_NE(six_mode_, nl_mode_);
+  EXPECT_NE(six_mode_, is_mode_);
+  EXPECT_NE(six_mode_, ix_mode_);
+  EXPECT_NE(six_mode_, s_mode_);
+  EXPECT_EQ(six_mode_, six_mode_);
+  EXPECT_NE(six_mode_, x_mode_);
+
+  EXPECT_NE(x_mode_, nl_mode_);
+  EXPECT_NE(x_mode_, is_mode_);
+  EXPECT_NE(x_mode_, ix_mode_);
+  EXPECT_NE(x_mode_, s_mode_);
+  EXPECT_NE(x_mode_, six_mode_);
+  EXPECT_EQ(x_mode_, x_mode_);
+}
+
+}  // namespace transaction
+}  // namespace quickstep
diff --git a/transaction/tests/DirectedGraph_unittest.cpp b/transaction/tests/DirectedGraph_unittest.cpp
index 2f43642..43ad972 100644
--- a/transaction/tests/DirectedGraph_unittest.cpp
+++ b/transaction/tests/DirectedGraph_unittest.cpp
@@ -24,7 +24,6 @@
 #include "gtest/gtest.h"
 
 namespace quickstep {
-
 namespace transaction {
 
 TEST(DirectedGraphTest, AddNode) {
@@ -127,5 +126,4 @@
 }
 
 }  // namespace transaction
-
 }  // namespace quickstep
diff --git a/transaction/tests/LockRequest_unittest.cpp b/transaction/tests/LockRequest_unittest.cpp
new file mode 100644
index 0000000..0e4138a
--- /dev/null
+++ b/transaction/tests/LockRequest_unittest.cpp
@@ -0,0 +1,49 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/LockRequest.hpp"
+
+#include "transaction/AccessMode.hpp"
+#include "transaction/ResourceId.hpp"
+#include "transaction/Transaction.hpp"
+
+#include "gtest/gtest.h"
+
+namespace quickstep {
+namespace transaction {
+
+class LockRequestTest : public ::testing::Test {
+ protected:
+  LockRequestTest()
+      : lock_request_(transaction_id(3),
+                      ResourceId(5),
+                      AccessMode(AccessModeType::kSLock),
+                      RequestType::kAcquireLock) {
+  }
+
+  const LockRequest lock_request_;
+};
+
+TEST_F(LockRequestTest, CheckGetters) {
+  EXPECT_EQ(transaction_id(3), lock_request_.getTransactionId());
+  EXPECT_EQ(ResourceId(5), lock_request_.getResourceId());
+  EXPECT_EQ(AccessMode(AccessModeType::kSLock), lock_request_.getAccessMode());
+  EXPECT_EQ(RequestType::kAcquireLock, lock_request_.getRequestType());
+}
+
+}  // namespace transaction
+}  // namespace quickstep
diff --git a/transaction/tests/LockTable_unittest.cpp b/transaction/tests/LockTable_unittest.cpp
new file mode 100644
index 0000000..577cb79
--- /dev/null
+++ b/transaction/tests/LockTable_unittest.cpp
@@ -0,0 +1,105 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/LockTable.hpp"
+
+#include "transaction/AccessMode.hpp"
+#include "transaction/ResourceId.hpp"
+#include "transaction/Transaction.hpp"
+
+#include "gtest/gtest.h"
+
+namespace quickstep {
+namespace transaction {
+
+class LockTableTest : public ::testing::Test {
+ protected:
+  LockTableTest()
+      : tid_1_(1),
+        tid_2_(2),
+        tid_3_(3) {
+  }
+
+  LockTable lock_table_;
+  const transaction_id tid_1_;
+  const transaction_id tid_2_;
+  const transaction_id tid_3_;
+};
+
+TEST_F(LockTableTest, CompatibleRequestsFromDifferentTransactions) {
+  EXPECT_EQ(lock_table_.putLock(tid_1_,
+                                ResourceId(2),
+                                AccessMode(AccessModeType::kIsLock)),
+            LockTableResult::kPLACED_IN_OWNED);
+
+  // Acquire the same lock mode on same resource.
+  EXPECT_EQ(lock_table_.putLock(tid_1_,
+                                ResourceId(2),
+                                AccessMode(AccessModeType::kIsLock)),
+            LockTableResult::kALREADY_IN_OWNED);
+
+  // Another transaction acquires compatible lock on the same resource.
+  EXPECT_EQ(lock_table_.putLock(tid_2_,
+                                ResourceId(2),
+                                AccessMode(AccessModeType::kSLock)),
+            LockTableResult::kPLACED_IN_OWNED);
+}
+
+TEST_F(LockTableTest, IncompatibleRequestsFromDifferentTransactions) {
+  EXPECT_EQ(lock_table_.putLock(tid_1_,
+                                ResourceId(2),
+                                AccessMode(AccessModeType::kIsLock)),
+            LockTableResult::kPLACED_IN_OWNED);
+
+  // Acquire the same lock mode on same resource.
+  EXPECT_EQ(lock_table_.putLock(tid_1_,
+                                ResourceId(2),
+                                AccessMode(AccessModeType::kIsLock)),
+            LockTableResult::kALREADY_IN_OWNED);
+
+  // Another transaction acquires incompatible lock on the same resource.
+  EXPECT_EQ(lock_table_.putLock(tid_2_,
+                                ResourceId(2),
+                                AccessMode(AccessModeType::kXLock)),
+            LockTableResult::kPLACED_IN_PENDING);
+}
+
+TEST_F(LockTableTest, StarvationProtection) {
+  EXPECT_EQ(lock_table_.putLock(tid_1_,
+                                ResourceId(2),
+                                AccessMode(AccessModeType::kIsLock)),
+            LockTableResult::kPLACED_IN_OWNED);
+
+  // Another transaction requests incompatible lock on the same resource.
+  // It should wait for the previous transaction.
+  EXPECT_EQ(lock_table_.putLock(tid_2_,
+                                ResourceId(2),
+                                AccessMode(AccessModeType::kXLock)),
+            LockTableResult::kPLACED_IN_PENDING);
+
+  // Another third transaction requests a compatible lock on the same resource.
+  // Normally, it should acquire the lock, however, there is a pending
+  // transaction waiting on the same resource. To prevent starvation, we should
+  // put in the pending list.
+  EXPECT_EQ(lock_table_.putLock(tid_3_,
+                                ResourceId(2),
+                                AccessMode(AccessModeType::kIsLock)),
+            LockTableResult::kPLACED_IN_PENDING);
+}
+
+}  // namespace transaction
+}  // namespace quickstep
diff --git a/transaction/tests/Lock_unittest.cpp b/transaction/tests/Lock_unittest.cpp
new file mode 100644
index 0000000..2ab8b3e
--- /dev/null
+++ b/transaction/tests/Lock_unittest.cpp
@@ -0,0 +1,92 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/Lock.hpp"
+
+#include <cstddef>
+#include <vector>
+
+#include "transaction/AccessMode.hpp"
+#include "transaction/ResourceId.hpp"
+
+#include "gtest/gtest.h"
+
+namespace quickstep {
+namespace transaction {
+
+class LockTest : public ::testing::Test {
+ protected:
+  LockTest()
+      : modes_({AccessMode(AccessModeType::kNoLock),
+                AccessMode(AccessModeType::kIsLock),
+                AccessMode(AccessModeType::kIxLock),
+                AccessMode(AccessModeType::kSLock),
+                AccessMode(AccessModeType::kSixLock),
+                AccessMode(AccessModeType::kXLock)}),
+        resource_a_(3, 10, 2, 5),
+        resource_b_(4, 5, 3, 2),
+        locks_on_resource_a_({Lock(resource_a_, modes_[0]),
+                              Lock(resource_a_, modes_[1]),
+                              Lock(resource_a_, modes_[2]),
+                              Lock(resource_a_, modes_[3]),
+                              Lock(resource_a_, modes_[4]),
+                              Lock(resource_a_, modes_[5])}),
+        locks_on_resource_b_({Lock(resource_b_, modes_[0]),
+                             Lock(resource_b_, modes_[1]),
+                             Lock(resource_b_, modes_[2]),
+                             Lock(resource_b_, modes_[3]),
+                             Lock(resource_b_, modes_[4]),
+                             Lock(resource_b_, modes_[5])}) {
+  }
+
+  const std::vector<AccessMode> modes_;
+  const ResourceId resource_a_;
+  const ResourceId resource_b_;
+  const std::vector<Lock> locks_on_resource_a_;
+  const std::vector<Lock> locks_on_resource_b_;
+};
+
+TEST_F(LockTest, LockEquality) {
+  // Locks are equal if they are on the same resource with same
+  // access mode.
+  for (std::size_t i = 0; i < locks_on_resource_a_.size(); ++i) {
+    for (std::size_t j = 0; j < locks_on_resource_a_.size(); ++j) {
+      if (i == j) {
+        EXPECT_EQ(locks_on_resource_a_[i], locks_on_resource_a_[j]);
+      } else {
+        EXPECT_NE(locks_on_resource_a_[i], locks_on_resource_a_[j]);
+      }
+    }
+    // Locks are nver equal if they have different resource ids.
+    EXPECT_NE(locks_on_resource_a_[i], locks_on_resource_b_[i]);
+  }
+}
+
+TEST_F(LockTest, GetResourceId) {
+  for (std::size_t i = 0; i < locks_on_resource_a_.size(); ++i) {
+    EXPECT_EQ(resource_a_, locks_on_resource_a_[i].getResourceId());
+  }
+}
+
+TEST_F(LockTest, GetAccessMode) {
+  for (std::size_t i = 0; i < locks_on_resource_a_.size(); ++i) {
+    EXPECT_EQ(modes_[i], locks_on_resource_a_[i].getAccessMode());
+  }
+}
+
+}  // namespace transaction
+}  // namespace quickstep
diff --git a/transaction/tests/ResourceId_unittest.cpp b/transaction/tests/ResourceId_unittest.cpp
new file mode 100644
index 0000000..f3029f1
--- /dev/null
+++ b/transaction/tests/ResourceId_unittest.cpp
@@ -0,0 +1,113 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/ResourceId.hpp"
+
+#include "gtest/gtest.h"
+
+namespace quickstep {
+namespace transaction {
+
+class ResourceIdTest : public ::testing::Test {
+ protected:
+  ResourceIdTest()
+      : db1_(1),
+        db2_(2),
+        db2_rel2_(2, 2),
+        db2_rel4_(2, 4),
+        db2_rel2_block2_(2, 2, 2),
+        db2_rel2_block3_(2, 2, 3),
+        db2_rel4_block5_(2, 4, 5),
+        db2_rel4_block7_(2, 4, 7),
+        db2_rel2_block2_tpl4_(2, 2, 2, 4),
+        db2_rel2_block2_tpl7_(2, 2, 2, 7),
+        db2_rel4_block5_tpl3_(2, 4, 5, 7),
+        db2_rel4_block5_tpl8_(2, 4, 5, 8) {
+  }
+
+  const ResourceId db1_;
+  const ResourceId db2_;
+  const ResourceId db2_rel2_;
+  const ResourceId db2_rel4_;
+  const ResourceId db2_rel2_block2_;
+  const ResourceId db2_rel2_block3_;
+  const ResourceId db2_rel4_block5_;
+  const ResourceId db2_rel4_block7_;
+  const ResourceId db2_rel2_block2_tpl4_;
+  const ResourceId db2_rel2_block2_tpl7_;
+  const ResourceId db2_rel4_block5_tpl3_;
+  const ResourceId db2_rel4_block5_tpl8_;
+};
+
+TEST_F(ResourceIdTest, CheckAccessLevels) {
+  EXPECT_TRUE(db2_.isDatabaseAccess());
+  EXPECT_FALSE(db2_rel4_.isDatabaseAccess());
+  EXPECT_FALSE(db2_rel4_block5_.isDatabaseAccess());
+  EXPECT_FALSE(db2_rel4_block5_tpl8_.isDatabaseAccess());
+
+  EXPECT_FALSE(db2_.isRelationAccess());
+  EXPECT_TRUE(db2_rel4_.isRelationAccess());
+  EXPECT_FALSE(db2_rel4_block5_.isRelationAccess());
+  EXPECT_FALSE(db2_rel4_block5_tpl8_.isRelationAccess());
+
+  EXPECT_FALSE(db2_.isBlockAccess());
+  EXPECT_FALSE(db2_rel4_.isBlockAccess());
+  EXPECT_TRUE(db2_rel4_block5_.isBlockAccess());
+  EXPECT_FALSE(db2_rel4_block5_tpl8_.isBlockAccess());
+
+  EXPECT_FALSE(db2_.isTupleAccess());
+  EXPECT_FALSE(db2_rel4_.isTupleAccess());
+  EXPECT_FALSE(db2_rel4_block5_.isTupleAccess());
+  EXPECT_TRUE(db2_rel4_block5_tpl8_.isTupleAccess());
+}
+
+TEST_F(ResourceIdTest, Equality) {
+  // Copy some resource ids.
+  const ResourceId db1_copy(db1_);
+  const ResourceId db2_rel2_copy(db2_rel2_);
+  const ResourceId db2_rel4_block5_copy(db2_rel4_block5_);
+  const ResourceId db2_rel4_block5_tpl8_copy(db2_rel4_block5_tpl8_);
+
+  // Self comparison must be equal.
+  EXPECT_EQ(db1_, db1_);
+  EXPECT_EQ(db2_rel2_, db2_rel2_);
+  EXPECT_EQ(db2_rel4_block5_, db2_rel4_block5_);
+  EXPECT_EQ(db2_rel4_block5_tpl3_, db2_rel4_block5_tpl3_);
+
+  // If resources are different, than it must have different ids.
+  EXPECT_NE(db1_, db2_);
+  EXPECT_NE(db2_rel2_, db2_rel4_);
+  EXPECT_NE(db2_rel4_block5_, db2_rel4_block7_);
+  EXPECT_NE(db2_rel4_block5_tpl3_, db2_rel4_block5_tpl8_);
+
+  // Comparison with a copy must be equal.
+  EXPECT_EQ(db1_copy, db1_);
+  EXPECT_EQ(db2_rel2_copy, db2_rel2_);
+  EXPECT_EQ(db2_rel4_block5_copy, db2_rel4_block5_);
+  EXPECT_EQ(db2_rel4_block5_tpl8_copy, db2_rel4_block5_tpl8_);
+}
+
+TEST_F(ResourceIdTest, ParentResourceIds) {
+  EXPECT_EQ(db2_, db2_rel2_.getParentResourceId());
+  EXPECT_EQ(db2_rel2_, db2_rel2_block2_.getParentResourceId());
+  EXPECT_EQ(db2_rel2_, db2_rel2_block3_.getParentResourceId());
+  EXPECT_EQ(db2_rel2_block2_, db2_rel2_block2_tpl4_.getParentResourceId());
+  EXPECT_EQ(db2_rel2_block2_, db2_rel2_block2_tpl7_.getParentResourceId());
+}
+
+}  // namespace transaction
+}  // namespace quickstep
diff --git a/transaction/tests/StronglyConnectedComponents_unittest.cpp b/transaction/tests/StronglyConnectedComponents_unittest.cpp
index 84851ab..79d6881 100644
--- a/transaction/tests/StronglyConnectedComponents_unittest.cpp
+++ b/transaction/tests/StronglyConnectedComponents_unittest.cpp
@@ -30,7 +30,6 @@
 #include "gtest/gtest.h"
 
 namespace quickstep {
-
 namespace transaction {
 
 class GraphConfiguration {
@@ -225,5 +224,4 @@
 }
 
 }  // namespace transaction
-
 }  // namespace quickstep
diff --git a/transaction/tests/TransactionTable_unittest.cpp b/transaction/tests/TransactionTable_unittest.cpp
new file mode 100644
index 0000000..f5b5bc9
--- /dev/null
+++ b/transaction/tests/TransactionTable_unittest.cpp
@@ -0,0 +1,132 @@
+/**
+ *   Copyright 2016, Quickstep Research Group, Computer Sciences Department,
+ *     University of Wisconsin—Madison.
+ *
+ *   Licensed 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 "transaction/TransactionTable.hpp"
+
+#include "transaction/AccessMode.hpp"
+#include "transaction/ResourceId.hpp"
+#include "transaction/Transaction.hpp"
+
+#include "gtest/gtest.h"
+
+namespace quickstep {
+namespace transaction {
+
+class TransactionTableTest : public ::testing::Test {
+ protected:
+  TransactionTableTest()
+      : tid_1_(1),
+        tid_2_(2),
+        tid_3_(3) {
+    }
+
+  TransactionTable transaction_table_;
+  const transaction_id tid_1_;
+  const transaction_id tid_2_;
+  const transaction_id tid_3_;
+};
+
+TEST_F(TransactionTableTest, NormalOperations) {
+  EXPECT_EQ(transaction_table_.putOwnEntry(tid_1_,
+                                           ResourceId(3),
+                                           AccessMode(AccessModeType::kIsLock)),
+            TransactionTableResult::kPlacedInOwned);
+
+  EXPECT_EQ(transaction_table_.putPendingEntry(tid_1_,
+                                               ResourceId(5),
+                                               AccessMode(AccessModeType::kXLock)),
+            TransactionTableResult::kPlacedInPending);
+}
+
+TEST_F(TransactionTableTest, DeleteEntryOperations) {
+  EXPECT_EQ(transaction_table_.deleteOwnEntry(tid_2_,
+                                              ResourceId(5),
+                                              AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kDelError);
+
+  EXPECT_EQ(transaction_table_.putOwnEntry(tid_2_,
+                                           ResourceId(5),
+                                           AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kPlacedInOwned);
+
+  // Tring to delete a lock with different acces mode on same resource id
+  // will result in an error.
+  EXPECT_EQ(transaction_table_.deleteOwnEntry(tid_2_,
+                                              ResourceId(5),
+                                              AccessMode(AccessModeType::kXLock)),
+            TransactionTableResult::kDelError);
+
+  // Transaction 3 does not have a lock on this resource id.
+  EXPECT_EQ(transaction_table_.deleteOwnEntry(tid_3_,
+                                              ResourceId(5),
+                                              AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kDelError);
+
+  // This will result in success since transaction 2 have acquired the lock on
+  // this resource with the corresponding mode.
+  EXPECT_EQ(transaction_table_.deleteOwnEntry(tid_2_,
+                                              ResourceId(5),
+                                              AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kDelFromOwned);
+
+  // Repeat the previous sequence, with pending list.
+  EXPECT_EQ(transaction_table_.deletePendingEntry(tid_2_,
+                                                  ResourceId(5),
+                                                  AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kDelError);
+
+  EXPECT_EQ(transaction_table_.putPendingEntry(tid_2_,
+                                               ResourceId(5),
+                                               AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kPlacedInPending);
+
+  EXPECT_EQ(transaction_table_.deletePendingEntry(tid_2_,
+                                                  ResourceId(5),
+                                                  AccessMode(AccessModeType::kXLock)),
+            TransactionTableResult::kDelError);
+
+  EXPECT_EQ(transaction_table_.deletePendingEntry(tid_3_,
+                                                  ResourceId(5),
+                                                  AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kDelError);
+
+  EXPECT_EQ(transaction_table_.deletePendingEntry(tid_2_,
+                                                  ResourceId(5),
+                                                  AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kDelFromPending);
+}
+
+TEST_F(TransactionTableTest, TransactionEntries) {
+  EXPECT_EQ(transaction_table_.deleteTransaction(tid_1_),
+            TransactionTableResult::kTransactionDeleteError);
+
+  EXPECT_EQ(transaction_table_.putOwnEntry(tid_1_,
+                                           ResourceId(4),
+                                           AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kPlacedInOwned);
+
+  EXPECT_EQ(transaction_table_.deleteTransaction(tid_1_),
+            TransactionTableResult::kTransactionDeleteOk);
+
+  EXPECT_EQ(transaction_table_.deleteOwnEntry(tid_1_,
+                                              ResourceId(4),
+                                              AccessMode(AccessModeType::kSLock)),
+            TransactionTableResult::kDelError);
+}
+
+}  // namespace transaction
+}  // namespace quickstep