dsl-to-sql 1.0.0-fabric-1p-development.1

package/src/sql-lib/function.ts

@@ -0,0 +1,9 @@
+import { ExpressionValue, SqlFunction, ValueExpr } from '../sql-types';
+
+export function toFunction(name: ValueExpr<string>, args: ExpressionValue[]): SqlFunction {
+  return {
+    type: 'function',
+    name: { name: [name] },
+    args: { type: 'expr_list', value: args },
+  };
+}

package/src/sql-lib/join.ts

@@ -0,0 +1,14 @@
+import { Binary, Join } from '../sql-types';
+
+export type JoinType = 'INNER JOIN' | 'LEFT JOIN' | 'RIGHT JOIN';
+
+export function toJoin(joinType: JoinType, table: string, on: Binary): Join {
+  return {
+    type: 'from',
+    db: null,
+    table,
+    as: null,
+    join: joinType,
+    on,
+  };
+}

package/src/sql-lib/literal.ts

@@ -0,0 +1,15 @@
+import { Value } from '../sql-types';
+
+export enum DataType {
+  NUMBER = 'number',
+  STRING = 'string',
+  BOOLEAN = 'boolean',
+  NULL = 'null',
+}
+
+export function toValue(dataType: DataType, value: unknown): Value {
+  return {
+    type: dataType,
+    value,
+  };
+}

package/src/sql-lib/select.ts

@@ -0,0 +1,154 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { ParseContext } from '../js-lib/ParseContext';
+import {
+  Binary,
+  Column,
+  ColumnRef,
+  RawSqlExpression,
+  From,
+  Limit,
+  OrderBy,
+  Select,
+  SqlFunction,
+  ValueExpr,
+  With,
+  ExpressionValue,
+} from '../sql-types';
+
+export class SelectBuilder {
+  private columns: Column[] = [];
+  private from: From[] | null = null;
+  private where: Binary | SqlFunction | RawSqlExpression | null = null;
+  private qualify: RawSqlExpression | null = null;
+  private groupby: { columns: ColumnRef[] | null; modifiers: ValueExpr<string>[] } = {
+    columns: null,
+    modifiers: [],
+  };
+  private having: any[] | null = null;
+  private orderby: OrderBy[] | RawSqlExpression[] | null = null;
+  private limit: Limit | RawSqlExpression | null = null;
+  private withExpr: With[] | null = null;
+  private set_op: string | undefined = undefined;
+  private _next: Select | undefined = undefined;
+  private distinct: 'DISTINCT' | null = null;
+
+  public addColumns(columns: Column[]): SelectBuilder {
+    this.columns = columns;
+    return this;
+  }
+
+  public addFrom(from: From[]): SelectBuilder {
+    this.from = from;
+    return this;
+  }
+
+  public addWhere(where: Binary | SqlFunction | RawSqlExpression): SelectBuilder {
+    this.where = where;
+    return this;
+  }
+
+  public addQualify(qualify: RawSqlExpression): SelectBuilder {
+    this.qualify = qualify;
+    return this;
+  }
+
+  public addGroupby(groupby: {
+    columns: ColumnRef[];
+    modifiers: ValueExpr<string>[];
+  }): SelectBuilder {
+    this.groupby = groupby;
+    return this;
+  }
+
+  public addHaving(having: any[]): SelectBuilder {
+    this.having = having;
+    return this;
+  }
+
+  public addOrderby(orderby: OrderBy[] | RawSqlExpression[]): SelectBuilder {
+    this.orderby = orderby;
+    return this;
+  }
+
+  public addLimit(limit: Limit | RawSqlExpression): SelectBuilder {
+    this.limit = limit;
+    return this;
+  }
+
+  public addWith(withExpr: With[]): SelectBuilder {
+    this.withExpr = withExpr;
+    return this;
+  }
+
+  public addSetOp(set_op: string): SelectBuilder {
+    this.set_op = set_op;
+    return this;
+  }
+
+  public addNext(next: Select): SelectBuilder {
+    this._next = next;
+    return this;
+  }
+
+  public addDistinct(): SelectBuilder {
+    this.distinct = 'DISTINCT';
+    return this;
+  }
+
+  public build(): Select {
+    return {
+      type: 'select',
+      with: this.withExpr,
+      columns: this.columns,
+      from: this.from,
+      where: this.where,
+      qualify: this.qualify,
+      groupby: this.groupby,
+      having: this.having,
+      orderby: this.orderby,
+      limit: this.limit,
+      options: null,
+      distinct: this.distinct,
+      set_op: this.set_op,
+      _next: this._next,
+    };
+  }
+}
+
+export class WithBuilder {
+  private name: string | undefined;
+  private stmt: Select | undefined;
+
+  constructor(context: ParseContext) {
+    this.name = undefined;
+    this.stmt = undefined;
+    context.incrementCTECount();
+  }
+
+  public addName(name: string): WithBuilder {
+    this.name = name;
+    return this;
+  }
+
+  public addStmt(stmt: Select): WithBuilder {
+    this.stmt = stmt;
+    return this;
+  }
+
+  public build(): With {
+    if (!this.name || !this.stmt) {
+      throw new Error('name and statement are required');
+    }
+
+    return {
+      name: { value: this.name },
+      stmt: {
+        _parentheses: true,
+        tableList: [],
+        columnList: [],
+        ast: this.stmt,
+      },
+    };
+  }
+}

package/src/sql-lib/unary_expr.ts

@@ -0,0 +1,9 @@
+import { ExpressionValue, UnaryExpression } from '../sql-types';
+
+export function toUnaryExpression(operator: string, expr: ExpressionValue): UnaryExpression {
+  return {
+    type: 'unary_expr',
+    operator,
+    expr,
+  };
+}

package/src/sql-lib/when.ts

@@ -0,0 +1,15 @@
+import { Binary, ExpressionValue } from '../sql-types';
+
+export type WhenType = {
+  type: 'when';
+  cond: Binary;
+  result: ExpressionValue;
+};
+
+export function toWhen(cond: Binary, result: ExpressionValue): WhenType {
+  return {
+    type: 'when',
+    cond,
+    result,
+  };
+}