quickstep-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From shix...@apache.org
Subject incubator-quickstep git commit: Added WindowAggregateFunctions for other functions without handle
Date Fri, 15 Jul 2016 17:32:53 GMT
Repository: incubator-quickstep
Updated Branches:
  refs/heads/SQL-window-aggregation 5f4647b73 -> 727761bb0


Added WindowAggregateFunctions for other functions without handle


Project: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/commit/727761bb
Tree: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/tree/727761bb
Diff: http://git-wip-us.apache.org/repos/asf/incubator-quickstep/diff/727761bb

Branch: refs/heads/SQL-window-aggregation
Commit: 727761bb083a197698db7e0f155a95c9f6b60cf6
Parents: 5f4647b
Author: shixuan-fan <shixuan@apache.org>
Authored: Fri Jul 15 17:30:53 2016 +0000
Committer: shixuan-fan <shixuan@apache.org>
Committed: Fri Jul 15 17:30:53 2016 +0000

----------------------------------------------------------------------
 expressions/window_aggregation/CMakeLists.txt   | 65 +++++++++++++++-
 .../WindowAggregateFunction.cpp                 | 12 +++
 .../WindowAggregateFunction.hpp                 |  6 +-
 .../WindowAggregateFunction.proto               |  4 +
 .../WindowAggregateFunctionCount.cpp            | 59 ++++++++++++++
 .../WindowAggregateFunctionCount.hpp            | 75 ++++++++++++++++++
 .../WindowAggregateFunctionFactory.cpp          | 28 +++++++
 .../WindowAggregateFunctionMax.cpp              | 67 ++++++++++++++++
 .../WindowAggregateFunctionMax.hpp              | 75 ++++++++++++++++++
 .../WindowAggregateFunctionMin.cpp              | 66 ++++++++++++++++
 .../WindowAggregateFunctionMin.hpp              | 75 ++++++++++++++++++
 .../WindowAggregateFunctionSum.cpp              | 82 ++++++++++++++++++++
 .../WindowAggregateFunctionSum.hpp              | 75 ++++++++++++++++++
 .../WindowAggregationHandle.hpp                 | 27 +++----
 .../WindowAggregationHandleAvg.cpp              | 26 +++----
 .../WindowAggregationHandleAvg.hpp              |  7 +-
 .../WindowAggregationHandleAvg_unittest.cpp     | 20 ++---
 .../tests/execution_generator/Select.test       | 78 ++++++++++++++++---
 .../WindowAggregationOperator.cpp               |  7 +-
 .../WindowAggregationOperator.hpp               |  1 +
 storage/WindowAggregationOperationState.cpp     | 23 +++++-
 storage/WindowAggregationOperationState.hpp     | 18 +----
 22 files changed, 816 insertions(+), 80 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/CMakeLists.txt b/expressions/window_aggregation/CMakeLists.txt
index db11ddd..d73bed1 100644
--- a/expressions/window_aggregation/CMakeLists.txt
+++ b/expressions/window_aggregation/CMakeLists.txt
@@ -28,6 +28,18 @@ add_library(quickstep_expressions_windowaggregation_WindowAggregateFunction_prot
 add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionAvg
             WindowAggregateFunctionAvg.cpp
             WindowAggregateFunctionAvg.hpp)
+add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionCount
+            WindowAggregateFunctionCount.cpp
+            WindowAggregateFunctionCount.hpp)
+add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionMax
+            WindowAggregateFunctionMax.cpp
+            WindowAggregateFunctionMax.hpp)
+add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionMin
+            WindowAggregateFunctionMin.cpp
+            WindowAggregateFunctionMin.hpp)
+add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionSum
+            WindowAggregateFunctionSum.cpp
+            WindowAggregateFunctionSum.hpp)
 add_library(quickstep_expressions_windowaggregation_WindowAggregateFunctionFactory
             WindowAggregateFunctionFactory.cpp
             WindowAggregateFunctionFactory.hpp)
@@ -51,16 +63,65 @@ target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFun
                       quickstep_utility_Macros)
 target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunction_proto
                       ${PROTOBUF_LIBRARY})
+target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionAvg
+                      glog
+                      quickstep_expressions_windowaggregation_WindowAggregateFunction
+                      quickstep_expressions_windowaggregation_WindowAggregationHandleAvg
+                      quickstep_expressions_windowaggregation_WindowAggregationID
+                      quickstep_types_Type
+                      quickstep_types_TypeFactory
+                      quickstep_types_TypeID
+                      quickstep_types_operations_binaryoperations_BinaryOperation
+                      quickstep_types_operations_binaryoperations_BinaryOperationFactory
+                      quickstep_types_operations_binaryoperations_BinaryOperationID
+                      quickstep_utility_Macros)
+target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionCount
+                      glog
+                      quickstep_expressions_windowaggregation_WindowAggregateFunction
+                      quickstep_expressions_windowaggregation_WindowAggregationHandle
+                      quickstep_expressions_windowaggregation_WindowAggregationID
+                      quickstep_types_Type
+                      quickstep_types_TypeFactory
+                      quickstep_types_TypeID
+                      quickstep_utility_Macros)
 target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionFactory
                       glog
                       quickstep_expressions_windowaggregation_WindowAggregateFunctionAvg
+                      quickstep_expressions_windowaggregation_WindowAggregateFunctionCount
+                      quickstep_expressions_windowaggregation_WindowAggregateFunctionMax
+                      quickstep_expressions_windowaggregation_WindowAggregateFunctionMin
+                      quickstep_expressions_windowaggregation_WindowAggregateFunctionSum
                       quickstep_expressions_windowaggregation_WindowAggregateFunction_proto
                       quickstep_expressions_windowaggregation_WindowAggregationID
                       quickstep_utility_Macros)
-target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionAvg
+target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionMax
                       glog
                       quickstep_expressions_windowaggregation_WindowAggregateFunction
