Conversion to relational algebra

compiler/CMakeLists.txt

@@ -66,6 +66,7 @@ endif ()
 
 # Directories with MLIR dialects
 add_subdirectory(include/graphalg)
+add_subdirectory(include/garel)
 
 add_subdirectory(src)
 add_subdirectory(test)

compiler/include/garel/CMakeLists.txt

@@ -0,0 +1,15 @@
+include_directories(SYSTEM ${MLIR_INCLUDE_DIRS})
+include_directories(SYSTEM ${PROJECT_BINARY_DIR}/include)
+
+set(LLVM_TARGET_DEFINITIONS GARelAttr.td)
+mlir_tablegen(GARelEnumAttr.h.inc -gen-enum-decls)
+mlir_tablegen(GARelEnumAttr.cpp.inc -gen-enum-defs)
+mlir_tablegen(GARelAttr.h.inc --gen-attrdef-decls)
+mlir_tablegen(GARelAttr.cpp.inc -gen-attrdef-defs)
+
+set(LLVM_TARGET_DEFINITIONS GARelOps.td)
+add_mlir_dialect(GARelOps garel)
+
+set(LLVM_TARGET_DEFINITIONS GARelPasses.td)
+mlir_tablegen(GARelPasses.h.inc --gen-pass-decls)
+add_public_tablegen_target(MLIRGARelPassesIncGen)

compiler/include/garel/GARelAttr.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <mlir/IR/Attributes.h>
+#include <mlir/IR/BuiltinAttributes.h>
+
+#include "garel/GARelEnumAttr.h.inc"
+
+namespace garel {
+
+/** Reference to a column inside of \c RelationType or \c TupleType. */
+using ColumnIdx = std::int32_t;
+
+} // namespace garel
+
+#define GET_ATTRDEF_CLASSES
+#include "garel/GARelAttr.h.inc"

compiler/include/garel/GARelAttr.td

@@ -0,0 +1,72 @@
+#ifndef GAREL_ATTR
+#define GAREL_ATTR
+
+include "mlir/IR/BuiltinAttributeInterfaces.td"
+
+include "GARelDialect.td"
+
+class GARel_Attr<string name, string attrMnemonic, list<Trait> traits = []>
+        : AttrDef<GARel_Dialect, name, traits> {
+    let mnemonic = attrMnemonic;
+}
+
+def JoinPredicate : GARel_Attr<"JoinPredicate", "join_pred"> {
+    let summary = "A binary equality join predicate";
+
+    let parameters = (ins
+        "std::int32_t":$lhsRelIdx,
+        "ColumnIdx":$lhsColIdx,
+        "std::int32_t":$rhsRelIdx,
+        "ColumnIdx":$rhsColIdx);
+
+    let assemblyFormat = [{
+        `<` $lhsRelIdx `[` $lhsColIdx `]` `=` $rhsRelIdx `[` $rhsColIdx `]` `>`
+    }];
+}
+
+def JoinPredicates : ArrayOfAttr<
+        GARel_Dialect,
+        "JoinPredicates",
+        "join_preds",
+        "JoinPredicateAttr">;
+
+def AggregateFunc : I64EnumAttr<
+    "AggregateFunc", "",
+    [
+        I64EnumAttrCase<"SUM", 0>,
+        I64EnumAttrCase<"MIN", 1>,
+        I64EnumAttrCase<"MAX", 2>,
+        I64EnumAttrCase<"LOR", 3>, /* Logical OR (over i1) */
+        I64EnumAttrCase<"ARGMIN", 4>,
+    ]
+> {
+    let cppNamespace = "::garel";
+}
+
+// NOTE: assumes an aggregator produces exactly one output column.
+def Aggregator : GARel_Attr<"Aggregator", "aggregator"> {
+    let summary = "Aggregate function with bound input columns";
+
+    let parameters = (ins
+        "AggregateFunc":$func,
+        ArrayRefParameter<"ColumnIdx">:$inputs);
+
+    let assemblyFormat = [{
+        `<` $func $inputs `>`
+    }];
+
+    let genVerifyDecl = 1;
+
+    let extraClassDeclaration = [{
+        /** Type for values in the output column. */
+        mlir::Type getResultType(::mlir::Type relType);
+    }];
+}
+
+def Aggregators : ArrayOfAttr<
+        GARel_Dialect,
+        "Aggregators",
+        "aggregators",
+        "AggregatorAttr">;
+
+#endif // GAREL_ATTR

