rado 0.4.4 → 0.4.6

package/dist/deno/lib/Formatter.js

@@ -0,0 +1,715 @@
+// src/lib/Formatter.ts
+import { ColumnType } from "../define/Column.ts";
+import { BinOpType, Expr, ExprData, ExprType, UnOpType } from "../define/Expr.ts";
+import { OrderDirection } from "../define/OrderBy.ts";
+import { ParamType } from "../define/Param.ts";
+import { Query, QueryType } from "../define/Query.ts";
+import { Target, TargetType } from "../define/Target.ts";
+import { Statement } from "./Statement.ts";
+var binOps = {
+  [BinOpType.Add]: "+",
+  [BinOpType.Subt]: "-",
+  [BinOpType.Mult]: "*",
+  [BinOpType.Mod]: "%",
+  [BinOpType.Div]: "/",
+  [BinOpType.Greater]: ">",
+  [BinOpType.GreaterOrEqual]: ">=",
+  [BinOpType.Less]: "<",
+  [BinOpType.LessOrEqual]: "<=",
+  [BinOpType.Equals]: "=",
+  [BinOpType.NotEquals]: "!=",
+  [BinOpType.And]: "AND",
+  [BinOpType.Or]: "OR",
+  [BinOpType.Like]: "LIKE",
+  [BinOpType.Glob]: "GLOB",
+  [BinOpType.Match]: "MATCH",
+  [BinOpType.In]: "IN",
+  [BinOpType.NotIn]: "NOT IN",
+  [BinOpType.Concat]: "||"
+};
+var joins = {
+  left: "LEFT",
+  inner: "INNER"
+};
+function formatAsResultObject(stmt, mkSubject) {
+  stmt.raw("json_object('result', ");
+  mkSubject();
+  stmt.raw(")");
+}
+var Formatter = class {
+  constructor() {
+  }
+  compile(query, options) {
+    const result = this.format(
+      this.createContext({ topLevel: true, ...options }),
+      query
+    );
+    return result;
+  }
+  createContext(options) {
+    return { stmt: new Statement(this, options), ...options };
+  }
+  format(ctx, query) {
+    switch (query.type) {
+      case QueryType.Select:
+        return this.formatSelect(ctx, query);
+      case QueryType.Insert:
+        return this.formatInsert(ctx, query);
+      case QueryType.Update:
+        return this.formatUpdate(ctx, query);
+      case QueryType.Delete:
+        return this.formatDelete(ctx, query);
+      case QueryType.CreateTable:
+        return this.formatCreateTable(ctx, query);
+      case QueryType.AlterTable:
+        return this.formatAlterTable(ctx, query);
+      case QueryType.DropTable:
+        return this.formatDropTable(ctx, query);
+      case QueryType.CreateIndex:
+        return this.formatCreateIndex(ctx, query);
+      case QueryType.DropIndex:
+        return this.formatDropIndex(ctx, query);
+      case QueryType.Transaction:
+        return this.formatTransaction(ctx, query);
+      case QueryType.Batch:
+        return this.formatBatch(ctx, query);
+      case QueryType.Raw:
+        return this.formatRaw(ctx, query);
+    }
+  }
+  formatSelect({ topLevel, ...ctx }, query) {
+    const { stmt } = ctx;
+    stmt.raw("SELECT").space();
+    this.formatSelection(
+      ctx,
+      query.selection,
+      topLevel ? formatAsResultObject : void 0
+    );
+    if (query.from) {
+      stmt.addLine("FROM").space();
+      this.formatTarget(ctx, query.from);
+    }
+    this.formatWhere(ctx, query.where);
+    this.formatGroupBy(ctx, query.groupBy);
+    this.formatHaving(ctx, query.having);
+    this.formatOrderBy(ctx, query.orderBy);
+    this.formatLimit(ctx, query);
+    return stmt;
+  }
+  formatInsert(ctx, query) {
+    const { stmt } = ctx;
+    const columns = Object.values(query.into.columns).map((c) => c.name);
+    stmt.add("INSERT INTO").addIdentifier(query.into.name);
+    if (query.into.alias)
+      stmt.raw("AS").addIdentifier(query.into.alias);
+    for (const column of stmt.call(columns))
+      this.formatString(ctx, column);
+    if (query.data) {
+      stmt.add("VALUES").space();
+      for (const row of stmt.separate(query.data))
+        this.formatInsertRow(ctx, query.into.columns, row);
+    }
+    if (query.select) {
+      stmt.space();
+      this.formatSelect(
+        {
+          ...ctx,
+          topLevel: false,
+          selectAsColumns: true
+        },
+        query.select
+      );
+    }
+    if (query.selection) {
+      stmt.add("RETURNING").space();
+      this.formatSelection(ctx, query.selection, formatAsResultObject);
+    }
+    return stmt;
+  }
+  formatUpdate(ctx, query) {
+    const { stmt } = ctx;
+    const data = query.set || {};
+    stmt.add("UPDATE").addIdentifier(query.table.name).add("SET").space();
+    const keys = Object.keys(data).filter((key) => query.table.columns[key]);
+    for (const key of stmt.separate(keys)) {
+      stmt.identifier(key).add("=").space();
+      const value = data[key];
+      if (Expr.isExpr(value))
+        this.formatExprJson(ctx, ExprData.create(data[key]));
+      else
+        this.formatValue({ ...ctx, formatAsInsert: true }, value);
+    }
+    this.formatWhere(ctx, query.where);
+    this.formatLimit(ctx, query);
+    return stmt;
+  }
+  formatDelete(ctx, query) {
+    const { stmt } = ctx;
+    stmt.add("DELETE FROM").addIdentifier(query.table.name);
+    stmt.space();
+    this.formatWhere(ctx, query.where);
+    stmt.space();
+    this.formatLimit(ctx, query);
+    return stmt;
+  }
+  formatCreateTable(ctx, query) {
+    const { stmt } = ctx;
+    stmt.add("CREATE TABLE");
+    if (query.ifNotExists)
+      stmt.add("IF NOT EXISTS");
+    stmt.addIdentifier(query.table.name);
+    for (const column of stmt.call(Object.values(query.table.columns))) {
+      this.formatColumn(ctx, column);
+    }
+    return stmt;
+  }
+  formatCreateIndex(ctx, query) {
+    const { stmt } = ctx;
+    stmt.add("CREATE");
+    if (query.index.unique)
+      stmt.add("UNIQUE");
+    stmt.add("INDEX");
+    if (query.ifNotExists)
+      stmt.add("IF NOT EXISTS");
+    stmt.addIdentifier(query.index.name).add("ON").addIdentifier(query.table.name);
+    for (const expr of stmt.call(query.index.on)) {
+      this.formatExprValue(
+        {
+          ...ctx,
+          skipTableName: true,
+          forceInline: true
+        },
+        expr
+      );
+    }
+    this.formatWhere(ctx, query.where);
+    return stmt;
+  }
+  formatDropIndex(ctx, query) {
+    const { stmt } = ctx;
+    stmt.add("DROP INDEX");
+    if (query.ifExists)
+      stmt.add("IF EXISTS");
+    stmt.addIdentifier(query.name);
+    return stmt;
+  }
+  formatAlterTable(ctx, query) {
+    const { stmt } = ctx;
+    stmt.add("ALTER TABLE").addIdentifier(
+      query.renameTable ? query.renameTable.from : query.table.name
+    );
+    if (query.addColumn) {
+      stmt.add("ADD COLUMN").space();
+      this.formatColumn(ctx, query.addColumn);
+    } else if (query.dropColumn) {
+      stmt.add("DROP COLUMN").addIdentifier(query.dropColumn);
+    } else if (query.renameColumn) {
+      stmt.add("RENAME COLUMN");
+      stmt.addIdentifier(query.renameColumn.from).add("TO");
+      stmt.addIdentifier(query.renameColumn.to);
+    } else if (query.renameTable) {
+      stmt.add("RENAME TO").addIdentifier(query.table.name);
+    } else if (query.alterColumn) {
+      throw new Error(`Not available in this formatter: alter column`);
+    }
+    return stmt;
+  }
+  formatDropTable(ctx, query) {
+    const { stmt } = ctx;
+    stmt.add("DROP TABLE");
+    if (query.ifExists)
+      stmt.add("IF EXISTS");
+    stmt.addIdentifier(query.table.name);
+    return stmt;
+  }
+  formatTransaction(ctx, { op, id }) {
+    const { stmt } = ctx;
+    switch (op) {
+      case Query.TransactionOperation.Begin:
+        return stmt.raw("SAVEPOINT").addIdentifier(id);
+      case Query.TransactionOperation.Commit:
+        return stmt.raw("RELEASE").addIdentifier(id);
+      case Query.TransactionOperation.Rollback:
+        return stmt.raw("ROLLBACK TO").addIdentifier(id);
+    }
+  }
+  formatBatch(ctx, { queries }) {
+    const { stmt } = ctx;
+    for (const query of stmt.separate(queries, ";"))
+      this.format(ctx, query);
+    return stmt;
+  }
+  formatRaw(ctx, { strings, params }) {
+    const { stmt } = ctx;
+    for (let i = 0; i < strings.length; i++) {
+      ctx.stmt.raw(strings[i]);
+      if (i < params.length) {
+        const param = params[i];
+        if (Expr.isExpr(param))
+          this.formatExpr(ctx, param[Expr.Data]);
+        else
+          this.formatValue(ctx, param);
+      }
+    }
+    return stmt;
+  }
+  formatColumn(ctx, column) {
+    const { stmt } = ctx;
+    stmt.identifier(column.name).space();
+    this.formatType(ctx, column.type);
+    if (column.unique)
+      stmt.add("UNIQUE");
+    if (column.autoIncrement)
+      stmt.add("AUTOINCREMENT");
+    if (column.primaryKey)
+      stmt.add("PRIMARY KEY");
+    if (!column.nullable)
+      stmt.add("NOT NULL");
+    if (column.defaultValue !== void 0) {
+      if (typeof column.defaultValue !== "function") {
+        stmt.add("DEFAULT").space();
+        stmt.openParenthesis();
+        this.formatExpr(
+          {
+            ...ctx,
+            formatAsInsert: true,
+            forceInline: true
+          },
+          column.defaultValue
+        );
+        stmt.closeParenthesis();
+      }
+    }
+    if (column.references)
+      this.formatContraintReference(ctx, column.references());
+    return stmt;
+  }
+  formatContraintReference(ctx, reference) {
+    const { stmt } = ctx;
+    if (reference.type !== ExprType.Field || reference.expr.type !== ExprType.Row)
+      throw new Error("not supported");
+    const from = reference.expr.target;
+    return stmt.add("REFERENCES").addIdentifier(Target.source(from).name).openParenthesis().identifier(reference.field).closeParenthesis();
+  }
+  formatType(ctx, type) {
+    const { stmt } = ctx;
+    switch (type) {
+      case ColumnType.String:
+        return stmt.raw("TEXT");
+      case ColumnType.Json:
+        return stmt.raw("JSON");
+      case ColumnType.Number:
+        return stmt.raw("NUMERIC");
+      case ColumnType.Boolean:
+        return stmt.raw("BOOLEAN");
+      case ColumnType.Integer:
+        return stmt.raw("INTEGER");
+    }
+  }
+  formatInsertRow(ctx, columns, row) {
+    const { stmt } = ctx;
+    for (const [property, column] of stmt.call(Object.entries(columns))) {
+      const columnValue = row[property];
+      this.formatColumnValue(ctx, column, columnValue);
+    }
+    return stmt;
+  }
+  formatColumnValue(ctx, column, columnValue) {
+    const { stmt } = ctx;
+    if (Expr.isExpr(columnValue))
+      return this.formatExprValue(ctx, columnValue[Expr.Data]);
+    const isNull = columnValue === void 0 || columnValue === null;
+    const isOptional = column.nullable || column.autoIncrement || column.primaryKey;
+    if (isNull) {
+      if (column.defaultValue !== void 0) {
+        if (typeof column.defaultValue === "function")
+          return this.formatExprJson(
+            { ...ctx, formatAsInsert: true },
+            column.defaultValue()
+          );
+        return this.formatExprJson(
+          { ...ctx, formatAsInsert: true },
+          column.defaultValue
+        );
+      }
+      if (!isOptional)
+        throw new TypeError(`Expected value for column ${column.name}`);
+      return stmt.raw("NULL");
+    }
+    switch (column.type) {
+      case ColumnType.String:
+        if (typeof columnValue !== "string")
+          throw new TypeError(`Expected string for column ${column.name}`);
+        return stmt.value(columnValue);
+      case ColumnType.Integer:
+      case ColumnType.Number:
+        if (typeof columnValue !== "number")
+          throw new TypeError(`Expected number for column ${column.name}`);
+        return stmt.value(columnValue);
+      case ColumnType.Boolean:
+        if (typeof columnValue !== "boolean")
+          throw new TypeError(`Expected boolean for column ${column.name}`);
+        return stmt.raw(this.escapeValue(columnValue));
+      case ColumnType.Json:
+        return stmt.value(JSON.stringify(columnValue));
+    }
+  }
+  formatTarget(ctx, target) {
+    const { stmt } = ctx;
+    switch (target.type) {
+      case TargetType.Table:
+        stmt.identifier(target.table.name);
+        if (target.table.alias)
+          stmt.add("AS").addIdentifier(target.table.alias);
+        return stmt;
+      case TargetType.Join:
+        const { left, right, joinType } = target;
+        this.formatTarget(ctx, left);
+        stmt.addLine(joins[joinType]).add("JOIN").space();
+        this.formatTarget(ctx, right);
+        stmt.add("ON").space();
+        this.formatExprValue(ctx, target.on);
+        return stmt;
+      case TargetType.Query:
+        stmt.openParenthesis();
+        this.format(ctx, target.query);
+        stmt.closeParenthesis();
+        if (target.alias)
+          stmt.add("AS").addIdentifier(target.alias);
+        return stmt;
+      case TargetType.Expr:
+        throw new Error("Cannot format expression as target");
+    }
+  }
+  formatWhere({ topLevel, ...ctx }, expr) {
+    const { stmt } = ctx;
+    if (!expr)
+      return stmt;
+    stmt.newline().raw("WHERE").space();
+    this.formatExprValue(ctx, expr);
+    return stmt;
+  }
+  formatHaving({ topLevel, ...ctx }, expr) {
+    const { stmt } = ctx;
+    if (!expr)
+      return stmt;
+    stmt.newline().raw("HAVING");
+    this.formatExprValue(ctx, expr);
+    return stmt;
+  }
+  formatGroupBy(ctx, groupBy) {
+    const { stmt } = ctx;
+    if (!groupBy)
+      return stmt;
+    stmt.newline().raw("GROUP BY");
+    for (const expr of stmt.separate(groupBy))
+      this.formatExprValue(ctx, expr);
+    return stmt;
+  }
+  formatOrderBy(ctx, orderBy) {
+    const { stmt } = ctx;
+    if (!orderBy)
+      return stmt;
+    stmt.newline().raw("ORDER BY").space();
+    for (const { expr, order } of stmt.separate(orderBy)) {
+      this.formatExprValue(ctx, expr);
+      stmt.add(order === OrderDirection.Asc ? "ASC" : "DESC");
+    }
+    return stmt;
+  }
+  formatLimit(ctx, { limit, offset, singleResult }) {
+    const { stmt, forceInline } = ctx;
+    if (!limit && !offset && !singleResult)
+      return stmt;
+    stmt.newline().raw("LIMIT").space();
+    this.formatValue(ctx, singleResult ? 1 : limit);
+    if (offset && offset > 0) {
+      stmt.add("OFFSET").space();
+      this.formatValue(ctx, offset);
+    }
+    return stmt;
+  }
+  formatSelection(ctx, selection, formatSubject) {
+    const { stmt } = ctx;
+    const mkSubject = () => this.formatExpr(
+      {
+        ...ctx,
+        formatAsJson: true
+      },
+      selection
+    );
+    if (formatSubject)
+      formatSubject(stmt, mkSubject);
+    else
+      this.formatExpr(ctx, selection);
+    if (!ctx.selectAsColumns)
+      stmt.add("AS").addIdentifier("result");
+    return stmt;
+  }
+  formatExprJson(ctx, expr) {
+    return this.formatExpr({ ...ctx, formatAsJson: true }, expr);
+  }
+  formatExprValue(ctx, expr) {
+    return this.formatExpr({ ...ctx, formatAsJson: false }, expr);
+  }
+  retrieveField(expr, field) {
+    switch (expr.type) {
+      case ExprType.Record:
+        return expr.fields[field];
+      case ExprType.Merge:
+        return this.retrieveField(expr.a, field) || this.retrieveField(expr.b, field);
+      default:
+        return void 0;
+    }
+  }
+  formatField(ctx, expr, field) {
+    const { stmt } = ctx;
+    const fieldExpr = this.retrieveField(expr, field);
+    if (fieldExpr)
+      return this.formatExpr(ctx, fieldExpr);
+    switch (expr.type) {
+      case ExprType.Row:
+        switch (expr.target.type) {
+          case TargetType.Table:
+            const column = expr.target.table.columns[field];
+            const asBoolean = column?.type === ColumnType.Boolean && ctx.formatAsJson;
+            const jsonColumn = column?.type === ColumnType.Json;
+            const asJson = jsonColumn && ctx.formatAsJson;
+            if (asJson) {
+              stmt.raw("json");
+              stmt.openParenthesis();
+            }
+            if (asBoolean)
+              stmt.add(`json(iif(`);
+            if (!ctx.skipTableName) {
+              stmt.identifier(expr.target.table.alias || expr.target.table.name).raw(".");
+            }
+            stmt.identifier(field);
+            if (asBoolean)
+              stmt.add(`, 'true', 'false'))`);
+            if (asJson)
+              stmt.closeParenthesis();
+            if (jsonColumn && !asJson)
+              stmt.raw("->>'$'");
+            return stmt;
+        }
+      default:
+        return this.formatAccess(ctx, () => this.formatExpr(ctx, expr), field);
+    }
+  }
+  formatString(ctx, input) {
+    const { stmt } = ctx;
+    return stmt.raw(this.escapeValue(String(input)));
+  }
+  formatInlineValue(ctx, rawValue) {
+    const { stmt } = ctx;
+    switch (true) {
+      case (rawValue === null || rawValue === void 0):
+        return stmt.raw("NULL");
+      case typeof rawValue === "boolean":
+        return rawValue ? stmt.raw("TRUE") : stmt.raw("FALSE");
+      case (typeof rawValue === "string" || typeof rawValue === "number"):
+        return this.formatString(ctx, rawValue);
+      default:
+        return this.formatString(ctx, JSON.stringify(rawValue));
+    }
+  }
+  formatValue(ctx, rawValue) {
+    const { stmt, formatAsJson, formatAsInsert, forceInline } = ctx;
+    const asJson = formatAsJson || formatAsInsert;
+    switch (true) {
+      case (rawValue === null || rawValue === void 0):
+        return stmt.raw("NULL");
+      case ((formatAsInsert || !formatAsJson) && typeof rawValue === "boolean"):
+        return rawValue ? stmt.raw("1") : stmt.raw("0");
+      case (!formatAsInsert && Array.isArray(rawValue)):
+        if (asJson)
+          stmt.raw("json_array");
+        stmt.openParenthesis();
+        for (const v of stmt.separate(rawValue))
+          this.formatValue({ ...ctx, formatAsJson: asJson }, v);
+        stmt.closeParenthesis();
+        return stmt;
+      case (typeof rawValue === "string" || typeof rawValue === "number"):
+        if (forceInline)
+          return stmt.raw(this.escapeValue(rawValue));
+        return stmt.value(rawValue);
+      default:
+        if (formatAsJson) {
+          stmt.raw("json");
+          stmt.openParenthesis();
+        }
+        if (forceInline)
+          this.formatString(ctx, JSON.stringify(rawValue));
+        else
+          stmt.value(JSON.stringify(rawValue));
+        if (formatAsJson)
+          stmt.closeParenthesis();
+        return stmt;
+    }
+  }
+  formatExpr({ formatAsIn, ...ctx }, expr) {
+    const { stmt } = ctx;
+    switch (expr.type) {
+      case ExprType.UnOp:
+        switch (expr.op) {
+          case UnOpType.IsNull:
+            return this.formatExprValue(ctx, expr.expr).add("IS NULL");
+          case UnOpType.Not:
+            stmt.raw("NOT").openParenthesis();
+            this.formatExprValue(ctx, expr.expr);
+            return stmt.closeParenthesis();
+        }
+      case ExprType.BinOp:
+        stmt.openParenthesis();
+        this.formatExprValue(ctx, expr.a).add(binOps[expr.op]).space();
+        const asIn = expr.op === BinOpType.In || expr.op === BinOpType.NotIn;
+        this.formatExprValue({ ...ctx, formatAsIn: asIn }, expr.b);
+        return stmt.closeParenthesis();
+      case ExprType.Param:
+        switch (expr.param.type) {
+          case ParamType.Value:
+            return this.formatValue(ctx, expr.param.value);
+          case ParamType.Named:
+            return stmt.param(expr.param);
+        }
+      case ExprType.Field:
+        if (formatAsIn) {
+          stmt.openParenthesis();
+          stmt.raw("SELECT value FROM json_each");
+          stmt.openParenthesis();
+          this.formatExprJson(ctx, expr);
+          stmt.closeParenthesis();
+          return stmt.closeParenthesis();
+        }
+        return this.formatField(ctx, expr.expr, expr.field);
+      case ExprType.Call: {
+        if (expr.method === "cast") {
+          const [e, type] = expr.params;
+          const typeName = type.type === ExprType.Param && type.param.type === ParamType.Value && type.param.value;
+          stmt.raw("cast").openParenthesis();
+          this.formatExprValue(ctx, e).add("as").space();
+          this.formatString(ctx, typeName);
+          return stmt.closeParenthesis();
+        } else if (expr.method === "exists") {
+          stmt.raw("exists").space();
+          return this.formatExprValue(ctx, expr.params[0]);
+        } else {
+          stmt.identifier(expr.method);
+          for (const param of stmt.call(expr.params))
+            this.formatExprValue(ctx, param);
+          return stmt;
+        }
+      }
+      case ExprType.Query:
+        if (!ctx.formatAsJson) {
+          stmt.openParenthesis();
+          this.format(ctx, expr.query);
+          return stmt.closeParenthesis();
+        }
+        if (expr.query.singleResult) {
+          stmt.openParenthesis();
+          this.format({ ...ctx, topLevel: true }, expr.query);
+          return stmt.closeParenthesis().raw(`->'$.result'`);
+        }
+        stmt.openParenthesis().raw(`SELECT json_group_array(result->'$.result')`).newline().raw("FROM").space().openParenthesis();
+        this.format({ ...ctx, topLevel: true }, expr.query);
+        return stmt.closeParenthesis().closeParenthesis();
+      case ExprType.Row:
+        switch (expr.target.type) {
+          case TargetType.Table:
+            const table = Target.source(expr.target);
+            if (!table)
+              throw new Error(`Cannot select empty target`);
+            if (ctx.tableAsExpr)
+              return stmt.identifier(table.alias || table.name);
+            stmt.identifier("json_object");
+            for (const [key, column] of stmt.call(
+              Object.entries(table.columns)
+            )) {
+              this.formatString(ctx, key).raw(", ");
+              this.formatField(ctx, expr, column.name);
+            }
+            return stmt;
+          case TargetType.Query:
+          case TargetType.Expr:
+            return stmt.identifier(expr.target.alias).raw(".value");
+          default:
+            throw new Error(`Cannot select from ${expr.target.type}`);
+        }
+      case ExprType.Merge:
+        stmt.identifier("json_patch").openParenthesis();
+        this.formatExpr({ ...ctx, formatAsJson: true }, expr.a);
+        stmt.raw(", ");
+        this.formatExpr({ ...ctx, formatAsJson: true }, expr.b);
+        return stmt.closeParenthesis();
+      case ExprType.Record:
+        if (ctx.selectAsColumns) {
+          const inner = { ...ctx, selectAsColumns: false };
+          for (const [key, value] of stmt.separate(
+            Object.entries(expr.fields)
+          )) {
+            this.formatExprJson(inner, value);
+          }
+          return stmt;
+        }
+        stmt.identifier("json_object").openParenthesis();
+        for (const [key, value] of stmt.separate(Object.entries(expr.fields))) {
+          this.formatString(ctx, key).raw(", ");
+          this.formatExprJson(ctx, value);
+        }
+        return stmt.closeParenthesis();
+      case ExprType.Filter: {
+        const { target, condition } = expr;
+        switch (target.type) {
+          case TargetType.Expr:
+            stmt.openParenthesis();
+            if (!formatAsIn) {
+              stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
+            }
+            stmt.raw("SELECT value AS result").add("FROM json_each").openParenthesis();
+            this.formatExpr(ctx, target.expr);
+            stmt.closeParenthesis();
+            if (target.alias)
+              stmt.add("AS").addIdentifier(target.alias);
+            stmt.add("WHERE").space();
+            this.formatExprValue(ctx, condition);
+            if (!formatAsIn) {
+              stmt.closeParenthesis();
+            }
+            return stmt.closeParenthesis();
+          default:
+            throw new Error("todo");
+        }
+      }
+      case ExprType.Map: {
+        const { target, result } = expr;
+        switch (target.type) {
+          case TargetType.Expr:
+            stmt.openParenthesis();
+            if (!formatAsIn) {
+              stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
+            }
+            stmt.raw("SELECT").space();
+            this.formatExpr(ctx, result).add("AS result").add("FROM json_each").openParenthesis();
+            this.formatExprJson(ctx, target.expr);
+            stmt.closeParenthesis();
+            if (target.alias)
+              stmt.add("AS").addIdentifier(target.alias);
+            if (!formatAsIn) {
+              stmt.closeParenthesis();
+            }
+            return stmt.closeParenthesis();
+          default:
+            throw new Error("todo");
+        }
+      }
+      default:
+        console.log(expr);
+        throw new Error("todo");
+    }
+  }
+};
+export {
+  Formatter
+};