-                      quickstep_expressions_windowaggregation_WindowAggregationHandleAvg
+                      quickstep_expressions_windowaggregation_WindowAggregationHandle
+                      quickstep_expressions_windowaggregation_WindowAggregationID
+                      quickstep_types_Type
+                      quickstep_types_TypeFactory
+                      quickstep_types_TypeID
+                      quickstep_types_operations_comparisons_Comparison
+                      quickstep_types_operations_comparisons_ComparisonFactory
+                      quickstep_types_operations_comparisons_ComparisonID
+                      quickstep_utility_Macros)
+target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionMin
+                      glog
+                      quickstep_expressions_windowaggregation_WindowAggregateFunction
+                      quickstep_expressions_windowaggregation_WindowAggregationHandle
+                      quickstep_expressions_windowaggregation_WindowAggregationID
+                      quickstep_types_Type
+                      quickstep_types_TypeFactory
+                      quickstep_types_TypeID
+                      quickstep_types_operations_comparisons_Comparison
+                      quickstep_types_operations_comparisons_ComparisonFactory
+                      quickstep_types_operations_comparisons_ComparisonID
+                      quickstep_utility_Macros)
+target_link_libraries(quickstep_expressions_windowaggregation_WindowAggregateFunctionSum
+                      glog
+                      quickstep_expressions_windowaggregation_WindowAggregateFunction
+                      quickstep_expressions_windowaggregation_WindowAggregationHandle
                       quickstep_expressions_windowaggregation_WindowAggregationID
                       quickstep_types_Type
                       quickstep_types_TypeFactory

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunction.cpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunction.cpp b/expressions/window_aggregation/WindowAggregateFunction.cpp
index 88ba0b9..6099504 100644
--- a/expressions/window_aggregation/WindowAggregateFunction.cpp
+++ b/expressions/window_aggregation/WindowAggregateFunction.cpp
@@ -34,6 +34,18 @@ serialization::WindowAggregateFunction WindowAggregateFunction::getProto() const
     case WindowAggregationID::kAvg:
       proto.set_window_aggregation_id(serialization::WindowAggregateFunction::AVG);
       break;
+    case WindowAggregationID::kCount:
+      proto.set_window_aggregation_id(serialization::WindowAggregateFunction::COUNT);
+      break;
+    case WindowAggregationID::kMax:
+      proto.set_window_aggregation_id(serialization::WindowAggregateFunction::MAX);
+      break;
+    case WindowAggregationID::kMin:
+      proto.set_window_aggregation_id(serialization::WindowAggregateFunction::MIN);
+      break;
+    case WindowAggregationID::kSum:
+      proto.set_window_aggregation_id(serialization::WindowAggregateFunction::SUM);
+      break;
     default: {
       LOG(FATAL) << "Unrecognized WindowAggregationID: "
                  << static_cast<std::underlying_type<WindowAggregationID>::type>(win_agg_id_);

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunction.hpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunction.hpp b/expressions/window_aggregation/WindowAggregateFunction.hpp
index eb82943..bb3fd60 100644
--- a/expressions/window_aggregation/WindowAggregateFunction.hpp
+++ b/expressions/window_aggregation/WindowAggregateFunction.hpp
@@ -120,10 +120,8 @@ class WindowAggregateFunction {
    *
    * @param argument_types A list of zero or more Types (in order) for
    *        arguments to this WindowAggregateFunction.
-   * @param partition_by_attributes The partition keys.
-   * @param is_row Ture if the frame mode is ROWS, false if it is RANGE.
-   * @param num_preceding The number of rows/range that precedes the current row.
-   * @param num_following The number of rows/range that follows the current row.
+   * @param partition_key_types A list or zero or more Types for partition keys
+   *                            to this WindowAggregateFunction.
    * 
    * @return A new WindowAggregationHandle that can be used to compute this
    *         WindowAggregateFunction over the specified argument_types. Caller

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunction.proto
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunction.proto b/expressions/window_aggregation/WindowAggregateFunction.proto
index 173ff0e..8c5d948 100644
--- a/expressions/window_aggregation/WindowAggregateFunction.proto
+++ b/expressions/window_aggregation/WindowAggregateFunction.proto
@@ -19,6 +19,10 @@ package quickstep.serialization;
 message WindowAggregateFunction {
   enum WindowAggregationID {
     AVG = 0;
+    COUNT = 1;
+    MAX = 2;
+    MIN = 3;
+    SUM = 4;    
   }
 
   required WindowAggregationID window_aggregation_id = 1;

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunctionCount.cpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunctionCount.cpp b/expressions/window_aggregation/WindowAggregateFunctionCount.cpp
new file mode 100644
index 0000000..22dc6a1
--- /dev/null
+++ b/expressions/window_aggregation/WindowAggregateFunctionCount.cpp
@@ -0,0 +1,59 @@
+/**
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#include "expressions/window_aggregation/WindowAggregateFunctionCount.hpp"
+
+#include <vector>
+
+#include "expressions/window_aggregation/WindowAggregationHandle.hpp"
+#include "types/Type.hpp"
+#include "types/TypeFactory.hpp"
+#include "types/TypeID.hpp"
+
+#include "glog/logging.h"
+
+namespace quickstep {
+
+bool WindowAggregateFunctionCount::canApplyToTypes(
+    const std::vector<const Type*> &argument_types) const {
+  // COUNT may be nullary (i.e. COUNT(*)) or unary.
+  return argument_types.size() <= 1;
+}
+
+const Type* WindowAggregateFunctionCount::resultTypeForArgumentTypes(
+    const std::vector<const Type*> &argument_types) const {
+  if (!canApplyToTypes(argument_types)) {
+    return nullptr;
+  }
+
+  return &TypeFactory::GetType(kLong);
+}
+
+WindowAggregationHandle* WindowAggregateFunctionCount::createHandle(
+    std::vector<const Type*> &&argument_types,
+    std::vector<const Type*> &&partition_key_types) const {
+  DCHECK(canApplyToTypes(argument_types))
+      << "Attempted to create a WindowAggregationHandleCount for argument Types "
+      << "that COUNT can not be applied to (> 1 argument).";
+
+  // TODO(Shixuan): Add handle for Count.
+  return nullptr;
+}
+
+}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunctionCount.hpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunctionCount.hpp b/expressions/window_aggregation/WindowAggregateFunctionCount.hpp
new file mode 100644
index 0000000..6090852
--- /dev/null
+++ b/expressions/window_aggregation/WindowAggregateFunctionCount.hpp
@@ -0,0 +1,75 @@
+/**
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#ifndef QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_COUNT_HPP_
+#define QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_COUNT_HPP_
+
+#include <string>
+#include <vector>
+
+#include "expressions/window_aggregation/WindowAggregateFunction.hpp"
+#include "expressions/window_aggregation/WindowAggregationID.hpp"
+#include "utility/Macros.hpp"
+
+namespace quickstep {
+
+class WindowAggregationHandle;
+class Type;
+
+/** \addtogroup Expressions
+ *  @{
+ */
+
+/**
+ * @brief WindowAggregateFunction representing SQL COUNT() OVER term.
+ **/
+class WindowAggregateFunctionCount : public WindowAggregateFunction {
+ public:
+  static const WindowAggregateFunctionCount& Instance() {
+    static WindowAggregateFunctionCount instance;
+    return instance;
+  }
+
+  std::string getName() const override {
+    return "COUNT";
+  }
+
+  bool canApplyToTypes(
+      const std::vector<const Type*> &argument_types) const override;
+
+  const Type* resultTypeForArgumentTypes(
+      const std::vector<const Type*> &argument_types) const override;
+
+  WindowAggregationHandle* createHandle(
+      std::vector<const Type*> &&argument_types,
+      std::vector<const Type*> &&partition_key_types) const override;
+
+ private:
+  WindowAggregateFunctionCount()
+      : WindowAggregateFunction(WindowAggregationID::kCount) {
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(WindowAggregateFunctionCount);
+};
+
+/** @} */
+
+}  // namespace quickstep
+
+#endif  // QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_COUNT_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunctionFactory.cpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunctionFactory.cpp b/expressions/window_aggregation/WindowAggregateFunctionFactory.cpp
index afd53ef..295ef60 100644
--- a/expressions/window_aggregation/WindowAggregateFunctionFactory.cpp
+++ b/expressions/window_aggregation/WindowAggregateFunctionFactory.cpp
@@ -24,6 +24,10 @@
 
 #include "expressions/window_aggregation/WindowAggregateFunction.pb.h"
 #include "expressions/window_aggregation/WindowAggregateFunctionAvg.hpp"
+#include "expressions/window_aggregation/WindowAggregateFunctionCount.hpp"
+#include "expressions/window_aggregation/WindowAggregateFunctionMax.hpp"
+#include "expressions/window_aggregation/WindowAggregateFunctionMin.hpp"
+#include "expressions/window_aggregation/WindowAggregateFunctionSum.hpp"
 #include "expressions/window_aggregation/WindowAggregationID.hpp"
 
 #include "glog/logging.h"
@@ -35,6 +39,14 @@ const WindowAggregateFunction& WindowAggregateFunctionFactory::Get(
   switch (agg_id) {
     case WindowAggregationID::kAvg:
       return WindowAggregateFunctionAvg::Instance();
+    case WindowAggregationID::kCount:
+      return WindowAggregateFunctionCount::Instance();
+    case WindowAggregationID::kMax:
+      return WindowAggregateFunctionMax::Instance();
+    case WindowAggregationID::kMin:
+      return WindowAggregateFunctionMin::Instance();
+    case WindowAggregationID::kSum:
+      return WindowAggregateFunctionSum::Instance();
     default: {
       LOG(FATAL) << "Unrecognized WindowAggregationID: "
                  << static_cast<std::underlying_type<WindowAggregationID>::type>(agg_id);
@@ -46,6 +58,14 @@ const WindowAggregateFunction* WindowAggregateFunctionFactory::GetByName(
     const std::string &name) {
   if (name == "avg") {
     return &WindowAggregateFunctionAvg::Instance();
+  } else if (name == "count") {
+    return &WindowAggregateFunctionCount::Instance();
+  } else if (name == "max") {
+    return &WindowAggregateFunctionMax::Instance();
+  } else if (name == "min") {
+    return &WindowAggregateFunctionMin::Instance();
+  } else if (name == "sum") {
+    return &WindowAggregateFunctionSum::Instance();
   } else {
     return nullptr;
   }
@@ -66,6 +86,14 @@ const WindowAggregateFunction& WindowAggregateFunctionFactory::ReconstructFromPr
   switch (proto.window_aggregation_id()) {
     case serialization::WindowAggregateFunction::AVG:
       return WindowAggregateFunctionAvg::Instance();
+    case serialization::WindowAggregateFunction::COUNT:
+      return WindowAggregateFunctionCount::Instance();
+    case serialization::WindowAggregateFunction::MAX:
+      return WindowAggregateFunctionMax::Instance();
+    case serialization::WindowAggregateFunction::MIN:
+      return WindowAggregateFunctionMin::Instance();
+    case serialization::WindowAggregateFunction::SUM:
+      return WindowAggregateFunctionSum::Instance();
     default: {
       LOG(FATAL) << "Unrecognized serialization::WindowAggregateFunction::WindowAggregationID: "
                  << proto.window_aggregation_id()

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunctionMax.cpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunctionMax.cpp b/expressions/window_aggregation/WindowAggregateFunctionMax.cpp
new file mode 100644
index 0000000..b284901
--- /dev/null
+++ b/expressions/window_aggregation/WindowAggregateFunctionMax.cpp
@@ -0,0 +1,67 @@
+/**
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#include "expressions/window_aggregation/WindowAggregateFunctionMax.hpp"
+
+#include <vector>
+
+#include "expressions/window_aggregation/WindowAggregationHandle.hpp"
+#include "types/Type.hpp"
+#include "types/operations/comparisons/Comparison.hpp"
+#include "types/operations/comparisons/ComparisonFactory.hpp"
+#include "types/operations/comparisons/ComparisonID.hpp"
+
+#include "glog/logging.h"
+
+namespace quickstep {
+
+bool WindowAggregateFunctionMax::canApplyToTypes(
+    const std::vector<const Type*> &argument_types) const {
+  // MAX is unary.
+  if (argument_types.size() != 1) {
+    return false;
+  }
+
+  // Argument must be comparable by '>'.
+  return ComparisonFactory::GetComparison(ComparisonID::kGreater).canCompareTypes(
+      *argument_types.front(),
+      *argument_types.front());
+}
+
+const Type* WindowAggregateFunctionMax::resultTypeForArgumentTypes(
+    const std::vector<const Type*> &argument_types) const {
+  if (!canApplyToTypes(argument_types)) {
+    return nullptr;
+  }
+
+  return &(argument_types.front()->getNullableVersion());
+}
+
+WindowAggregationHandle* WindowAggregateFunctionMax::createHandle(
+    std::vector<const Type*> &&argument_types,
+    std::vector<const Type*> &&partition_key_types) const {
+  DCHECK(canApplyToTypes(argument_types))
+      << "Attempted to create a WindowAggregationHandleMax for argument Type(s) "
+      << "that MAX can not be applied to.";
+
+  // TODO(Shixuan): Add handle for Max.
+  return nullptr;
+}
+
+}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunctionMax.hpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunctionMax.hpp b/expressions/window_aggregation/WindowAggregateFunctionMax.hpp
new file mode 100644
index 0000000..8d9de11
--- /dev/null
+++ b/expressions/window_aggregation/WindowAggregateFunctionMax.hpp
@@ -0,0 +1,75 @@
+/**
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#ifndef QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_MAX_HPP_
+#define QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_MAX_HPP_
+
+#include <string>
+#include <vector>
+
+#include "expressions/window_aggregation/WindowAggregateFunction.hpp"
+#include "expressions/window_aggregation/WindowAggregationID.hpp"
+#include "utility/Macros.hpp"
+
+namespace quickstep {
+
+class WindowAggregationHandle;
+class Type;
+
+/** \addtogroup Expressions
+ *  @{
+ */
+
+/**
+ * @brief WindowAggregateFunction representing SQL MAX() OVER term.
+ **/
+class WindowAggregateFunctionMax : public WindowAggregateFunction {
+ public:
+  static const WindowAggregateFunctionMax& Instance() {
+    static WindowAggregateFunctionMax instance;
+    return instance;
+  }
+
+  std::string getName() const override {
+    return "MAX";
+  }
+
+  bool canApplyToTypes(
+      const std::vector<const Type*> &argument_types) const override;
+
+  const Type* resultTypeForArgumentTypes(
+      const std::vector<const Type*> &argument_types) const override;
+
+  WindowAggregationHandle* createHandle(
+      std::vector<const Type*> &&argument_types,
+      std::vector<const Type*> &&partition_key_types) const override;
+
+ private:
+  WindowAggregateFunctionMax()
+      : WindowAggregateFunction(WindowAggregationID::kMax) {
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(WindowAggregateFunctionMax);
+};
+
+/** @} */
+
+}  // namespace quickstep
+
+#endif  // QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_MAX_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunctionMin.cpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunctionMin.cpp b/expressions/window_aggregation/WindowAggregateFunctionMin.cpp
new file mode 100644
index 0000000..a3e3f1e
--- /dev/null
+++ b/expressions/window_aggregation/WindowAggregateFunctionMin.cpp
@@ -0,0 +1,66 @@
+/**
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#include "expressions/window_aggregation/WindowAggregateFunctionMin.hpp"
+
+#include <vector>
+
+#include "expressions/window_aggregation/WindowAggregationHandle.hpp"
+#include "types/Type.hpp"
+#include "types/operations/comparisons/Comparison.hpp"
+#include "types/operations/comparisons/ComparisonFactory.hpp"
+#include "types/operations/comparisons/ComparisonID.hpp"
+
+#include "glog/logging.h"
+
+namespace quickstep {
+
+bool WindowAggregateFunctionMin::canApplyToTypes(
+    const std::vector<const Type*> &argument_types) const {
+  // MIN is unary.
+  if (argument_types.size() != 1) {
+    return false;
+  }
+
+  // Argument must be comparable by '<'.
+  return ComparisonFactory::GetComparison(ComparisonID::kLess).canCompareTypes(
+      *argument_types.front(),
+      *argument_types.front());
+}
+
+const Type* WindowAggregateFunctionMin::resultTypeForArgumentTypes(
+    const std::vector<const Type*> &argument_types) const {
+  if (!canApplyToTypes(argument_types)) {
+    return nullptr;
+  }
+
+  return &(argument_types.front()->getNullableVersion());
+}
+
+WindowAggregationHandle* WindowAggregateFunctionMin::createHandle(
+    std::vector<const Type*> &&argument_types,
+    std::vector<const Type*> &&partition_key_types) const {
+  DCHECK(canApplyToTypes(argument_types))
+      << "Attempted to create a WindowAggregationHandleMin for argument Type(s) "
+      << "that MIN can not be applied to.";
+
+  return nullptr;
+}
+
+}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunctionMin.hpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunctionMin.hpp b/expressions/window_aggregation/WindowAggregateFunctionMin.hpp
new file mode 100644
index 0000000..39928d3
--- /dev/null
+++ b/expressions/window_aggregation/WindowAggregateFunctionMin.hpp
@@ -0,0 +1,75 @@
+/**
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#ifndef QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_MIN_HPP_
+#define QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_MIN_HPP_
+
+#include <string>
+#include <vector>
+
+#include "expressions/window_aggregation/WindowAggregateFunction.hpp"
+#include "expressions/window_aggregation/WindowAggregationID.hpp"
+#include "utility/Macros.hpp"
+
+namespace quickstep {
+
+class WindowAggregationHandle;
+class Type;
+
+/** \addtogroup Expressions
+ *  @{
+ */
+
+/**
+ * @brief WindowAggregateFunction representing SQL MIN() OVER term.
+ **/
+class WindowAggregateFunctionMin : public WindowAggregateFunction {
+ public:
+  static const WindowAggregateFunctionMin& Instance() {
+    static WindowAggregateFunctionMin instance;
+    return instance;
+  }
+
+  std::string getName() const override {
+    return "MIN";
+  }
+
+  bool canApplyToTypes(
+      const std::vector<const Type*> &argument_types) const override;
+
+  const Type* resultTypeForArgumentTypes(
+      const std::vector<const Type*> &argument_types) const override;
+
+  WindowAggregationHandle* createHandle(
+      std::vector<const Type*> &&argument_types,
+      std::vector<const Type*> &&partition_key_types) const override;
+
+ private:
+  WindowAggregateFunctionMin()
+      : WindowAggregateFunction(WindowAggregationID::kMin) {
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(WindowAggregateFunctionMin);
+};
+
+/** @} */
+
+}  // namespace quickstep
+
+#endif  // QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_MIN_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunctionSum.cpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunctionSum.cpp b/expressions/window_aggregation/WindowAggregateFunctionSum.cpp
new file mode 100644
index 0000000..8ea2e00
--- /dev/null
+++ b/expressions/window_aggregation/WindowAggregateFunctionSum.cpp
@@ -0,0 +1,82 @@
+/**
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#include "expressions/window_aggregation/WindowAggregateFunctionSum.hpp"
+
+#include <vector>
+
+#include "expressions/window_aggregation/WindowAggregationHandle.hpp"
+#include "types/Type.hpp"
+#include "types/TypeFactory.hpp"
+#include "types/TypeID.hpp"
+#include "types/operations/binary_operations/BinaryOperation.hpp"
+#include "types/operations/binary_operations/BinaryOperationFactory.hpp"
+#include "types/operations/binary_operations/BinaryOperationID.hpp"
+
+#include "glog/logging.h"
+
+namespace quickstep {
+
+bool WindowAggregateFunctionSum::canApplyToTypes(
+    const std::vector<const Type*> &argument_types) const {
+  // SUM is unary.
+  if (argument_types.size() != 1) {
+    return false;
+  }
+
+  // Argument must be addable.
+  return BinaryOperationFactory::GetBinaryOperation(BinaryOperationID::kAdd)
+             .canApplyToTypes(*argument_types.front(), *argument_types.front());
+}
+
+const Type* WindowAggregateFunctionSum::resultTypeForArgumentTypes(
+    const std::vector<const Type*> &argument_types) const {
+  if (!canApplyToTypes(argument_types)) {
+    return nullptr;
+  }
+
+  // SUM may return NULL if there are no input rows, and we automatically widen
+  // int to long and float to double to have more headroom when adding up many
+  // values.
+  const Type *sum_type = &(argument_types.front()->getNullableVersion());
+  switch (sum_type->getTypeID()) {
+    case kInt:
+      sum_type = &TypeFactory::GetType(kLong, true);
+      break;
+    case kFloat:
+      sum_type = &TypeFactory::GetType(kDouble, true);
+      break;
+    default:
+      break;
+  }
+
+  return sum_type;
+}
+
+WindowAggregationHandle* WindowAggregateFunctionSum::createHandle(
+    std::vector<const Type*> &&argument_types,
+    std::vector<const Type*> &&partition_key_types) const {
+  DCHECK(canApplyToTypes(argument_types))
+      << "Attempted to create a WindowAggregationHandleSum for argument Type(s) "
+      << "that SUM can not be applied to.";
+
+  return nullptr;
+}
+
+}  // namespace quickstep

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregateFunctionSum.hpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregateFunctionSum.hpp b/expressions/window_aggregation/WindowAggregateFunctionSum.hpp
new file mode 100644
index 0000000..89de355
--- /dev/null
+++ b/expressions/window_aggregation/WindowAggregateFunctionSum.hpp
@@ -0,0 +1,75 @@
+/**
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ **/
+
+#ifndef QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_SUM_HPP_
+#define QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_SUM_HPP_
+
+#include <string>
+#include <vector>
+
+#include "expressions/window_aggregation/WindowAggregateFunction.hpp"
+#include "expressions/window_aggregation/WindowAggregationID.hpp"
+#include "utility/Macros.hpp"
+
+namespace quickstep {
+
+class WindowAggregationHandle;
+class Type;
+
+/** \addtogroup Expressions
+ *  @{
+ */
+
+/**
+ * @brief WindowAggregateFunction representing SQL SUM() OVER term.
+ **/
+class WindowAggregateFunctionSum : public WindowAggregateFunction {
+ public:
+  static const WindowAggregateFunctionSum& Instance() {
+    static WindowAggregateFunctionSum instance;
+    return instance;
+  }
+
+  std::string getName() const override {
+    return "SUM";
+  }
+
+  bool canApplyToTypes(
+      const std::vector<const Type*> &argument_types) const override;
+
+  const Type* resultTypeForArgumentTypes(
+      const std::vector<const Type*> &argument_types) const override;
+
+  WindowAggregationHandle* createHandle(
+      std::vector<const Type*> &&argument_types,
+      std::vector<const Type*> &&partition_key_types) const override;
+
+ private:
+  WindowAggregateFunctionSum()
+      : WindowAggregateFunction(WindowAggregationID::kSum) {
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(WindowAggregateFunctionSum);
+};
+
+/** @} */
+
+}  // namespace quickstep
+
+#endif  // QUICKSTEP_EXPRESSIONS_WINDOW_AGGREGATION_WINDOW_AGGREGATE_FUNCTION_SUM_HPP_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregationHandle.hpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregationHandle.hpp b/expressions/window_aggregation/WindowAggregationHandle.hpp
index 8941209..8863bad 100644
--- a/expressions/window_aggregation/WindowAggregationHandle.hpp
+++ b/expressions/window_aggregation/WindowAggregationHandle.hpp
@@ -83,7 +83,7 @@ class ValueAccessor;
  * is not finished. WindowAggregationOperationState will be used for handling
  * the global state of the calculation.
  **/
- 
+
 class WindowAggregationHandle {
  public:
   /**
@@ -94,13 +94,14 @@ class WindowAggregationHandle {
   /**
    * @brief Calculate the window aggregate result.
    *
-   * @param state The start state of the calculation.
-   * @param attribute_accessor A pointer to the value accessor of attributes.
-   * @param argument_ids The attribute_id of arguments in attribute_accessor,
-   *                     NULL if not all arguments are attributes.
-   * @param argument_accessor A pointer to the value accessor of arguments,
-   *                          NULL if all arguments are attributes.
-   * @param output_destination The destination for output.
+   * @param block_accessors A pointer to the value accessor of block attributes.
+   * @param arguments The ColumnVectors of arguments
+   * @param partition_by_ids The ids of partition keys.
+   * @param is_row True if the frame mode is ROWS, false if it is RANGE.
+   * @param num_preceding The number of rows/range that precedes the current row.
+   * @param num_following The number of rows/range that follows the current row.
+   *
+   * @return A ColumnVector of the calculated window aggregates.
    **/
   virtual ColumnVector* calculate(ColumnVectorsValueAccessor* block_accessors,
                                   std::vector<ColumnVector*> &&arguments,
@@ -113,14 +114,10 @@ class WindowAggregationHandle {
   /**
    * @brief Constructor.
    *
-   * @param partition_by_ids The attribute_id of partition keys in
-   *                         attribute_accessor.
-   * @param is_row True if the frame mode is ROWS, false if it is RANGE.
-   * @param num_preceding The number of rows/range that precedes the current row.
-   * @param num_following The number of rows/range that follows the current row.
-   * @param storage_manager A pointer to the storage manager.
+   * @param partition_key_types The Types of the partition key.
    **/
-  WindowAggregationHandle(std::vector<const Type*> &&partition_key_types) {
+  explicit WindowAggregationHandle(
+      std::vector<const Type*> &&partition_key_types) {
     // Comparison operators for checking if two tuples belong to the same partition.
     for (const Type *partition_key_type : partition_key_types) {
       equal_comparators_.emplace_back(

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregationHandleAvg.cpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregationHandleAvg.cpp b/expressions/window_aggregation/WindowAggregationHandleAvg.cpp
index 18ab52f..acc19fe 100644
--- a/expressions/window_aggregation/WindowAggregationHandleAvg.cpp
+++ b/expressions/window_aggregation/WindowAggregationHandleAvg.cpp
@@ -94,21 +94,21 @@ ColumnVector* WindowAggregationHandleAvg::calculate(
     const bool is_row,
     const std::int64_t num_preceding,
     const std::int64_t num_following) {
-  DCHECK(arguments.size() == 1);
+  DCHECK_EQ(1u, arguments.size());
   DCHECK(arguments[0]->isNative());
-  DCHECK(static_cast<std::size_t>(tuple_accessor->getNumTuples()) ==
-         static_cast<const NativeColumnVector*>(arguments[0])->size());
-  
+  DCHECK_EQ(static_cast<std::size_t>(tuple_accessor->getNumTuples()),
+            static_cast<const NativeColumnVector*>(arguments[0])->size());
+
   // Initialize the output column and argument accessor.
   NativeColumnVector *window_aggregates =
       new NativeColumnVector(*result_type_, tuple_accessor->getNumTuples());
   ColumnVectorsValueAccessor* argument_accessor = new ColumnVectorsValueAccessor();
   argument_accessor->addColumn(arguments[0]);
-  
+
   // Create a window for each tuple and calculate the window aggregate.
   tuple_accessor->beginIteration();
   argument_accessor->beginIteration();
-      
+
   while (tuple_accessor->next() && argument_accessor->next()) {
     const TypedValue window_aggregate = this->calculateOneWindow(tuple_accessor,
                                                                  argument_accessor,
@@ -137,11 +137,11 @@ TypedValue WindowAggregationHandleAvg::calculateOneWindow(
   // Initialize.
   TypedValue sum = sum_type_->makeZeroValue();
   TypedValue current_value = argument_accessor->getTypedValue(0);
-  
+
   sum = fast_add_operator_->
       applyToTypedValues(sum, current_value);
   std::uint64_t count = 1;
-  
+
   // Get the partition key for the current row.
   std::vector<TypedValue> current_row_partition_key;
   for (attribute_id partition_by_id : partition_by_ids) {
@@ -151,7 +151,7 @@ TypedValue WindowAggregationHandleAvg::calculateOneWindow(
 
   // Get current position.
   tuple_id current_tuple_id = tuple_accessor->getCurrentPositionVirtual();
-  
+
   // Find preceding tuples.
   int count_preceding = 0;
   tuple_id preceding_tuple_id = current_tuple_id;
@@ -176,12 +176,12 @@ TypedValue WindowAggregationHandleAvg::calculateOneWindow(
     count_preceding++;
     TypedValue preceding_value =
         argument_accessor->getTypedValueAtAbsolutePosition(0, preceding_tuple_id);
-        
+
     // If a null value is in the window, return a null value.
     if (preceding_value.isNull()) {
       return TypedValue(result_type_->getTypeID());
     }
-    
+
     sum = fast_add_operator_->applyToTypedValues(sum, preceding_value);
   }
 
@@ -211,12 +211,12 @@ TypedValue WindowAggregationHandleAvg::calculateOneWindow(
     count_following++;
     TypedValue following_value =
         argument_accessor->getTypedValueAtAbsolutePosition(0, following_tuple_id);
-        
+
     // If a null value is in the window, return a null value.
     if (following_value.isNull()) {
       return TypedValue(result_type_->getTypeID());
     }
-    
+
     sum = fast_add_operator_->applyToTypedValues(sum, following_value);
   }
 

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/WindowAggregationHandleAvg.hpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/WindowAggregationHandleAvg.hpp b/expressions/window_aggregation/WindowAggregationHandleAvg.hpp
index 18b801e..e0b630a 100644
--- a/expressions/window_aggregation/WindowAggregationHandleAvg.hpp
+++ b/expressions/window_aggregation/WindowAggregationHandleAvg.hpp
@@ -68,12 +68,7 @@ class WindowAggregationHandleAvg : public WindowAggregationHandle {
   /**
    * @brief Constructor.
    *
-   * @param partition_by_ids The attribute_id of partition keys in
-   *                         attribute_accessor.
-   * @param is_row True if the frame mode is ROWS, false if it is RANGE.
-   * @param num_preceding The number of rows/range that precedes the current row.
-   * @param num_following The number of rows/range that follows the current row.
-   * @param storage_manager A pointer to the storage manager.
+   * @param partition_key_types The Types of the partition key.
    * @param type Type of the avg value.
    **/
   explicit WindowAggregationHandleAvg(std::vector<const Type*> &&partition_key_types,

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/expressions/window_aggregation/tests/WindowAggregationHandleAvg_unittest.cpp
----------------------------------------------------------------------
diff --git a/expressions/window_aggregation/tests/WindowAggregationHandleAvg_unittest.cpp b/expressions/window_aggregation/tests/WindowAggregationHandleAvg_unittest.cpp
index 9d3d2d8..a48a654 100644
--- a/expressions/window_aggregation/tests/WindowAggregationHandleAvg_unittest.cpp
+++ b/expressions/window_aggregation/tests/WindowAggregationHandleAvg_unittest.cpp
@@ -62,7 +62,7 @@ namespace {
 
 // Attribute value could be null if set true.
 class WindowAggregationHandleAvgTest : public::testing::TestWithParam<bool> {
- protected: 
+ protected:
   // Handle initialization.
   void initializeHandle(const Type &argument_type) {
     const WindowAggregateFunction &function =
@@ -126,7 +126,7 @@ class WindowAggregationHandleAvgTest : public::testing::TestWithParam<bool> {
         createArgumentGeneric<GenericType>(&argument_cpp_vector);
     NativeColumnVector *partition_key_vector =
       new NativeColumnVector(IntType::InstanceNonNullable(), kNumTuples + 2);
-        
+
     for (int i = 0; i < kNumTuples; ++i) {
       partition_key_vector->appendTypedValue(TypedValue(i / kNumTuplesPerPartition));
     }
@@ -161,13 +161,13 @@ class WindowAggregationHandleAvgTest : public::testing::TestWithParam<bool> {
       }
 
       typename GenericType::cpptype *val = new typename GenericType::cpptype;
-      
+
       if (type.getTypeID() == kInt || type.getTypeID() == kLong) {
         SetDataType(i - 10, val);
       } else {
         SetDataType(static_cast<float>(i - 10) / 10, val);
       }
-      
+
       column->appendTypedValue(type.makeValue(val));
       argument_cpp_vector->push_back(val);
     }
@@ -183,7 +183,7 @@ class WindowAggregationHandleAvgTest : public::testing::TestWithParam<bool> {
     arguments.push_back(argument_type_vector);
     // The partition key index is 0.
     std::vector<attribute_id> partition_key(1, 0);
-    
+
     ColumnVector *result =
         handle_avg_->calculate(tuple_accessor,
                                std::move(arguments),
@@ -191,7 +191,7 @@ class WindowAggregationHandleAvgTest : public::testing::TestWithParam<bool> {
                                true  /* is_row */,
                                -1  /* num_preceding: UNBOUNDED PRECEDING */,
                                0  /* num_following: CURRENT ROW */);
-                           
+
     // Get the cpptype result.
     std::vector<typename OutputType::cpptype*> result_cpp_vector;
     bool is_null;
@@ -233,7 +233,7 @@ class WindowAggregationHandleAvgTest : public::testing::TestWithParam<bool> {
     arguments.push_back(argument_type_vector);
     // The partition key index is 0.
     std::vector<attribute_id> partition_key(1, 0);
-    
+
     ColumnVector *result =
         handle_avg_->calculate(tuple_accessor,
                                std::move(arguments),
@@ -241,17 +241,17 @@ class WindowAggregationHandleAvgTest : public::testing::TestWithParam<bool> {
                                true  /* is_row */,
                                kNumPreceding,
                                kNumFollowing);
-                           
+
     // Get the cpptype result.
     // For each value, calculate all surrounding values in the window.
     std::vector<typename OutputType::cpptype*> result_cpp_vector;
-    
+
     for (std::size_t i = 0; i < argument_cpp_vector.size(); ++i) {
       if (argument_cpp_vector[i] == nullptr) {
         result_cpp_vector.push_back(nullptr);
         continue;
       }
-      
+
       typename GenericType::cpptype sum;
       SetDataType(0, &sum);
       sum += *argument_cpp_vector[i];

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/query_optimizer/tests/execution_generator/Select.test
----------------------------------------------------------------------
diff --git a/query_optimizer/tests/execution_generator/Select.test b/query_optimizer/tests/execution_generator/Select.test
index 16127cc..f290059 100644
--- a/query_optimizer/tests/execution_generator/Select.test
+++ b/query_optimizer/tests/execution_generator/Select.test
@@ -953,19 +953,79 @@ WHERE double_col < 0
 ==
 
 # Window Aggregation Test.
-# Currently this is not supported, an empty table will be returned.
-SELECT avg(int_col) OVER w FROM test
+SELECT char_col, long_col, avg(long_col) OVER w FROM test
 WINDOW w AS
-(PARTITION BY char_col
- ORDER BY long_col DESC NULLS LAST
+(ORDER BY char_col DESC NULLS LAST
  ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW);
 --
-+------------------------+
-|avg(int_col)            |
-+------------------------+
-+------------------------+
++--------------------+--------------------+------------------------+
+|char_col            |long_col            |avg(long_col)           |
++--------------------+--------------------+------------------------+
+|          8 2.828427|                  64|                      64|
+|          6 2.449490|                  36|                      50|
+|          4 2.000000|                  16|      38.666666666666664|
+|         24 4.898979|                 576|                     173|
+|         22 4.690416|                 484|      235.19999999999999|
+|         20 4.472136|                 400|      262.66666666666669|
+|          2 1.414214|                   4|      225.71428571428572|
+|         18 4.242641|                 324|                     238|
+|         16 4.000000|                 256|                     240|
+|         14 3.741657|                 196|      235.59999999999999|
+|         12 3.464102|                 144|      227.27272727272728|
+|         10 3.162278|                 100|      216.66666666666666|
+|          0 0.000000|                   0|                     200|
+|         -9 3.000000|                  81|                   191.5|
+|         -7 2.645751|                  49|                     182|
+|         -5 2.236068|                  25|                172.1875|
+|         -3 1.732051|                   9|      162.58823529411765|
+|        -23 4.795832|                 529|      182.94444444444446|
+|        -21 4.582576|                 441|      196.52631578947367|
+|        -19 4.358899|                 361|                  204.75|
+|        -17 4.123106|                 289|      208.76190476190476|
+|        -15 3.872983|                 225|                   209.5|
+|        -13 3.605551|                 169|       207.7391304347826|
+|        -11 3.316625|                 121|                 204.125|
+|         -1 1.000000|                   1|                     196|
++--------------------+--------------------+------------------------+
 ==
 
+SELECT long_col, int_col, avg(int_col) OVER w FROM test
+WINDOW w AS
+(ORDER BY long_col DESC NULLS LAST
+ ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING);
+--
++--------------------+-----------+------------------------+
+|long_col            |int_col    |avg(int_col)            |
++--------------------+-----------+------------------------+
+|                 576|         24|       7.666666666666667|
+|                 529|        -23|                     0.5|
+|                 484|         22|                    NULL|
+|                 441|        -21|                    NULL|
+|                 400|       NULL|                    NULL|
+|                 361|        -19|                    NULL|
+|                 324|         18|                    NULL|
+|                 289|        -17|     -3.3999999999999999|
+|                 256|         16|      3.2000000000000002|
+|                 225|        -15|                      -3|
+|                 196|         14|      2.7999999999999998|
+|                 169|        -13|     -2.6000000000000001|
+|                 144|         12|                    NULL|
+|                 121|        -11|                    NULL|
+|                 100|       NULL|                    NULL|
+|                  81|         -9|                    NULL|
+|                  64|          8|                    NULL|
+|                  49|         -7|     -1.3999999999999999|
+|                  36|          6|                     1.2|
+|                  25|         -5|                      -1|
+|                  16|          4|     0.80000000000000004|
+|                   9|         -3|    -0.59999999999999998|
+|                   4|          2|                    NULL|
+|                   1|         -1|                    NULL|
+|                   0|       NULL|                    NULL|
++--------------------+-----------+------------------------+
+==
+
+# Currently this is not supported, an empty table will be returned.
 SELECT int_col, sum(float_col) OVER
 (PARTITION BY char_col, long_col
  ORDER BY double_col DESC NULLS LAST, int_col ASC NULLS FIRST
@@ -987,5 +1047,5 @@ WINDOW w AS
 +------------------------+
 |sum(avg(int_col))       |
 +------------------------+
-|                    NULL|
+|                     -18|
 +------------------------+

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/relational_operators/WindowAggregationOperator.cpp
----------------------------------------------------------------------
diff --git a/relational_operators/WindowAggregationOperator.cpp b/relational_operators/WindowAggregationOperator.cpp
index 2b1870a..8939ac2 100644
--- a/relational_operators/WindowAggregationOperator.cpp
+++ b/relational_operators/WindowAggregationOperator.cpp
@@ -42,8 +42,9 @@ bool WindowAggregationOperator::getAllWorkOrders(
   DCHECK(query_context != nullptr);
 
   if (blocking_dependencies_met_ && !generated_) {
-    std::vector<block_id> relation_blocks = input_relation_.getBlocksSnapshot();
-    
+    std::vector<block_id> relation_blocks =
+        input_relation_.getBlocksSnapshot();
+
     container->addNormalWorkOrder(
         new WindowAggregationWorkOrder(
             query_id_,
@@ -72,7 +73,7 @@ serialization::WorkOrder* WindowAggregationOperator::createWorkOrderProto() {
   proto->set_query_id(query_id_);
   proto->SetExtension(serialization::WindowAggregationWorkOrder::window_aggr_state_index,
                       window_aggregation_state_index_);
-                      
+
   std::vector<block_id> relation_blocks = input_relation_.getBlocksSnapshot();
   for (block_id bid : relation_blocks) {
     proto->AddExtension(serialization::WindowAggregationWorkOrder::block_ids, bid);

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/relational_operators/WindowAggregationOperator.hpp
----------------------------------------------------------------------
diff --git a/relational_operators/WindowAggregationOperator.hpp b/relational_operators/WindowAggregationOperator.hpp
index 02482a0..bd83248 100644
--- a/relational_operators/WindowAggregationOperator.hpp
+++ b/relational_operators/WindowAggregationOperator.hpp
@@ -121,6 +121,7 @@ class WindowAggregationWorkOrder : public WorkOrder {
    *
    * @param query_id The ID of this query.
    * @param state The WindowAggregationOperatorState to use.
+   * @param block_ids The blocks' id of the input relation.
    * @param output_destination The InsertDestination for output.
    **/
   WindowAggregationWorkOrder(const std::size_t query_id,

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/storage/WindowAggregationOperationState.cpp
----------------------------------------------------------------------
diff --git a/storage/WindowAggregationOperationState.cpp b/storage/WindowAggregationOperationState.cpp
index 668af9b..8d7cfbb 100644
--- a/storage/WindowAggregationOperationState.cpp
+++ b/storage/WindowAggregationOperationState.cpp
@@ -68,7 +68,6 @@ WindowAggregationOperationState::WindowAggregationOperationState(
       storage_manager_(storage_manager) {
   // Get the Types of this window aggregate's arguments so that we can create an
   // AggregationHandle.
-  // TODO(Shixuan): Next step: New handles for window aggregation function.
   std::vector<const Type*> argument_types;
   for (const std::unique_ptr<const Scalar> &argument : arguments_) {
     argument_types.emplace_back(&argument->getType());
@@ -175,19 +174,34 @@ bool WindowAggregationOperationState::ProtoIsValid(const serialization::WindowAg
 void WindowAggregationOperationState::windowAggregateBlocks(
     InsertDestination *output_destination,
     const std::vector<block_id> &block_ids) {
+  // TODO(Shixuan): This is a quick fix for currently unsupported functions in
+  // order to pass the query_optimizer test.
+  if (window_aggregation_handle_.get() == nullptr) {
+    std::cout << "The function will be supported in the near future :)\n";
+    return;
+  }
+
+  // TODO(Shixuan): RANGE frame mode should be supported to make SQL grammar
+  // work. This will need Order Key to be passed so that we know where the
+  // window should start and end.
+  if (!is_row_) {
+    std::cout << "Currently we don't support RANGE frame mode :(\n";
+    return;
+  }
+
   // Get the total number of tuples.
   int num_tuples = 0;
   for (block_id block_idx : block_ids) {
     num_tuples +=
         storage_manager_->getBlock(block_idx, input_relation_)->getNumTuples();
   }
-  
+
   // Construct column vectors for attributes.
   std::vector<ColumnVector*> attribute_vecs;
   for (std::size_t attr_id = 0; attr_id < input_relation_.size(); ++attr_id) {
     const CatalogAttribute *attr = input_relation_.getAttributeById(attr_id);
     const Type &type = attr->getType();
-    
+
     if (NativeColumnVector::UsableForType(type)) {
       attribute_vecs.push_back(new NativeColumnVector(type, num_tuples));
     } else {
@@ -207,6 +221,7 @@ void WindowAggregationOperationState::windowAggregateBlocks(
     }
   }
 
+  // TODO(Shixuan): Add Support for Vector Copy Elision Selection.
   // Add tuples and arguments into ColumnVectors.
   for (block_id block_idx : block_ids) {
     BlockReference block = storage_manager_->getBlock(block_idx, input_relation_);
@@ -222,7 +237,7 @@ void WindowAggregationOperationState::windowAggregateBlocks(
     }
 
     InvokeOnAnyValueAccessor(tuple_accessor,
-                             [&] (auto *tuple_accessor) -> void {
+                             [&] (auto *tuple_accessor) -> void {  // NOLINT(build/c++11)
       tuple_accessor->beginIteration();
       argument_accessor->beginIteration();
 

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/727761bb/storage/WindowAggregationOperationState.hpp
----------------------------------------------------------------------
diff --git a/storage/WindowAggregationOperationState.hpp b/storage/WindowAggregationOperationState.hpp
index 3225b66..141fbc5 100644
--- a/storage/WindowAggregationOperationState.hpp
+++ b/storage/WindowAggregationOperationState.hpp
@@ -25,20 +25,20 @@
 #include <vector>
 
 #include "catalog/CatalogTypedefs.hpp"
-#include "expressions/window_aggregation/WindowAggregationHandle.hpp"
 #include "expressions/scalar/Scalar.hpp"
 #include "expressions/scalar/ScalarAttribute.hpp"
+#include "expressions/window_aggregation/WindowAggregationHandle.hpp"
 #include "storage/StorageBlockInfo.hpp"
 #include "storage/WindowAggregationOperationState.pb.h"
 #include "utility/Macros.hpp"
 
 namespace quickstep {
 
-class WindowAggregateFunction;
 class CatalogDatabaseLite;
 class CatalogRelationSchema;
 class InsertDestination;
 class StorageManager;
+class WindowAggregateFunction;
 
 /** \addtogroup Storage
  *  @{
@@ -63,8 +63,7 @@ class WindowAggregationOperationState {
    *                      current row. -1 means UNBOUNDED PRECEDING.
    * @param num_following The number of rows/range for the tuples following the
    *                      current row. -1 means UNBOUNDED FOLLOWING.
-   * @param storage_manager The StorageManager to use for allocating hash
-   *        tables.
+   * @param storage_manager The StorageManager to get block references.
    */
   WindowAggregationOperationState(const CatalogRelationSchema &input_relation,
                                   const WindowAggregateFunction *window_aggregate_function,
@@ -111,6 +110,7 @@ class WindowAggregationOperationState {
    *
    * @param output_destination The output destination for the computed window
    *                           aggregate.
+   * @param block_ids The id of the blocks to be computed.
    **/
   void windowAggregateBlocks(InsertDestination *output_destination,
                              const std::vector<block_id> &block_ids);
@@ -118,11 +118,7 @@ class WindowAggregationOperationState {
  private:
   const CatalogRelationSchema &input_relation_;
   const std::vector<block_id> block_ids_;
-
-  // TODO(Shixuan): Handle and State for window aggregation will be needed for
-  //                actual calculation.
   std::unique_ptr<WindowAggregationHandle> window_aggregation_handle_;
-  
   std::vector<std::unique_ptr<const Scalar>> arguments_;
   std::vector<attribute_id> partition_by_ids_;
 
@@ -133,12 +129,6 @@ class WindowAggregationOperationState {
 
   StorageManager *storage_manager_;
 
-#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.
-  std::vector<attribute_id> arguments_as_attributes_;
-#endif
-
   DISALLOW_COPY_AND_ASSIGN(WindowAggregationOperationState);
 };
 


Mime
View raw message