compiler/include/garel/GARelDialect.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <mlir/IR/Dialect.h>
+#include <mlir/Interfaces/SideEffectInterfaces.h>
+
+#include "garel/GARelOpsDialect.h.inc"

compiler/include/garel/GARelDialect.td

@@ -0,0 +1,27 @@
+#ifndef GAREL_DIALECT
+#define GAREL_DIALECT
+
+include "mlir/Interfaces/SideEffectInterfaces.td"
+include "mlir/IR/EnumAttr.td"
+include "mlir/IR/OpBase.td"
+
+def GARel_Dialect : Dialect {
+    let name = "garel";
+    let cppNamespace = "::garel";
+
+    let extraClassDeclaration = [{
+    private:
+        void registerAttributes();
+        void registerTypes();
+    }];
+
+    let usePropertiesForAttributes = 1;
+    let useDefaultAttributePrinterParser = 1;
+    let useDefaultTypePrinterParser = 1;
+}
+
+// NOTE: GARel ops are always 'Pure'
+class GARel_Op<string mnemonic, list<Trait> traits = []> :
+        Op<GARel_Dialect, mnemonic, !listconcat(traits, [Pure])>;
+
+#endif // GAREL_DIALECT

compiler/include/garel/GARelOps.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <mlir/Bytecode/BytecodeOpInterface.h>
+#include <mlir/IR/BuiltinAttributes.h>
+#include <mlir/IR/OpDefinition.h>
+#include <mlir/IR/OpImplementation.h>
+#include <mlir/IR/OperationSupport.h>
+#include <mlir/IR/Region.h>
+#include <mlir/Interfaces/InferTypeOpInterface.h>
+#include <mlir/Interfaces/SideEffectInterfaces.h>
+
+#include "garel/GARelTypes.h"
+
+#define GET_OP_CLASSES
+#include "garel/GARelOps.h.inc"

compiler/include/garel/GARelOps.td

