Initial Project Skeleton

Author: alexbaden

.clang-format

@@ -0,0 +1,7 @@
+BasedOnStyle:  Chromium
+BinPackArguments: false
+BinPackParameters: false
+ColumnLimit:     90
+IndentWidth:     2
+BreakConstructorInitializers: BeforeComma
+IncludeBlocks:   Preserve

.gitignore

@@ -0,0 +1,2 @@
+build/*
+.vscode

CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.18.2)
+
+project(
+    HeterogeneousDataKernels
+    VERSION 0.1
+    LANGUAGES CXX
+)
+
+# set default build type to "Release w/ Debug Info" 
+set(default_build_type "RelWithDebInfo")
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
+  set(CMAKE_BUILD_TYPE "${default_build_type}" CACHE
+      STRING "Choose the type of build." FORCE)
+  # Set the possible values of build type for cmake-gui
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
+    "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+add_subdirectory(src)
+
+add_executable(TestDriver apps/TestDriver.cpp)
+
+target_link_libraries(TestDriver PRIVATE HDK)
+target_include_directories(TestDriver PRIVATE src/)

apps/TestDriver.cpp

@@ -0,0 +1,14 @@
+#include "HDK.h"
+
+#include <iostream>
+#include <memory>
+
+int main(void) {
+  auto input_data_type = std::make_unique<hdk::Int>();
+  auto input_data = std::make_unique<hdk::Column>(std::move(input_data_type));
+  auto output_type = std::make_unique<hdk::Int>();
+  auto agg_expr = std::make_unique<hdk::Aggregate>(
+      std::move(output_type), hdk::Aggregate::AggType::kCOUNT, std::move(input_data));
+
+  std::cout << "Test program worked: " << agg_expr->toString() << std::endl;
+}

src/CMakeLists.txt

@@ -0,0 +1,4 @@
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/)
+
+add_library(HDK HDK.h HDK.cpp Expression/Expression.cpp) 
+

src/Expression/Expression.cpp

@@ -0,0 +1,30 @@
+#include "Expression/Expression.h"
+
+namespace hdk {
+
+std::string Column::toString() const {
+  return "Column: " + type_->toString();
+}
+
+std::string Aggregate::toString() const {
+  return "Aggregate: " + aggTypeToString(agg_type_) + " (" + type_->toString() +
+         ") over " + target_expression_->toString();
+}
+
+std::string Aggregate::aggTypeToString(const AggType type) {
+  switch (type) {
+    case AggType::kAVG:
+      return "AVG";
+    case AggType::kMIN:
+      return "MIN";
+    case AggType::kMAX:
+      return "MAX";
+    case AggType::kSUM:
+      return "SUM";
+    case AggType::kCOUNT:
+      return "COUNT";
+  }
+  return "";
+}
+
+}  // namespace hdk

src/Expression/Expression.h

@@ -0,0 +1,52 @@
+#include "Expression/Types.h"
+
+#include <memory>
+#include <string>
+
+namespace hdk {
+
+class Expression {
+ public:
+  Expression(std::unique_ptr<Type>&& type) : type_(std::move(type)) {}
+
+  virtual ~Expression() = default;
+
+  virtual std::string toString() const = 0;
+
+  Type* getTypeInfo() const { return type_.get(); }
+
+ protected:
+  std::unique_ptr<Type> type_;
+};
+
+class Column : public Expression {
+ public:
+  Column(std::unique_ptr<Type>&& type) : Expression(std::move(type)) {}
+
+  std::string toString() const override;
+};
+
+// TODO: consider computing the output type based on the target expression over which we
+// are performing the aggregate
+class Aggregate : public Expression {
+ public:
+  enum class AggType { kAVG, kMIN, kMAX, kSUM, kCOUNT };
+
+  Aggregate(std::unique_ptr<Type>&& type,
+            const AggType aggregate_type,
+            std::unique_ptr<Expression>&& target_expression)
+      : Expression(std::move(type))
+      , agg_type_(aggregate_type)
+      , target_expression_(std::move(target_expression)) {}
+
+  std::string toString() const override;
+
+  AggType getAggType() const { return agg_type_; }
+  static std::string aggTypeToString(const AggType type);
+
+ private:
+  AggType agg_type_;
+  std::unique_ptr<Expression> target_expression_;
+};
+
+}  // namespace hdk

src/Expression/Types.h

@@ -0,0 +1,63 @@
+#include <cstdint>
+#include <string>
+
+namespace hdk {
+
+class Type {
+ public:
+  virtual ~Type() = default;
+
+  virtual int32_t size() const = 0;
+  virtual std::string toString() const = 0;
+};
+
+class TinyInt : public Type {
+ public:
+  int32_t size() const override { return 1; }
+
+  std::string toString() const override { return "TINYINT"; }
+};
+
+class SmallInt : public Type {
+ public:
+  int32_t size() const override { return 2; }
+
+  std::string toString() const override { return "SMALLINT"; }
+};
+
+class Int : public Type {
+ public:
+  int32_t size() const override { return 4; }
+
+  std::string toString() const override { return "INT"; }
+};
+
+class BigInt : public Type {
+ public:
+  int32_t size() const override { return 8; }
+
+  std::string toString() const override { return "BIGINT"; }
+};
+
+class Float : public Type {
+ public:
+  int32_t size() const override { return 4; }
+
+  std::string toString() const override { return "FLOAT"; }
+};
+
+class Double : public Type {
+ public:
+  int32_t size() const override { return 8; }
+
+  std::string toString() const override { return "DOUBLE"; }
+};
+
+class String : public Type {
+ public:
+  int32_t size() const override { return -1; }
+
+  std::string toString() const override { return "STRING"; }
+};
+
+}  // namespace hdk

src/HDK.cpp

@@ -0,0 +1 @@
+#include "HDK.h"

src/HDK.h

@@ -0,0 +1 @@
+#include "Expression/Expression.h"