@@ -0,0 +1,224 @@
+#ifndef GAREL_OPS
+#define GAREL_OPS
+
+/**
+ * Relation-level ops in the GARel dialect.
+ *
+ * See ./GARelTupleOps.td for the tuple-level ops.
+ */
+
+include "mlir/Interfaces/InferTypeOpInterface.td"
+
+include "GARelDialect.td"
+include "GARelTypes.td"
+
+// Per-tuple ops kept in a separate file.
+include "GARelTupleOps.td"
+
+def ProjectOp : GARel_Op<"project", [IsolatedFromAbove]> {
+    let summary = "Remaps, reorders, drops and computes columns";
+
+    let arguments = (ins Relation:$input);
+
+    let regions = (region SizedRegion<1>:$projections);
+
+    let results = (outs Relation:$result);
+
+    let assemblyFormat = [{
+        $input `:` type($input) `->` type($result) $projections attr-dict
+    }];
+
+    let hasRegionVerifier = 1;
+
+    let extraClassDeclaration = [{
+        mlir::Block& createProjectionsBlock();
+        ProjectReturnOp getTerminator();
+    }];
+}
+
+def ProjectReturnOp : GARel_Op<"project.return", [
+        Terminator,
+        HasParent<"ProjectOp">]> {
+    let summary = "The output projections";
+
+    let arguments = (ins Variadic<ColumnType>:$projections);
+
+    let assemblyFormat = [{
+        $projections `:` type($projections) attr-dict
+    }];
+
+    // NOTE: verification performed by ProjectOp
+}
+
+def SelectOp : GARel_Op<"select", [
+        SameOperandsAndResultType,
+        IsolatedFromAbove]> {
+    let summary = "Removes tuples that fail (one of) the predicates";
+
+    let arguments = (ins Relation:$input);
+    let regions = (region SizedRegion<1>:$predicates);
+
+    let results = (outs Relation:$result);
+
+    let assemblyFormat = [{
+        $input `:` type($input) $predicates attr-dict
+    }];
+
+    let hasRegionVerifier = 1;
+
+    let extraClassDeclaration = [{
+        mlir::Block& createPredicatesBlock();
+        SelectReturnOp getTerminator();
+    }];
+}
+
+def SelectReturnOp : GARel_Op<"select.return", [
+        Terminator,
+        HasParent<"SelectOp">]> {
+    let summary = "Return the select predicates";
+
+    let arguments = (ins Variadic<I1>:$predicates);
+
+    let assemblyFormat = [{
+        $predicates attr-dict
+    }];
+}
+
+def JoinOp : GARel_Op<"join", [InferTypeOpAdaptor]> {
+    let summary = "Natural (equi)join of relations";
+
+    let arguments = (ins
+        // NOTE: All inputs must have distinct columns
+        Variadic<Relation>:$inputs,
+        // NOTE: Equality predicates only
+        JoinPredicates:$predicates);
+
+    let results = (outs Relation:$result);
+
+    let assemblyFormat = [{
+        $inputs `:` type($inputs)
+        $predicates
+        attr-dict
+    }];
+
+    let hasVerifier = 1;
+    let hasFolder = 1;
+}
+
+def UnionOp : GARel_Op<"union", [SameOperandsAndResultType]> {
+    let summary = "Union of relations";
+
+    let arguments = (ins Variadic<Relation>:$inputs);
+
+    let results = (outs Relation:$result);
+
+    let assemblyFormat = [{
+        $inputs `:` type($inputs)
+        attr-dict
+    }];
+
+    let hasFolder = 1;
+}
+
+def AggregateOp : GARel_Op<"aggregate", [InferTypeOpAdaptor]> {
+    let summary = "Groups tuples by key columns, aggregating values of other columns";
+
+    let arguments = (ins
+        Relation:$input,
+        DenseI32ArrayAttr:$groupBy,
+        Aggregators:$aggregators);
+
+    let results = (outs Relation:$result);
+
+    let assemblyFormat = [{
+        $input `:` type($input)
+        `group_by` `` `=` `` $groupBy
+        `aggregators` `` `=` `` $aggregators
+        attr-dict
+    }];
+}
+
+def ForOp : GARel_Op<"for", [InferTypeOpAdaptor]> {
+    let summary = "Bounded iteration";
+
+    let arguments = (ins
+        Variadic<Relation>:$init,
+        I64Attr:$iters,
+        I64Attr:$resultIdx);
+
+    let regions = (region
+        SizedRegion<1>:$body,
+        MaxSizedRegion<1>:$until);
+
+    let results = (outs Relation:$result);
+
+    let assemblyFormat = [{
+        $init `:` type($init)
+        `iters` `` `=` `` $iters
+        `result_idx` `` `=` `` $resultIdx
+        $body
+        (`until` $until^)?
+        attr-dict
+    }];
+
+    let hasVerifier = 1;
+    let hasRegionVerifier = 1;
+}
+
+def ForYieldOp : GARel_Op<"for.yield", [
+        Terminator,
+        HasParent<"ForOp">]> {
+    let summary = "Produces the iter args for the next iteration";
+
+    let arguments = (ins Variadic<Relation>:$inputs);
+
+    let assemblyFormat = [{
+        $inputs `:` type($inputs)
+        attr-dict
+    }];
+
+    // Note: verification performed by parent ForOp.
+}
+
+def RangeOp : GARel_Op<"range", [InferTypeOpAdaptor]> {
+    let summary = "generates a range of `index` values from `[0, size)`";
+
+    let arguments = (ins I64Attr:$size);
+
+    let results = (outs Relation:$result);
+
+    let assemblyFormat = [{
+        $size attr-dict
+    }];
+}
+
+def RemapOp : GARel_Op<"remap", [InferTypeOpAdaptor]> {
+    let summary = "reorders or drop columns";
+
+    let arguments = (ins Relation:$input, DenseI32ArrayAttr:$remap);
+
+    let results = (outs Relation:$result);
+
+    let assemblyFormat = [{
+        $input `:` type($input)
+        $remap
+        attr-dict
+    }];
+
+    let hasVerifier = 1;
+    let hasFolder = 1;
+}
+
+def ConstantOp : GARel_Op<"const", [InferTypeOpAdaptor]> {
+    let summary = "A relation with one constant-value tuple";
+
+    let arguments = (ins TypedAttrInterface:$value);
+
+    let results = (outs Relation:$result);
+
+    let assemblyFormat = [{
+        $value attr-dict
+    }];
+}
+
+#endif // GAREL_OPS