@graphenedata/cli 0.0.5 → 0.0.7

package/dist/cli/cli.js

@@ -69,6 +69,7 @@ async function pollFor(fn, timeoutMs, interval) {
 }
 var init_util = __esm({
   "../lang/util.ts"() {
+    "use strict";
   }
 });
 
@@ -135,6 +136,7 @@ function extractLeadingMetadata(node) {
 }
 var init_metadata = __esm({
   "../lang/metadata.ts"() {
+    "use strict";
     init_util();
   }
 });
@@ -143,8 +145,12 @@ var init_metadata = __esm({
 import * as fs from "fs";
 import path from "path";
 function setConfig(cfg) {
+  let dialect = cfg.dialect || "duckdb";
+  if (cfg.bigquery) dialect = "bigquery";
+  else if (cfg.snowflake) dialect = "snowflake";
+  else if (cfg.duckdb) dialect = "duckdb";
   Object.keys(config).forEach((key) => delete config[key]);
-  Object.assign(config, cfg);
+  Object.assign(config, cfg, { dialect });
 }
 function loadConfig(dir) {
   if (config.root) return;
@@ -156,19 +162,17 @@ function loadConfig(dir) {
   } catch {
     console.warn("No package.json found in current directory");
   }
-  let dialect = "duckdb";
-  if (packageJsonObject.bigquery) dialect = "bigquery";
-  else if (packageJsonObject.snowflake) dialect = "snowflake";
-  setConfig({ ...packageJsonObject, dialect, root: packageJsonObject.root || process.cwd() });
+  setConfig({ ...packageJsonObject, root: packageJsonObject.root || process.cwd() });
 }
 var config;
 var init_config = __esm({
   "../lang/config.ts"() {
+    "use strict";
     config = { dialect: "duckdb", root: "" };
   }
 });
 
-// ../lang/functions.ts
+// ../lang/functionDefs.ts
 import { DUCKDB_DIALECT_FUNCTIONS, GlobalNameSpace, DialectNameSpace, getDialect } from "@graphenedata/malloy";
 function findOverloads(name, dialect) {
   if (!dialectNamespaces.has(dialect)) {
@@ -179,8 +183,9 @@ function findOverloads(name, dialect) {
   return res?.entry ? res.entry.overloads : [];
 }
 var globalNamespace, dialectNamespaces, BIGQUERY_DIALECT_FUNCTIONS;
-var init_functions = __esm({
-  "../lang/functions.ts"() {
+var init_functionDefs = __esm({
+  "../lang/functionDefs.ts"() {
+    "use strict";
     globalNamespace = new GlobalNameSpace();
     dialectNamespaces = /* @__PURE__ */ new Map();
     Object.assign(DUCKDB_DIALECT_FUNCTIONS, {
@@ -249,8 +254,9 @@ var init_functions = __esm({
         impl: { function: "TIMESTAMP_DIFF" }
       },
       "date_trunc": {
-        takes: { "date": "timestamp", "unit": { sql_native: "kw" } },
-        returns: "timestamp",
+        generic: { "T": ["date", "timestamp"] },
+        takes: { "date": { generic: "T" }, "unit": { sql_native: "kw" } },
+        returns: { generic: "T" },
         impl: { sql: "DATE_TRUNC(${date}, ${unit})" }
       },
       "current_date": {
@@ -310,6 +316,244 @@ var init_functions = __esm({
   }
 });
 
+// ../lang/functions.ts
+function analyzeFunctionCall(expr, scope) {
+  let rawName = txt(expr.getChild("Identifier")).toLowerCase();
+  let argNodes = expr.getChildren("Expression");
+  let name = rawName;
+  let overload = findOverloads(name, config.dialect).find((o) => {
+    return o.params.length == argNodes.length || !!o.params.find((p) => p.isVariadic);
+  });
+  let args = argNodes.map((node, idx) => {
+    let firstType = overload?.params[idx]?.allowedTypes[0];
+    if (firstType?.type === "sql native" && firstType?.rawType === "kw") {
+      return { node: "genericSQLExpr", kids: { args: [] }, type: "sql native", src: [txt(node)], isAgg: false };
+    } else {
+      let argExpr = analyzeExpression(node, scope);
+      let allowed = overload?.params[idx]?.allowedTypes.map((at) => at.type);
+      if (allowed) checkTypes(argExpr, allowed, node);
+      return argExpr;
+    }
+  });
+  let type = overload?.returnType.type;
+  if (type == "generic") type = args[0]?.type || "string";
+  if (type && !isSupportedType(type)) {
+    return diag(expr, `Unsupported function return type ${type} from function ${name}`, errExpr);
+  }
+  let structPaths = /* @__PURE__ */ new Set();
+  args.forEach((a) => walkExpression(a, (e) => {
+    if (e.node != "field") return;
+    structPaths.add(e.path.slice(0, -1).join(".") || scope.table.name);
+  }));
+  let ret;
+  let percentileMatch = /^p(\d+)$/.exec(rawName);
+  if (["count", "min", "max", "avg", "sum"].includes(name.toLowerCase())) {
+    let type2 = "number", typeDef;
+    if (["min", "max", "avg"].includes(name.toLowerCase())) {
+      type2 = args[0].type;
+      typeDef = args[0].typeDef;
+    }
+    ret = { node: "aggregate", function: name, e: args[0], type: type2, typeDef, isAgg: true };
+  } else if (percentileMatch) {
+    ret = analyzePercentile(expr, scope, percentileMatch[1], argNodes);
+  } else if (overload && type) {
+    ret = {
+      node: "function_call",
+      type,
+      name,
+      overload,
+      expressionType: overload.returnType.expressionType || "scalar",
+      kids: { args },
+      isAgg: overload.returnType.expressionType == "aggregate" || args.some((a) => a.isAgg)
+    };
+  } else {
+    return diag(expr, `Unknown function: ${name}`, errExpr);
+  }
+  if (structPaths.size > 1 && (ret.node == "aggregate" || ret.expressionType == "aggregate")) {
+    return diag(expr, "Graphene only supports a single table within aggregates. This one has: " + Array.from(structPaths).join(", "), errExpr);
+  }
+  let foriegnPaths = Array.from(structPaths).filter((p) => p != scope.table.name);
+  if (foriegnPaths.length > 0) ret.structPath = foriegnPaths[0].split(".");
+  return ret;
+}
+function isSupportedType(value) {
+  let supported = ["string", "number", "boolean", "date", "timestamp", "json", "sql native", "error", "array", "record", "null", "generic", "interval"];
+  return supported.includes(value);
+}
+function analyzePercentile(callNode, scope, digits, argNodes) {
+  let frac = Number(`0.${digits}`);
+  if (Number(digits) == 100) return diag(callNode, "p100 is not allowed", errExpr);
+  if (Number(digits) == 0) return diag(callNode, "p0 is not allowed", errExpr);
+  if (config.dialect == "bigquery" && frac > 0.99) return diag(callNode, "BigQuery only supports up to p99", errExpr);
+  let valueExpr = analyzeExpression(argNodes[0], scope);
+  checkTypes(valueExpr, ["number"], argNodes[0]);
+  let src;
+  switch (config.dialect) {
+    case "duckdb":
+      src = ["quantile_cont(", `, ${frac})`];
+      break;
+    case "bigquery": {
+      src = ["approx_quantiles(", `, 100)[OFFSET(${Math.round(frac * 10)})]`];
+      break;
+    }
+    case "snowflake":
+      src = [`PERCENTILE_CONT(${frac}) WITHIN GROUP (ORDER BY `, ")"];
+      break;
+    default:
+      return diag(callNode, `Percentile functions are not supported for dialect ${config.dialect}`, errExpr);
+  }
+  return {
+    node: "genericSQLExpr",
+    kids: { args: [valueExpr] },
+    src,
+    type: "number",
+    isAgg: true
+  };
+}
+var errExpr;
+var init_functions = __esm({
+  "../lang/functions.ts"() {
+    "use strict";
+    init_config();
+    init_functionDefs();
+    init_util();
+    init_analyze();
+    errExpr = { node: "error", type: "error" };
+  }
+});
+
+// ../lang/temporalLiterals.ts
+function parseTemporalLiteral(value, expected) {
+  let raw = (value ?? "").trim();
+  if (!raw) return null;
+  let yearMatch = raw.match(/^([0-9]{4})$/);
+  if (yearMatch) {
+    let year = Number(yearMatch[1]);
+    return buildResult(year, 1, 1, 0, 0, 0, "year", expected);
+  }
+  let yearMonthMatch = raw.match(/^([0-9]{4})-([0-9]{2})$/);
+  if (yearMonthMatch) {
+    let year = Number(yearMonthMatch[1]);
+    let month = Number(yearMonthMatch[2]);
+    if (!inRange(month, 1, 12)) return null;
+    return buildResult(year, month, 1, 0, 0, 0, "month", expected);
+  }
+  let dateMatch = raw.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})$/);
+  if (dateMatch) {
+    let year = Number(dateMatch[1]);
+    let month = Number(dateMatch[2]);
+    let day = Number(dateMatch[3]);
+    if (!isValidDate(year, month, day)) return null;
+    return buildResult(year, month, day, 0, 0, 0, "day", expected);
+  }
+  if (expected === "timestamp") {
+    let dateTimeMatch = raw.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})[Tt\s]([0-9]{1,2})(?::([0-9]{2})(?::([0-9]{2}))?)?$/);
+    if (!dateTimeMatch) return null;
+    let year = Number(dateTimeMatch[1]);
+    let month = Number(dateTimeMatch[2]);
+    let day = Number(dateTimeMatch[3]);
+    if (!isValidDate(year, month, day)) return null;
+    let hour = Number(dateTimeMatch[4]);
+    let minute = dateTimeMatch[5] ? Number(dateTimeMatch[5]) : 0;
+    let second = dateTimeMatch[6] ? Number(dateTimeMatch[6]) : 0;
+    if (!inRange(hour, 0, 23) || !inRange(minute, 0, 59) || !inRange(second, 0, 59)) return null;
+    let timeframe = "hour";
+    if (dateTimeMatch[6]) {
+      timeframe = "second";
+    } else if (dateTimeMatch[5]) {
+      timeframe = "minute";
+    }
+    return buildResult(year, month, day, hour, minute, second, timeframe, expected);
+  }
+  return null;
+}
+function parseTemporal(node) {
+  if (node.node !== "stringLiteral") return null;
+  let rawValue = typeof node.literal === "string" ? node.literal.trim() : "";
+  if (!rawValue) return null;
+  let parsedDate = parseTemporalLiteral(rawValue, "date");
+  if (parsedDate) {
+    let typeDef = { type: parsedDate.type, timeframe: parsedDate.timeframe };
+    Object.assign(node, { node: "timeLiteral", literal: parsedDate.literal, type: parsedDate.type, typeDef });
+    return parsedDate.timeframe;
+  }
+  let parsedTimestamp = parseTemporalLiteral(rawValue, "timestamp");
+  if (parsedTimestamp) {
+    let typeDef = { type: parsedTimestamp.type, timeframe: parsedTimestamp.timeframe };
+    Object.assign(node, { node: "timeLiteral", literal: parsedTimestamp.literal, type: parsedTimestamp.type, typeDef });
+    return parsedTimestamp.timeframe;
+  }
+  let interval = parseIntervalLiteral(rawValue);
+  if (interval) {
+    Object.assign(node, { node: "numberLiteral", literal: interval.quantity.toString(), type: "interval", intervalUnit: interval.unit });
+    return interval.unit;
+  }
+  return null;
+}
+function parseIntervalLiteral(value) {
+  let raw = (value ?? "").trim().toLowerCase().replace(/\s+/g, " ");
+  if (!raw) return null;
+  let match = raw.match(/^(-?\d+(?:\.\d+)?)\s+([a-z]+)$/);
+  if (!match) return null;
+  let quantity = Number(match[1]);
+  if (!Number.isFinite(quantity)) return null;
+  let unit = INTERVAL_UNITS[match[2]];
+  if (!unit) return null;
+  return { quantity, unit };
+}
+function buildResult(year, month, day, hour, minute, second, timeframe, expected) {
+  if (expected === "date") {
+    return { literal: `${pad(year)}-${pad(month)}-${pad(day)}`, timeframe, type: "date" };
+  }
+  return {
+    literal: `${pad(year)}-${pad(month)}-${pad(day)} ${pad(hour)}:${pad(minute)}:${pad(second)}`,
+    timeframe,
+    type: "timestamp"
+  };
+}
+function inRange(value, min, max) {
+  return Number.isInteger(value) && value >= min && value <= max;
+}
+function isValidDate(year, month, day) {
+  if (!inRange(month, 1, 12)) return false;
+  if (!inRange(day, 1, 31)) return false;
+  let date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function pad(value) {
+  return value.toString().padStart(2, "0");
+}
+var INTERVAL_UNITS;
+var init_temporalLiterals = __esm({
+  "../lang/temporalLiterals.ts"() {
+    "use strict";
+    INTERVAL_UNITS = {
+      second: "second",
+      seconds: "second",
+      sec: "second",
+      secs: "second",
+      minute: "minute",
+      minutes: "minute",
+      min: "minute",
+      mins: "minute",
+      hour: "hour",
+      hours: "hour",
+      hr: "hour",
+      hrs: "hour",
+      day: "day",
+      days: "day",
+      week: "week",
+      weeks: "week",
+      month: "month",
+      months: "month",
+      quarter: "quarter",
+      quarters: "quarter",
+      year: "year",
+      years: "year"
+    };
+  }
+});
+
 // ../lang/params.ts
 function inferParamTypes(query) {
   let parentMap = /* @__PURE__ */ new WeakMap();
@@ -416,8 +660,7 @@ function sanitizeType(value) {
   return value;
 }
 function fillInParams(query, params) {
-  let q = structuredClone(query);
-  let filters = q.pipeline[0].filterList || [];
+  let filters = query.pipeline[0].filterList || [];
   for (let filter of filters) {
     walkExpression(filter.e, (e) => {
       if (e.node !== "parameter") return;
@@ -426,20 +669,31 @@ function fillInParams(query, params) {
       else if (value == null) Object.assign(e, { node: "null", type: "string" });
       else if (e.type == "string") Object.assign(e, { node: "stringLiteral", literal: value });
       else if (e.type == "number") Object.assign(e, { node: "numberLiteral", literal: value.toString() });
-      else if (e.type == "boolean") Object.assign(e, { node: value ? "true" : "false" });
+      else if (e.type == "date" || e.type == "timestamp") {
+        if (typeof value !== "string") throw new Error(`Parameters of type ${e.type} must be provided as strings`);
+        let parsed = parseTemporalLiteral(value, e.type);
+        if (!parsed) throw new Error(`Could not parse ${e.type} literal for param $${e.path[0]}`);
+        Object.assign(e, { node: "timeLiteral", literal: parsed.literal, type: parsed.type, typeDef: { type: parsed.type, timeframe: parsed.timeframe } });
+      } else if (e.type == "interval") {
+        if (typeof value !== "string") throw new Error("Parameters of type interval must be provided as strings");
+        let parsed = parseIntervalLiteral(value);
+        if (!parsed) throw new Error(`Could not parse interval literal for param $${e.path[0]}`);
+        Object.assign(e, { node: "numberLiteral", literal: parsed.quantity.toString(), type: "interval", intervalUnit: parsed.unit });
+      } else if (e.type == "boolean") Object.assign(e, { node: value ? "true" : "false" });
       else throw new Error(`Unsupported param type ${e.type}`);
     });
   }
-  return q;
 }
 var COMPARISON_OPS, BOOLEAN_OPS, NUMERIC_UNARY_OPS, FIELD_TYPES;
 var init_params = __esm({
   "../lang/params.ts"() {
+    "use strict";
     init_util();
+    init_temporalLiterals();
     COMPARISON_OPS = /* @__PURE__ */ new Set(["=", "!=", "<>", ">", ">=", "<", "<=", "like", "ilike"]);
     BOOLEAN_OPS = /* @__PURE__ */ new Set(["and", "or"]);
     NUMERIC_UNARY_OPS = /* @__PURE__ */ new Set(["unary-"]);
-    FIELD_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "date", "timestamp", "json", "sql native", "error", "fieldref", "array", "record", "null"]);
+    FIELD_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "date", "timestamp", "json", "sql native", "error", "fieldref", "array", "record", "null", "interval"]);
   }
 });
 
@@ -451,40 +705,15 @@ function findTables(fi) {
   fi.tables = [];
   let nodes = tn.getChildren("TableStatement").concat(tn.getChildren("ViewStatement"));
   for (let syntaxNode of nodes) {
-    let name = txt(syntaxNode.getChild("Identifier"));
+    let name = txt(syntaxNode.getChild("Ref"));
     if (Object.values(FILE_MAP).find((f) => f.tables.find((t) => t.name == name))) {
-      diag(syntaxNode.getChild("Identifier"), `Table "${name}" is already defined`);
+      diag(syntaxNode.getChild("Ref"), `Table "${name}" is already defined`);
     }
     let table2 = makeTable(name, syntaxNode.getChild("QueryStatement") ? "query_source" : "table");
     table2.metadata = extractLeadingMetadata(syntaxNode);
-    for (let cn of syntaxNode.getChildren("ColumnDef")) {
-      let name2 = txt(cn.getChild("Identifier"));
-      if (cn.getChild("PrimaryKey")) {
-        if (table2.primaryKey) diag(cn, `Table ${table2.name} has multiple primary keys`);
-        table2.primaryKey = name2;
-      }
-      let type = convertDataType(txt(cn.getChild("DataType")));
-      if (!type) diag(cn, `Unsupported data type: ${txt(cn.getChild("DataType"))}`);
-      let field = { name: name2, type, metadata: extractLeadingMetadata(cn) };
-      table2.fields.push(field);
-      FIELD_NODE_MAP.set(field, cn);
-    }
-    for (let jn of syntaxNode.getChildren("JoinDef")) {
-      let nameNode = jn.getChild("Alias") || jn.getChild("Identifier");
-      let field = { name: txt(nameNode) };
-      table2.fields.push(field);
-      FIELD_NODE_MAP.set(field, jn);
-    }
-    for (let cn of syntaxNode.getChildren("ComputedDef")) {
-      let field = { name: txt(cn.getChild("Alias")), metadata: extractLeadingMetadata(cn) };
-      table2.fields.push(field);
-      FIELD_NODE_MAP.set(field, cn);
-    }
-    table2.fields.reduce((set, f) => {
-      if (!set[f.name]) set[f.name] = true;
-      else diag(FIELD_NODE_MAP.get(f), `Table already has a field called "${f.name}"`);
-      return set;
-    }, {});
+    syntaxNode.getChildren("ColumnDef").forEach((cn) => addColumnField(table2, cn));
+    syntaxNode.getChildren("JoinDef").forEach((jn) => addJoinField(table2, jn));
+    syntaxNode.getChildren("ComputedDef").forEach((cn) => addComputedField(table2, cn));
     TABLE_NODE_MAP.set(table2, syntaxNode);
     fi.tables.push(table2);
   }
@@ -493,12 +722,53 @@ function makeTable(name, type) {
   let tablePath = config.namespace ? `${config.namespace}.${name}` : name;
   return { name, type, fields: [], connection: config.dialect, dialect: config.dialect, tableName: name, tablePath, metadata: {} };
 }
+function addColumnField(table2, node) {
+  let name = txt(node.getChild("Identifier"));
+  if (node.getChild("PrimaryKey")) {
+    if (table2.primaryKey) diag(node, `Table ${table2.name} has multiple primary keys`);
+    table2.primaryKey = name;
+  }
+  let type = convertDataType(txt(node.getChild("DataType")));
+  if (!type) diag(node, `Unsupported data type: ${txt(node.getChild("DataType"))}`);
+  addFieldToTable(table2, { name, type, metadata: extractLeadingMetadata(node) }, node);
+}
+function addJoinField(table2, node) {
+  let nameNode = node.getChild("Alias") || node.getChild("Ref").getChildren("Identifier").pop();
+  return addFieldToTable(table2, { name: txt(nameNode) }, node);
+}
+function addComputedField(table2, node) {
+  let name = txt(node.getChild("Alias"));
+  addFieldToTable(table2, { name, metadata: extractLeadingMetadata(node) }, node);
+}
+function addFieldToTable(table2, field, node) {
+  if (table2.fields.find((f) => f.name == field.name)) {
+    return diag(node, `Table already has a field called "${field.name}"`);
+  }
+  table2.fields.push(field);
+  FIELD_NODE_MAP.set(field, node);
+}
+function applyExtends(fi) {
+  fi.tree.topNode.getChildren("ExtendStatement").forEach((node) => {
+    let tableName = txt(node.getChild("Ref"));
+    let target = lookupTable(tableName, node);
+    if (!target) {
+      return diag(node.getChild("Ref") || node, `Cannot extend unknown table "${tableName}"`);
+    }
+    node.getChildren("JoinDef").forEach((jn) => addJoinField(target, jn));
+    node.getChildren("ComputedDef").forEach((cn) => addComputedField(target, cn));
+  });
+}
 function analyzeTable(table2) {
-  if (table2.type == "query_source") return analyzeQueryTable(table2);
-  for (let f of table2.fields) {
-    if (f.type) continue;
-    analyzeField(f, table2);
+  if (table2.type == "query_source") {
+    if (table2.query) return;
+    let node = TABLE_NODE_MAP.get(table2);
+    let query = analyzeQuery(node.getChild("QueryStatement"));
+    if (!query) return;
+    let queryFields = query.fields.map((f) => ({ type: f.type, name: f.name, metadata: f.metadata }));
+    table2.fields.push(...queryFields);
+    table2.query = query;
   }
+  table2.fields.map((f) => analyzeField(f, table2));
 }
 function analyzeField(field, table2) {
   if (field.type) return;
@@ -509,13 +779,14 @@ function analyzeField(field, table2) {
   analysisQueue.add(field);
   if (node.name == "JoinDef") {
     field = field;
-    let target = lookupTable(txt(node.getChild("Identifier")), node);
+    let target = lookupTable(txt(node.getChild("Ref")), node);
     if (!target) return diag(node, "Unknown table to join");
-    if (target.type == "query_source") analyzeQueryTable(target);
-    let jt = { "join_many": "many", "join_one": "one" }[txt(node.getChild("JoinType"))];
+    if (target.type == "query_source") analyzeTable(target);
+    let joinTypeStr = txt(node.getChild("JoinType")).replace(/\s+/g, " ");
+    let jt = { "join many": "many", "join one": "one" }[joinTypeStr];
     if (!jt) return diag(node, "Unknown join type");
     Object.assign(field, target, { name: field.name, join: jt });
-    field.onExpression = analyzeExpression(node.getChild("Expression"), { table: table2, outputFields: [] });
+    field.onExpression = analyzeExpression(node.getChild("BinaryExpression"), { table: table2, outputFields: [] });
   }
   if (node.name == "ComputedDef") {
     let e = analyzeExpression(node.getChild("Expression"), { table: table2, outputFields: [] });
@@ -524,38 +795,29 @@ function analyzeField(field, table2) {
   }
   analysisQueue.delete(field);
 }
-function analyzeQueryTable(table2) {
-  if (table2.query) return;
-  let node = TABLE_NODE_MAP.get(table2);
-  let query = analyzeQuery(node.getChild("QueryStatement"));
-  if (!query) return;
-  table2.fields = query.fields.map((f) => ({ type: f.type, name: f.name, metadata: f.metadata }));
-  table2.query = query.malloyQuery;
-  if (table2.query && typeof table2.query.structRef == "string") {
-    table2.query.structRef = lookupTable(table2.query.structRef, node);
-  }
-}
 function analyzeQuery(queryNode) {
-  let structRef;
+  let baseTableName;
   let scope = { table: null, outputFields: [] };
   let isAgg = false;
-  let subQuerySources = [];
   if (!txt(queryNode)) return;
-  if (txt(queryNode).trim().toLowerCase() == "select 1") return { fields: [{ name: "col_0", type: "number", metadata: {}, e: { node: "numberLiteral", literal: "1", type: "number" } }], subQuerySources, rawSql: "select 1" };
+  if (txt(queryNode).trim().toLowerCase() == "select 1") {
+    let fields = [{ name: "col_0", type: "number", metadata: {}, e: { node: "numberLiteral", literal: "1", type: "number" } }];
+    return { fields, baseTableName: "", rawSql: "select 1", structRef: {}, pipeline: [] };
+  }
   let froms = queryNode.getChild("FromClause")?.getChildren("TablePrimary") || [];
   if (froms.find((f) => f.name == "JoinClause")) diag(froms[0], "Query joins not yet supported");
   if (froms.length == 0) return diag(queryNode, "No tables in FROM clause");
   if (froms.length > 1) diag(froms[0], "Multiple tables/joins in FROM clause not yet supported");
   if (froms[0].name == "Subquery") {
-    structRef = txt(froms[0].getChild("Alias")) || "subquery";
-    scope.table = makeTable(structRef, "query_source");
+    diag(froms[0], "Graphene doesn't yet support subqueries. Try chaining queries instead.");
+    baseTableName = txt(froms[0].getChild("Alias")) || "subquery";
+    scope.table = makeTable(baseTableName, "query_source");
     TABLE_NODE_MAP.set(scope.table, froms[0].getChild("SubqueryExpression"));
-    analyzeQueryTable(scope.table);
-    subQuerySources.push(scope.table);
+    analyzeTable(scope.table);
   } else {
-    structRef = txt(froms[0].getChild("Identifier"));
-    scope.table = lookupTable(structRef, froms[0]);
-    if (!scope.table) return diag(froms[0], `could not find table "${structRef}"`);
+    baseTableName = txt(froms[0].getChild("Ref"));
+    scope.table = lookupTable(baseTableName, froms[0]);
+    if (!scope.table) return diag(froms[0], `could not find table "${baseTableName}"`);
     NODE_ENTITY_MAP.set(froms[0], { entityType: "table", table: scope.table });
   }
   let selects = queryNode.getChild("SelectClause")?.getChildren("SelectItem") || [];
@@ -563,11 +825,12 @@ function analyzeQuery(queryNode) {
   isAgg ||= !!isSelectDistinct;
   selects.forEach((s) => {
     if (s.getChild("Wildcard")) {
-      let path9 = s.getChild("Wildcard").getChildren("Identifier");
-      let pathStrings = path9.map((p) => txt(p));
-      let target = followJoins(path9, scope.table);
+      let path10 = s.getChild("Wildcard").getChildren("Identifier");
+      let pathStrings = path10.map((p) => txt(p));
+      let target = followJoins(path10, scope.table);
       if (!target) return;
       target.fields.forEach((f) => {
+        analyzeField(f, target);
         if (isJoin(f) || f.isAgg) return;
         scope.outputFields.push({ ...f, e: { node: "field", path: [...pathStrings, f.name], type: f.type } });
       });
@@ -621,27 +884,26 @@ function analyzeQuery(queryNode) {
   }
   let q = {
     fields: scope.outputFields,
-    subQuerySources,
-    malloyQuery: {
-      type: "query",
-      structRef,
-      pipeline: [{
-        type: isAgg ? "reduce" : "project",
-        queryFields: scope.outputFields,
-        filterList,
-        outputStruct: null,
-        isRepeated: false,
-        orderBy: orderByList.length ? orderByList : void 0,
-        limit: queryLimit
-      }]
-    }
+    baseTableName,
+    type: "query",
+    structRef: null,
+    // We fill this in as part of `toSql`
+    pipeline: [{
+      type: isAgg ? "reduce" : "project",
+      queryFields: scope.outputFields,
+      filterList,
+      outputStruct: null,
+      isRepeated: false,
+      orderBy: orderByList.length ? orderByList : void 0,
+      limit: queryLimit
+    }]
   };
-  inferParamTypes(q.malloyQuery);
+  inferParamTypes(q);
   return q;
 }
 function analyzeExpression(expr, scope) {
   if (expr.type.isError) {
-    return diag(expr, "Invalid expression", errExpr);
+    return diag(expr, "Invalid expression", errExpr2);
   }
   switch (expr.name) {
     case "Number":
@@ -656,21 +918,23 @@ function analyzeExpression(expr, scope) {
       return { node: "parameter", path: [txt(expr).slice(1)], type: "string" };
     case "Ref": {
       let field = lookupField(expr, scope);
-      if (!field) return errExpr;
+      if (!field) return errExpr2;
       let type = field.type || "unknown";
       let typeInfo = { type };
       if (type === "date" || type === "timestamp") typeInfo.typeDef = { type };
       if (scope.outputFields.includes(field) && field.isAgg) {
         return { node: "outputField", name: field.name, ...typeInfo, isAgg: field.isAgg };
       }
-      let path9 = expr.getChildren("Identifier").map((i) => txt(i));
-      return { node: "field", path: path9, ...typeInfo, isAgg: field.isAgg };
+      let path10 = expr.getChildren("Identifier").map((i) => txt(i));
+      return { node: "field", path: path10, ...typeInfo, isAgg: field.isAgg };
     }
     case "ExtractExpression": {
-      let e = analyzeExpression(expr.getChild("Expression"), scope);
-      if (!isTemporalType(e.type) || !e.typeDef) return diag(expr, "Expression must be a date or timestamp", errExpr);
+      let extractExprNode = expr.getChild("Expression");
+      let e = analyzeExpression(extractExprNode, scope);
+      checkTypes(e, ["date", "timestamp"], extractExprNode);
+      if (!isTemporalType(e.type) || !e.typeDef) return diag(expr, "Expression must be a date or timestamp", errExpr2);
       let units = txt(expr.getChild("ExtractUnit")).replace(/^['"]|['"]$/g, "").toLowerCase();
-      if (!isExtractUnit(units)) return diag(expr, "Not a valid unit to extract", errExpr);
+      if (!isExtractUnit(units)) return diag(expr, "Not a valid unit to extract", errExpr2);
       return { node: "extract", type: "number", units, e, isAgg: false };
     }
     case "FunctionCall":
@@ -690,7 +954,29 @@ function analyzeExpression(expr, scope) {
       let left2 = analyzeExpression(expr.firstChild, scope);
       let right2 = analyzeExpression(expr.lastChild, scope);
       let op = txt(expr.firstChild?.nextSibling).toLowerCase();
-      return { node: op, kids: { left: left2, right: right2 }, type: left2.type, isAgg: left2.isAgg || right2.isAgg };
+      let type = left2.type;
+      if (op == "or" || op == "and") type = "boolean";
+      if (op == "+" || op == "-") {
+        if (["date", "timestamp", "interval"].find((t) => left2.type == t || right2.type == t)) {
+          return analyzeTimeExpression(op, left2, right2, expr);
+        }
+        ensureSameType(left2, expr.firstChild, right2, expr.lastChild);
+      }
+      if (op == "*" || op == "/" || op == "%") {
+        checkTypes(left2, ["number"], expr.firstChild);
+        checkTypes(right2, ["number"], expr.lastChild);
+      }
+      if (op == "<" || op == "<=" || op == ">" || op == ">=" || op == "=" || op == "!=" || op == "<>") {
+        if (op == "<>") op = "!=";
+        ensureSameType(left2, expr.firstChild, right2, expr.lastChild);
+        type = "boolean";
+      }
+      if (op == "like" || op == "ilike") {
+        checkTypes(left2, ["string"], expr.firstChild);
+        checkTypes(right2, ["string"], expr.lastChild);
+        type = "boolean";
+      }
+      return { node: op, kids: { left: left2, right: right2 }, type, isAgg: left2.isAgg || right2.isAgg };
     }
     case "NullTestExpression": {
       let node = expr.getChildren("Kw").find((n) => txt(n).toLowerCase() == "not") ? "is-not-null" : "is-null";
@@ -703,7 +989,7 @@ function analyzeExpression(expr, scope) {
       if (opTxt === "not") return { node: "not", e: child, type: "boolean", isAgg: child.isAgg };
       if (opTxt === "-") return { node: "unary-", e: child, type: child.type, isAgg: child.isAgg };
       if (opTxt === "+") return { node: "()", e: child, type: child.type, isAgg: child.isAgg };
-      return diag(expr, `Unknown unary operator: ${opTxt}`, errExpr);
+      return diag(expr, `Unknown unary operator: ${opTxt}`, errExpr2);
     }
     case "CaseExpression": {
       let caseValue = expr.getChild("Expression");
@@ -724,8 +1010,13 @@ function analyzeExpression(expr, scope) {
       let oneOf = [];
       let valueList = expr.getChild("InValueList");
       if (valueList) {
-        oneOf = valueList.getChildren("Expression").map((v) => analyzeExpression(v, scope));
+        oneOf = valueList.getChildren("Expression").map((v) => {
+          let e = analyzeExpression(v, scope);
+          checkTypes(e, [eNode.type], v);
+          return e;
+        });
       } else {
+        diag(expr, "IN (<subquery>) is not yet supported");
         oneOf = [{ node: "genericSQLExpr", kids: { args: [] }, type: "array" }];
       }
       let isAgg = eNode.isAgg || oneOf.some((v) => v.isAgg);
@@ -733,59 +1024,52 @@ function analyzeExpression(expr, scope) {
     }
     case "SubqueryExpression":
     default:
-      return diag(expr, `Unsupported expression "${expr.name}": ${txt(expr)}`, errExpr);
+      return diag(expr, `Unsupported expression "${expr.name}": ${txt(expr)}`, errExpr2);
   }
 }
-function analyzeFunctionCall(expr, scope) {
-  let name = txt(expr.getChild("Identifier")).toLowerCase();
-  let argNodes = expr.getChildren("Expression");
-  let overload = findOverloads(name, config.dialect).find((o) => {
-    return o.params.length == argNodes.length || !!o.params.find((p) => p.isVariadic);
-  });
-  let args = argNodes.map((node, idx) => {
-    let type2 = overload?.params[idx]?.allowedTypes[0];
-    if (type2?.type === "sql native" && type2?.rawType === "kw") {
-      return { node: "genericSQLExpr", kids: { args: [] }, type: "sql native", src: [txt(node)], isAgg: false };
-    } else {
-      return analyzeExpression(node, scope);
+function analyzeTimeExpression(op, left2, right2, node) {
+  if (left2.type !== "date" && left2.type !== "timestamp") return diag(node, "Expected left side to be a date or timestamp", errExpr2);
+  let units = left2.type === "timestamp" ? "second" : "day";
+  if (right2.node == "stringLiteral") {
+    units = parseTemporal(right2);
+    if (right2.node == "stringLiteral") {
+      return diag(node, "Could not parse interval", errExpr2);
     }
-  });
-  let type = overload?.returnType.type;
-  if (type == "generic") type = args[0]?.type || "string";
-  if (type && !isSupportedType(type)) {
-    return diag(expr, `Unsupported function return type ${type} from function ${name}`, errExpr);
-  }
-  let structPaths = /* @__PURE__ */ new Set();
-  args.forEach((a) => walkExpression(a, (e) => {
-    if (e.node != "field") return;
-    structPaths.add(e.path.slice(0, -1).join(".") || scope.table.name);
-  }));
-  let ret;
-  if (["count", "min", "max", "avg", "sum"].includes(name.toLowerCase())) {
-    ret = { node: "aggregate", function: name, e: args[0], type: "number", isAgg: true };
-  } else if (overload && type) {
-    ret = {
-      node: "function_call",
-      type,
-      name,
-      overload,
-      expressionType: overload.returnType.expressionType || "scalar",
-      kids: { args },
-      isAgg: overload.returnType.expressionType == "aggregate" || args.some((a) => a.isAgg)
-    };
-  } else {
-    return diag(expr, `Unknown function: ${name}`, errExpr);
-  }
-  if (structPaths.size > 1 && (ret.node == "aggregate" || ret.expressionType == "aggregate")) {
-    return diag(expr, "Graphene only supports a single table within aggregates. This one has: " + Array.from(structPaths).join(", "), errExpr);
   }
-  let foriegnPaths = Array.from(structPaths).filter((p) => p != scope.table.name);
-  if (foriegnPaths.length > 0) ret.structPath = foriegnPaths[0].split(".");
-  return ret;
-}
-function isSupportedType(value) {
-  let supported = ["string", "number", "boolean", "date", "timestamp", "json", "sql native", "error", "array", "record", "null", "generic"];
-  return supported.includes(value);
+  if (right2.type == "date" || right2.type == "timestamp") {
+    if (op !== "-") return diag(node, "Only subtraction between dates is supported", errExpr2);
+    if (right2.type !== left2.type) return diag(node, `Expected right side to be a ${left2.type}`, errExpr2);
+    return { node: "timeDiff", kids: { left: left2, right: right2 }, units, type: "interval", isAgg: false };
+  }
+  if (right2.type == "interval") {
+    let typeDef = { type: left2.type };
+    return { node: "delta", kids: { base: left2, delta: right2 }, op, units, type: left2.type, typeDef, isAgg: false };
+  }
+  return diag(node, "Expected right side to be a date or interval", errExpr2);
+}
+function ensureSameType(left2, leftNode, right2, rightNode) {
+  if (left2.type === "error" || right2.type === "error") return;
+  if (left2.node === "parameter" || right2.node === "parameter") return;
+  if (isTemporalType(left2.type)) checkTypes(right2, [left2.type], rightNode);
+  if (isTemporalType(right2.type)) checkTypes(left2, [right2.type], leftNode);
+  if (left2.type !== right2.type) diag(rightNode, `Expected ${left2.type}, got ${right2.type}`);
+}
+function checkTypes(expr, expected, node) {
+  if (expr.type === "error") return;
+  if (expr.node === "parameter") return;
+  if (expected.includes(expr.type)) return;
+  if (expected.includes("generic")) return;
+  let dt = expected.find((t) => t == "date") || expected.find((t) => t == "timestamp");
+  if (expr.node == "stringLiteral" && dt) {
+    let parsed = parseTemporalLiteral(expr.literal, dt);
+    if (!parsed) return diag(node, `Could not parse ${dt} literal: "${expr.literal}"`, void 0);
+    let typeDef = { type: parsed.type, timeframe: parsed.timeframe };
+    Object.assign(expr, { node: "timeLiteral", literal: parsed?.literal, type: parsed?.type, typeDef });
+  } else if (expr.node == "stringLiteral" && expected.includes("interval")) {
+    let parsed = parseIntervalLiteral(expr.literal);
+    if (!parsed) return diag(node, `Could not parse interval literal: "${expr.literal}"`, void 0);
+    return Object.assign(expr, { node: "numberLiteral", literal: parsed.quantity.toString(), type: "interval", intervalUnit: parsed.unit });
+  } else diag(node, `Expected types: ${expected.join(", ")}`);
 }
 function lookupField(expr, scope) {
   let pathNodes = expr.getChildren("Identifier");
@@ -886,6 +1170,8 @@ function convertDataType(dataType) {
       return "number";
     case "FLOAT64":
       return "number";
+    case "BOOL":
+      return "boolean";
     case "BOOLEAN":
       return "boolean";
     case "DATE":
@@ -918,58 +1204,61 @@ function convertDataType(dataType) {
       return null;
   }
 }
-var FILE_MAP, diagnostics, TABLE_NODE_MAP, FIELD_NODE_MAP, NODE_ENTITY_MAP, analysisQueue, errExpr;
+var FILE_MAP, diagnostics, TABLE_NODE_MAP, FIELD_NODE_MAP, NODE_ENTITY_MAP, analysisQueue, errExpr2;
 var init_analyze = __esm({
   "../lang/analyze.ts"() {
+    "use strict";
     init_util();
     init_metadata();
     init_config();
     init_functions();
     init_params();
+    init_temporalLiterals();
     FILE_MAP = {};
     diagnostics = [];
     TABLE_NODE_MAP = /* @__PURE__ */ new WeakMap();
     FIELD_NODE_MAP = /* @__PURE__ */ new WeakMap();
     NODE_ENTITY_MAP = new NodeWeakMap();
     analysisQueue = /* @__PURE__ */ new Set();
-    errExpr = { node: "error", type: "error" };
+    errExpr2 = { node: "error", type: "error" };
   }
 });
 
 // ../lang/parser.terms.js
-var table, primary_key, as, on, not, exists, from, inner, left, right, full, cross, join, select, where, group, by, order, asc, desc, limit, offset, _in, is, _null, _true, _false, or, and, like;
+var table, primary_key, join, as, on, or, and, like, not, _in, from, inner, left, right, full, cross, select, where, group, by, order, asc, desc, limit, offset, is, _null, exists, _true, _false;
 var init_parser_terms = __esm({
   "../lang/parser.terms.js"() {
+    "use strict";
     table = 6;
-    primary_key = 11;
-    as = 19;
-    on = 22;
-    not = 31;
-    exists = 49;
-    from = 53;
-    inner = 59;
-    left = 61;
-    right = 63;
-    full = 65;
-    cross = 67;
-    join = 69;
-    select = 72;
-    where = 80;
-    group = 83;
-    by = 85;
-    order = 91;
-    asc = 95;
-    desc = 97;
-    limit = 100;
-    offset = 102;
-    _in = 105;
+    primary_key = 12;
+    join = 16;
+    as = 22;
+    on = 25;
+    or = 31;
+    and = 34;
+    like = 43;
+    not = 45;
+    _in = 55;
+    from = 60;
+    inner = 66;
+    left = 68;
+    right = 70;
+    full = 72;
+    cross = 74;
+    select = 77;
+    where = 84;
+    group = 87;
+    by = 89;
+    order = 95;
+    asc = 99;
+    desc = 101;
+    limit = 104;
+    offset = 106;
     is = 109;
     _null = 111;
-    _true = 115;
-    _false = 117;
-    or = 130;
-    and = 132;
-    like = 141;
+    exists = 129;
+    _true = 133;
+    _false = 135;
   }
 });
 
@@ -981,6 +1270,7 @@ function specializeIdentifier(value) {
 var keywords;
 var init_tokens = __esm({
   "../lang/tokens.js"() {
+    "use strict";
     init_parser_terms();
     keywords = {
       select,
@@ -1022,25 +1312,26 @@ import { LRParser } from "@lezer/lr";
 var spec_Identifier, parser;
 var init_parser = __esm({
   "../lang/parser.js"() {
+    "use strict";
     init_tokens();
-    spec_Identifier = { __proto__: null, table: 12, primary_key: 22, join_one: 30, join_many: 34, as: 38, on: 44, not: 62, case: 72, when: 78, then: 82, else: 88, end: 92, exists: 98, from: 106, inner: 118, left: 122, right: 126, full: 130, cross: 134, join: 138, select: 144, distinct: 148, where: 160, group: 166, by: 170, having: 176, order: 182, asc: 190, desc: 194, limit: 200, offset: 204, in: 210, is: 218, null: 222, true: 230, false: 234, count: 244, extract: 250, or: 260, and: 264, like: 282 };
+    spec_Identifier = { __proto__: null, table: 12, primary_key: 24, join: 32, one: 36, many: 40, as: 44, on: 50, or: 62, and: 68, like: 86, not: 90, in: 110, from: 120, inner: 132, left: 136, right: 140, full: 144, cross: 148, select: 154, distinct: 158, where: 168, group: 174, by: 178, having: 184, order: 190, asc: 198, desc: 202, limit: 208, offset: 212, is: 218, null: 222, case: 232, when: 238, then: 242, else: 248, end: 252, exists: 258, true: 266, false: 270, count: 280, extract: 286, extend: 306 };
     parser = LRParser.deserialize({
       version: 14,
-      states: "BbQYQPOOOOQO'#C`'#C`OOQO'#Db'#DbOtQPO'#DaOOQO'#Du'#DuO#QQPO'#DtOOQO'#D}'#D}O#XQPO'#D|OOQO'#EQ'#EQO$YQPO'#EPOOQO'#EV'#EVO#XQPO'#EUOOQO'#EY'#EYO$YQPO'#EXOOQO'#Ec'#EcO$_QPO'#EbOOQO'#Fi'#FiO$dQPO'#D`O$qQPO'#C_O$vQPO'#FeQYQPOOQ%hQPO'#FeO%mQPO'#DdO]QPO'#DfO&zQPO'#DeOOQO'#Fv'#FvO(mQPO,59{O*tQPO'#CtO,^QPO'#CtOOQO'#Cz'#CzOOQO'#Cy'#CyO#XQPO'#CxOOQO'#DP'#DPO,fQPO'#DOOOQO'#D^'#D^O,mQPO'#DfOOQO'#Dw'#DwOOQO'#Dz'#DzO.bQPO'#DyOOQO'#Dy'#DyO/_QPO,5:`O|QPO,5:`O0SQPO'#D]OOQO'#En'#EnOOQO'#Er'#ErOOQO'#Et'#EtOOQO'#Eq'#EqOOQO'#Ev'#EvOOQO'#Fy'#FyOOQO'#Ey'#EyO0XQPO'#ExOOQO'#E|'#E|O0^QPO'#E{OOQO'#Fu'#FuO0cQPO'#CtO0hQPO,5:hOOQO'#ES'#ESO|QPO,5:kO1[QPO,5:pO2OQPO,5:sO2WQPO,5:|OOQO-E9g-E9gO2{QPO,58yOOQO,5<P,5<POOQO-E9c-E9cOOQO'#Cn'#CnOOQO'#Cp'#CpOOQO,5:O,5:OO3TQPO,5:OO3YQPO,5:QOOQO,5:P,5:PO3TQPO,5:POOQO'#Dh'#DhOOQO'#Dj'#DjOOQO'#Dl'#DlOOQO'#Dn'#DnOOQO'#Dp'#DpOOQO'#Dr'#DrOtQPO'#DgO(hQPO'#DgOOQO'#Fj'#FjO3_QPO1G/gOOQO,5<R,5<RO4RQPO,5;kO4YQPO,59`OOQO-E9e-E9eOOQO,5:f,5:fOOQO,59d,59dOOQO'#DS'#DSO#XQPO'#DROOQO'#Fh'#FhO7wQPO,59jO8SQPO,59jO8ZQPO,5;lOOQO,5:e,5:eO3TQPO,5:eOOQO'#Eh'#EhO8bQPO,5;RO8gQPO,5;ROOQO'#El'#ElO8oQPO,5;VOOQO'#FR'#FROOQO'#FT'#FTOOQO'#F^'#F^OOQO'#FV'#FVOOQO'#F`'#F`OOQO'#Fa'#FaO#XQPO,59cO#XQPO,59cO#XQPO,59cO#XQPO,59cO#XQPO,59cO8wQPO1G/zO9kQPO1G/zO9kQPO1G/zO]QPO,59wO:`QPO,5;dO:mQPO,5;gO:uQPO1G0VO;jQPO'#E[O<eQPO1G0_OOQO'#Ee'#EeO=YQPO1G0hO=_QPO1G.eO>fQPO1G1jOOQO1G/j1G/jOOQO1G/l1G/lOOQO1G/k1G/kO>kQPO,5:ROtQPO,5:ROOQO-E9h-E9hO?rQPO1G1VOOQO1G1V1G1VP?|QPO'#FgO@RQPO,59mOOQO-E9f-E9fOOQO'#DX'#DXO#XQPO'#DWOOQO'#DZ'#DZOOQO1G/U1G/UO7}QPO1G/UO7wQPO1G/UOOQO1G1W1G1WOOQO1G0P1G0PO,mQPO1G0mO@YQPO1G0mOOQO,5;q,5;qOOQO1G0q1G0qO8rQPO1G0qOB}QPO1G.}OCUQPO1G.}OExQPO1G.}OFSQPO1G.}OOQO1G.}1G.}OOQO,5<V,5<VOF^QPO7+%fOOQO-E9i-E9iOGQQPO7+%fOGuQPO1G/cOGzQPO1G1OOOQO1G1O1G1OOHRQPO1G1OO#XQPO1G1OOOQO'#FO'#FOOHWQPO1G1ROH]QPO7+%qOIPQPO7+%qOOQO'#E^'#E^OOQO'#E`'#E`OOQO,5:v,5:vOJfQPO7+%yOJpQPO7+%yOOQO7+&S7+&SOJwQPO'#CtOOQO'#Cj'#CjOOQO'#Cl'#ClOOQO'#Ci'#CiOKOQPO'#ChO-WQPOOOL_QPO'#FuOLfQPO'#FuOOQO'#Ft'#FtOLmQPO'#CvOOQO'#Fr'#FrOLrQPO'#FfONPQPO7+$PO]QPO7+'UOOQO'#Cq'#CqO#XQPO1G/mONWQPO1G/mO! _QPO7+&qO! fQPO7+&qOOQO7+&q7+&qOOQO'#DU'#DUO#XQPO1G/XO! nQPO,59rOOQO7+$p7+$pO7}QPO7+$pO! uQPO'#EjO!!PQPO7+&XO,mQPO7+&XOOQO7+&]7+&]P|QPO'#FkO!!UQPO<<IQOOQO7+$}7+$}OOQO7+&j7+&jO!!xQPO7+&jO#XQPO7+&mO!#PQPO<<I]OOQO,5<W,5<WO!#sQPO<<IeOOQO-E9j-E9jOOQO'#Cd'#CdO!$kQPO,58}O!%{QPO,59SO3TQPO,59bOOQO,5<Q,5<QOOQO-E9d-E9dOOQO<<Gk<<GkO!&TQPO<<JpO!&YQPO7+%XO#XQPO7+%XO!'`QPO,5<XOOQO<<J]<<J]O!'jQPO<<J]OOQO-E9k-E9kO!'qQPO7+$sOOQO<<H[<<H[O!(OQPO,5;UO!(VQPO,5;UOOQO<<Is<<IsO!(_QPO<<IsOOQO<<JU<<JUO!(dQPO<<JXP2OQPO'#FlOOQO'#Cf'#CfOOQO'#Ce'#CeOOQO1G.i1G.iO!(kQPO1G.nO3TQPO1G.nOOQO1G.|1G.|OOQOAN@[AN@[O!(pQPO<<HsOOQOAN?wAN?wP#XQPO'#FmO!)vQPO1G0pOOQOAN?_AN?_OOQOAN?sAN?sO!)}QPO'#CtO!+bQPO'#CsOOQO7+$Y7+$YO!&OQPO7+$YO!(kQPO,59_O!(kQPO<<GtOOQO1G.y1G.yOOQOAN=`AN=`",
-      stateData: "!+l~O$dOSPOS~OUPO!VQO!jSO!rUO!uWO!zYO!}[O#W^O~OTfO$egO~OTkOomOpnOqnOtpO!RrO!ouO#P!QO#c{O#d!QO#g|O#i}O#k!VO#n!RO#q!TO$esO~O!ltO~P|OTkOomOpnOqnOtpO!RrO#P!QO#c{O#d!QO#g|O#i}O#k!VO#n!RO#q!TO$esO~O!w!YO~O#P!^O~O$b!SX$o!SX$k!SX~P]OT!`O~O$o!aOU$XX!V$XX!j$XX!r$XX!u$XX!z$XX!}$XX#W$XX$b$XX~O$o!aO~OT!dOc!cO!V!WX!]!WX!_!WX!a!WX!c!WX!e!WX!g!WX!j!WX!r!WX!u!WX!z!WX!}!WX#W!WX$b!WX$o!WX$k!WXf!WX~OT!dOc!cO!V!XX!]!XX!_!XX!a!XX!c!XX!e!XX!g!XX!j!XX!r!XX!u!XX!z!XX!}!XX#W!XX$b!XX$o!XX$k!XXf!XX~O!]!jO!_!kO!a!lO!c!mO!e!nO!g!oO~O!V!Ta!j!Ta!r!Ta!u!Ta!z!Ta!}!Ta#W!Ta$b!Ta$o!Ta$k!Ta~P(XO$e!uO$g!tOchXihXohXphXqhX!ohX#]hX#ahX#vhX#xhX#zhX#{hX#|hX#}hX$OhX$PhX$RhX$UhX$VhX~OThX!VhX!jhX!rhX!uhX!zhX!}hX#WhX$bhX$lhX$ohXwhX$khXyhX!OhX!]hX!_hX!ahX!chX!ehX!ghX|hX~P)aOT!vO!o!xO~Ow!zO~P#XO!VQO!jSO!rUO!uWO!zYO!}[O#W^O~P#XOi#[OomOp#]Oq#]O!o#^O#]#SO#a#VO#v#XO#x#YO#z#[O#{#[O#|#[O#}#[O$O#[O$P#[O$R#ZO$U#^O$V#^O~OT!dOc!cO!V!mX!j!mX!r!mX!u!mX!z!mX!}!mX#W!mX$b!mX$l!mX$o!mX$k!mX~P-WO$l#dO!V!ha!j!ha!r!ha!u!ha!z!ha!}!ha#W!ha$b!ha$o!ha$k!ha~O$e#gO~O$e#hO~O$e#iO~OT!vO~O!V!pa!j!pa!r!pa!u!pa!z!pa!}!pa#W!pa$b!pa$o!pa$k!pa~P-WO!V!xa!j!xa!r!xa!u!xa!z!xa!}!xa#W!xa$b!xa$o!xa$k!xa~P-WOT#kO#P#kO~O#Y#mO!V#Ua!j#Ua!r#Ua!u#Ua!z#Ua!}#Ua#W#Ua$b#Ua$o#Ua$k#Ua~Oc!cO$e#oO~OT!dO~O$k#rO~O!V!Ti!j!Ti!r!Ti!u!Ti!z!Ti!}!Ti#W!Ti$b!Ti$o!Ti$k!Ti~P(XO$k#xO~P#XO$g!tOThachaihaohaphaqha!Vha!jha!oha!rha!uha!zha!}ha#Wha#]ha#aha#vha#xha#zha#{ha#|ha#}ha$Oha$Pha$Rha$Uha$Vha$bha$lha$ohawha$khayha!Oha!]ha!_ha!aha!cha!eha!gha|ha_haahatha!Rha#Pha#cha#dha#gha#iha#kha#nha#qha$eha~Ow!zO|#|O!O$OO~Ow!zO~P-WO$k$SO~P-WO$e$UO~O#]#SO$R#ZO~OomO#c{O~O!V!hi!j!hi!r!hi!u!hi!z!hi!}!hi#W!hi$b!hi$o!hi$k!hi~P|O$l$aO!V!hi!j!hi!r!hi!u!hi!z!hi!}!hi#W!hi$b!hi$o!hi$k!hi~O!ltO!o$gO$k$fO~P#XOT$iO#d$iO~O$l$kO!V!si!j!si!r!si!u!si!z!si!}!si#W!si$b!si$o!si$k!si~O#R$mO#T$nO!V#OX!j#OX!r#OX!u#OX!z#OX!}#OX#W#OX$b#OX$l#OX$o#OX$k#OX~O$l$pO!V!{i!j!{i!r!{i!u!{i!z!{i!}!{i#W!{i$b!{i$o!{i$k!{i~O#P$rO~OT$sO_$tOa$uOomOpnOqnOtpO!RrO#P!QO#c{O#d!QO#g|O#i}O#k!VO#n!RO#q!TO$esO~O$e%QO~Of%RO!V!Za!]!Za!_!Za!a!Za!c!Za!e!Za!g!Za!j!Za!r!Za!u!Za!z!Za!}!Za#W!Za$b!Za$o!Za$k!Za~O$k%WO$l%UO~P-WO$g!tO~Oy%XO~P-WO$e%`O~Oi#[OomOp#]Oq#]O!o#^O#]#SO#z#[O#{#[O#|#[O#}#[O$O#[O$P#[O$R#ZO$U#^O$V#^OTkicki!Vki!jki!rki!uki!zki!}ki#Wki#aki#vki$bki$lki$okiwki$kkiyki!Oki!]ki!_ki!aki!cki!eki!gki|ki~O#x#YO~P@_O#xki~P@_O!o#^O$U#^O$V#^OTkickiikioki!Vki!jki!rki!uki!zki!}ki#Wki#]ki#aki#vki#xki#zki#{ki#|ki#}ki$Oki$Pki$Rki$bki$lki$okiwki$kkiyki!Oki!]ki!_ki!aki!cki!eki!gki|ki~Op#]Oq#]O~PC]Opkiqki~PC]O!V!hq!j!hq!r!hq!u!hq!z!hq!}!hq#W!hq$b!hq$o!hq$k!hq~P|O$l%cO!V!hq!j!hq!r!hq!u!hq!z!hq!}!hq#W!hq$b!hq$o!hq$k!hq~O$k%dO~O$k%eO~P-WO$k%eO~O!VQO~O!V!sq!j!sq!r!sq!u!sq!z!sq!}!sq#W!sq$b!sq$o!sq$k!sq~P|O$l%hO!V!sq!j!sq!r!sq!u!sq!z!sq!}!sq#W!sq$b!sq$o!sq$k!sq~O!V!{q!j!{q!r!{q!u!{q!z!{q!}!{q#W!{q$b!{q$o!{q$k!{q~OT#kO#P#kO~PItO$l%jO~PItOT%lO~P)aOT%nO~Oi$iXo$iXp$iXq$iX!o$iX#]$iX#a$iX#v$iX#x$iX#z$iX#{$iX#|$iX#}$iX$O$iX$P$iX$R$iX$U$iX$V$iX~Oc$hX~PKTOc$nX~PKTOc!cO~O$l%pOT$YX_$YXa$YXo$YXp$YXq$YXt$YX!R$YX#P$YX#c$YX#d$YX#g$YX#i$YX#k$YX#n$YX#q$YX$e$YX$k$YX~O$k%rO~P=_Of%RO!V!Zi!]!Zi!_!Zi!a!Zi!c!Zi!e!Zi!g!Zi!j!Zi!r!Zi!u!Zi!z!Zi!}!Zi#W!Zi$b!Zi$o!Zi$k!Zi~O$k%wO~P#XO$k%wO$l%xO~O!Oza~P-WO$l%|O$k#^X~P-WO$k&OO~O!V!hy!j!hy!r!hy!u!hy!z!hy!}!hy#W!hy$b!hy$o!hy$k!hy~P|O$k&QO~P-WO!V!sy!j!sy!r!sy!u!sy!z!sy!}!sy#W!sy$b!sy$o!sy$k!sy~P|OT#kO#P#kO!V!{y!j!{y!r!{y!u!{y!z!{y!}!{y#W!{y$b!{y$o!{y$k!{y~OZ&TOTVa_VaaVaoVapVaqVatVa!RVa#PVa#cVa#dVa#gVa#iVa#kVa#nVa#qVa$eVa$kVa$lVa~Oc!cOf%RO~O$k&ZO~O!V!Zq!]!Zq!_!Zq!a!Zq!c!Zq!e!Zq!g!Zq!j!Zq!r!Zq!u!Zq!z!Zq!}!Zq#W!Zq$b!Zq$o!Zq$k!Zq~P-WO$k$aa$l$aa~P-WO$k&]O~P#XOwuq|uq!Ouq~P-WO$k#^a~P#XO$l&_O$k#^a~O$k&`O~O$k&aO~P-WOT&bO~O!V!Zy!]!Zy!_!Zy!a!Zy!c!Zy!e!Zy!g!Zy!j!Zy!r!Zy!u!Zy!z!Zy!}!Zy#W!Zy$b!Zy$o!Zy$k!Zy~P-WO$k#^i~P#XO$g!tOihXThX_hXahXohXphXqhXthX!RhX#PhX#chX#dhX#ghX#ihX#khX#nhX#qhX$ehX$khX$lhX~Oi&fO~OP$U!op~",
-      goto: "@[$oPPP$p$tPP$x$|%P%SP$x%V%ZP%ZP%_P%q&ZP&g&mP$x'o'o(j)cPPP'o*tP+m+sP+yP+|,SP,WP'o,bP-Z-o-zP.Y.Y._/]/aP/aP/aP/aP/aP/eP-o/lP/wP/}0`P-o0kP-o0vP1RP-o1XP-o1dP1oP1wP1wP-o1zP2VP'o2YP2r.d2xP3]PP4[5TP5TP4[P5|6wP.d7pP8i5|.d8lP9PP9ePPPPPP9zP:d:zPP$p;c;i;o<q<{=Y=`=n=tPPPP>OP>S>W?}PP5|@WTcOdTbOdT$}#o%PR%m$sR&V%mR&U%mT$w#o%PT$v#o%PQ!ffQ!ihQ#RvQ#p!`Q%o$|R&X%nQ!efQ!hhQ#QvQ#q!fQ#s!iQ$T#RQ&Y%oR&e&XQ%S#tQ%u%TQ&W%nR&g&eQ&d&WR&i&g!h!VTVZoqsy!Z!u!{#_#`#a#b#c#d#h#}$U$a$h$k%S%U%Y%`%b%c%g%h%u%x%|&^&_S$z#o%PS&c&W&gR&h&f!h!VTVZoqsy!Z!u!{#_#`#a#b#c#d#h#}$U$a$h$k%S%U%Y%`%b%c%g%h%u%x%|&^&_T$y#o%P!moTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_!lnTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_v#Uv!X![#O#P#w#z$Z$[$e$x%Z%^%f%t%v%z&R&[R$Y#W!mqTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_X!|q!}#O$RX!{q!}#O$RR%Y#zQ$Q!}R%]$RT#}!}$RQ$P!}S%[$Q$RR%{%]!mzTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_SeOdS!ggsQ$d#gQ%_$UQ%s%QR&P%`c`Oadgs#g$U%Q%`bROadgs#g$U%Q%`R%g$jViR!p#uUhR!p#u!m!VTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_T!rj!sT!qj!sS!pj!sR#u!qcTOadgs#g$U%Q%`QyTR$h#hQxTQ#fyQ#j!Z]$`#d$a$k%b%c%hcwTy!Z#d$a$k%b%c%hcVOadgs#g$U%Q%`cXOadgs#g$U%Q%`Q!ZXR!]]cZOadgs#g$U%Q%`c]Oadgs#g$U%Q%`Q#l!]V%i$p%j&SR$o#kc_Oadgs#g$U%Q%`R#n!^v#Tv!X![#O#P#w#z$Z$[$e$x%Z%^%f%t%v%z&R&[R$V#UQ%_$UR&P%`s#Wv!X![#O#P#w#z$e$x%Z%^%f%t%v%z&R&[!l!PTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_Q$X#WR%a$Y!m!QTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_!m!OTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_!h!VTVZoqsy!Z!u!{#_#`#a#b#c#d#h#}$U$a$h$k%S%U%Y%`%b%c%g%h%u%x%|&^&_T$z#o%P!m!STVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_!m!UTVZoqsy!Z!u!{#_#`#a#b#c#d#h#o#}$U$a$h$k%P%S%U%Y%`%b%c%g%h%u%x%|&^&_R$j#is#_v!X![#O#P#w#z$e$x%Z%^%f%t%v%z&R&[u#`v!X![#O#P#w#z$Z$e$x%Z%^%f%t%v%z&R&[w#av!X![#O#P#w#z$Z$[$e$x%Z%^%f%t%v%z&R&[v#[v!X![#O#P#w#z$Z$[$e$x%Z%^%f%t%v%z&R&[R$W#Uy#bv!X![#O#P#w#z$Z$[$]$e$x%Z%^%f%t%v%z&R&[{#cv!X![#O#P#w#z$Z$[$]$^$e$x%Z%^%f%t%v%z&R&[QdOR!bdQ%P#oR%q%PblTy!Z#d$a$k%b%c%h!`!WVZoqs!u!{#_#`#a#b#c#h#o#}$U$h%P%S%U%Y%`%g%u%x%|&W&^&_&f&gT!wl!WQ!}qS#{!}$RR$R#O`aOdgs#g$U%Q%`R!_aQ!sjR#v!sQ#exU$b#e$c$lQ$c#fR$l#jQ$q#lR%k$qQ%V#wS%y%V%}R%}%^T%O#o%PT$|#o%PbvTy!Z#d$a$k%b%c%hQ!XVQ![ZQ!yoQ#OqQ#PsQ#w!uQ#z!{Q$Z#_Q$[#`Q$]#aQ$^#bQ$_#cQ$e#hS$x#o%PQ%Z#}S%^$U%`Q%f$hQ%t%SY%v%U%x%|&^&_Q%z%YQ&R%gR&[%uQjRQ#t!pR%T#uT${#o%P",
-      nodeNames: "\u26A0 Comment Program TableStatement Kw Identifier table ColumnDef DataType PrimaryKey Kw primary_key JoinDef JoinType Kw join_one Kw join_many Kw as Alias Kw on BinaryExpression Ref = ComputedDef BinaryExpression UnaryExpression UnaryOperator Kw not - + CaseExpression Kw case WhenClause Kw when Kw then ElseClause Kw else Kw end ExistsExpression Kw exists QueryStatement FromClause Kw from TableName Subquery SubqueryExpression JoinClause Kw inner Kw left Kw right Kw full Kw cross Kw join SelectClause Kw select Kw distinct SelectItem Wildcard * WhereClause Kw where GroupByClause Kw group Kw by HavingClause Kw having OrderByClause Kw order OrderItem Number Kw asc Kw desc LimitClause Kw limit Kw offset InExpression Kw in InValueList NullTestExpression Kw is Kw null String Boolean Kw true Kw false Null Param Count Kw count ExtractExpression Kw extract ExtractUnit FunctionCall Parenthetical Kw or Kw and ComparisonOp != <> < > <= >= Kw like AddOp MulOp / % ViewStatement",
-      maxTerm: 169,
+      states: "G`QYQPOOOOQO'#C`'#C`OOQO'#Di'#DiOwQPO'#DhOOQO'#Dz'#DzO#TQPO'#DyOOQO'#ER'#EROOQO'#EU'#EUO#[QPO'#ETOOQO'#EZ'#EZOOQO'#E^'#E^O#[QPO'#E]OOQO'#Eg'#EgO#aQPO'#EfOOQO'#Fp'#FpO#}QPO'#DgO$[QPO'#C_OOQO'#Fj'#FjO$[QPO'#FiO$aQPO'#FlQYQPOOQ%UQPO'#FlO%ZQPO'#EQO%ZQPO'#EYO(hQPO'#CcO(rQPO'#CcO(wQPO'#DkO#fQPO'#DmO*UQPO'#DlOOQO'#GP'#GPO+wQPO,5:SO,kQPO'#CcO-zQPO'#CcOOQO'#DY'#DYO.SQPO'#DmOOQO'#D|'#D|OOQO'#EP'#EPOOQO'#EO'#EOO.mQPO,5:eO!PQPO,5:eO0oQPO'#EOOOQO'#En'#EnOOQO'#Eq'#EqOOQO'#Es'#EsO1iQPO'#ErOOQO'#FQ'#FQO1pQPO'#FPOOQO'#FU'#FUOOQO'#FW'#FWOOQO'#FT'#FTOOQO'#FY'#FYOOQO'#GT'#GTOOQO'#F]'#F]O1uQPO'#F[OOQO'#GS'#GSOOQO'#F`'#F`OOQO'#GR'#GROOQO'#GU'#GUOOQO'#F}'#F}O%ZQPO'#EpO1zQPO'#F_OOQO'#EW'#EWO!PQPO,5:oO2PQPO,5:wO2XQPO,5;QOOQO-E9n-E9nO2|QPO,58yO3UQPO,5<TOOQO,5<W,5<WOOQO-E9j-E9jO3ZQPO,5:lO3}QPO,5:tOOQO,5<X,5<XO4qQPO,58}OOQO-E9k-E9kOOQO'#Cq'#CqOOQO'#Cs'#CsOOQO,5:V,5:VO8]QPO,5:VO8bQPO,5:XOOQO,5:W,5:WO8]QPO,5:WOOQO'#Ck'#CkOOQO'#Do'#DoOOQO'#Dq'#DqOOQO'#Ds'#DsOOQO'#Du'#DuOOQO'#Dw'#DwOwQPO'#DnO8gQPO'#DnOOQO'#Fq'#FqO8lQPO1G/nO9`QPO,5;uOOQO,5:k,5:kO9gQPO,5<OO9nQPO1G0PO:bQPO1G0PO:bQPO1G0POOQO'#Cz'#CzOOQO'#C}'#C}OOQO'#DW'#DWOOQO'#DP'#DPO;VQPO,59}OOQO'#D['#D[OOQO'#D_'#D_OOQO'#Dd'#DdO;_QPO,59}OOQO'#El'#ElO;dQPO,5;VO%ZQPO,59hO%ZQPO,59hO%ZQPO,59hO%ZQPO,59hO%ZQPO,59hOOQO,5:j,5:jO8]QPO,5:jO;lQPO,5;^OOQO'#Ev'#EvOOQO'#Ft'#FtO;sQPO,5;^O%ZQPO'#EuO#fQPO,5;kO<OQPO,5;vOOQO,5;[,5;[O<]QPO,5;yO<eQPO1G0ZO=YQPO'#E`O>TQPO1G0cOOQO'#Ei'#EiO>xQPO1G0lO>}QPO1G.eO@OQPO1G1nO@TQPO1G1oPAUQPO'#FmOOQO1G/q1G/qOOQO1G/s1G/sOOQO1G/r1G/rOAZQPO,5:YOwQPO,5:YOOQO-E9o-E9oOBbQPO1G1aOOQO1G1a1G1aOOQO1G1j1G1jOOQO,5<^,5<^OBlQPO7+%kOOQO-E9p-E9pOC`QPO7+%kOOQO,59k,59kODTQPO1G/iO.SQPO1G/iOOQO1G0q1G0qO;gQPO1G0qOGhQPO1G/SOGoQPO1G/SOKRQPO1G/SOK]QPO1G/SOOQO1G/S1G/SOOQO1G0U1G0UO;sQPO1G0xOOQO-E9r-E9rOOQO'#E{'#E{OOQO'#E}'#E}OOQO1G0x1G0xO;yQPO1G0xO%ZQPO'#EzOKgQPO,5;aOKnQPO1G1VOKsQPO1G1bOOQO1G1b1G1bOKzQPO1G1bO%ZQPO1G1bOOQO'#Fb'#FbOLPQPO1G1eOLUQPO7+%uOLxQPO7+%uOOQO'#Eb'#EbOOQO'#Ed'#EdOOQO,5:z,5:zON_QPO7+%}ONiQPO7+%}OOQO7+&W7+&WO!!WQPO'#CcO!!_QPO'#CjO$[QPO'#CiO/bQPO'#CxOOQO'#F|'#F|OOQO'#F{'#F{O!!gQPO'#FnO!#nQPO7+$PO!#uQPO'#CxO#fQPO7+'YONpQPO'#CcOOQO'#GW'#GWO!#zQPO'#FuO!%RQPO7+'ZOOQO'#Ct'#CtO%ZQPO1G/tO!%YQPO1G/tO!&aQPO7+&{O!&iQPO7+&{OOQO7+&{7+&{P!PQPO'#FrO!&pQPO<<IVO.SQPO7+%TO!'dQPO'#DfO!'nQPO7+%TOOQO7+&]7+&]OOQO7+&d7+&dO;yQPO7+&dO!'sQPO,5;fOOQO'#Ex'#ExO%ZQPO1G0{OOQO7+&q7+&qOOQO7+&|7+&|O!'zQPO7+&|O%ZQPO7+'PO!(RQPO<<IaOOQO,5<_,5<_O!(uQPO<<IiOOQO-E9q-E9qOOQO'#Ce'#CeO!)mQPO,59OOOQO'#Cm'#CmOOQO'#Co'#CoOOQO,59U,59UO!*wQPO,59TO;VQPO,5<PO!+PQPO,5<PO;dQPO,5<QO%ZQPO,59eO%ZQPO,59eO%ZQPO,59eO%ZQPO,59eO%ZQPO,59eO8]QPO,59dOOQO,5<Y,5<YOOQO-E9l-E9lOOQO<<Gk<<GkO%ZQPO,59dO!+UQPO<<JtOOQO,5<a,5<aOOQO-E9s-E9sOOQO<<Ju<<JuO!+ZQPO7+%`O%ZQPO7+%`OOQO-E9m-E9mO!,aQPO<<JgOOQO<<Jg<<JgO!,hQPO,5<ZO!,rQPO<<HoO!,wQPO,5:QO!-PQPO,5:QOOQO<<Ho<<HoOOQO<<JO<<JOO!-WQPO7+&gOOQO<<Jh<<JhO!-eQPO<<JkP2PQPO'#FsOOQO'#Cg'#CgOOQO'#Cf'#CfOOQO1G.j1G.jO$[QPO1G.oO8]QPO1G.oO!-lQPO1G1kO.SQPO1G1kOOQO1G1l1G1lO;gQPO1G1lO!.{QPO1G/PO!/SQPO1G/PO!0bQPO1G/PO!0lQPO1G/POOQO1G/P1G/POOQO1G/O1G/OO!0vQPO1G/OOOQOAN@`AN@`O!1vQPO<<HzP%ZQPO'#FoOOQOAN@RAN@ROOQOAN>ZAN>ZO!2|QPO1G/lOOQOAN@VAN@VO!3TQPO'#CvOOQO7+$Z7+$ZO!*zQPO7+$ZO.SQPO7+'VO!3YQPO7+'VOOQO7+'W7+'WO$[QPO,59bO$[QPO<<GuO!3_QPO<<JqOOQO<<Jq<<JqOOQO1G.|1G.|OOQOAN=aAN=aOOQOAN@]AN@]",
+      stateData: "!3i~O$lOSPOS~OUPO!^QO!oSO!vUO!yVO#OXO#RYO#[[O$_aO~OThO$nkO~OToO}qO!PzO!QzO!StO#T!TO#cyO#h{O#u}O#v!TO#y!PO#{!QO$Q!UO$T!XO$V!YO$nrO~O!qsO~P!PO!{!_O~O#T!bO~O!^QO!oSO!vUO!yVO#OXO#RYO#[[O~O$j!ZX$y!ZX$t!ZX~P#fOThO~O$y!fOU$`X!^$`X!o$`X!v$`X!y$`X#O$`X#R$`X#[$`X$_$`X$j$`X~O$y!fO~OToO}qO!PzO!QzO#T!TO#cyO#h{O#u}O#v!TO#y!PO#{!QO$Q!UO$T!XO$V!YO$nrO~O$m!jOTVX`VXfVX!^VX!dVX!fVX!hVX!jVX!lVX!oVX!vVX!yVX#OVX#RVX#[VX$jVX$yVX$tVXkVX}VX!PVX!QVX#TVX#cVX#hVX#uVX#vVX#yVX#{VX$QVX$TVX$VVX$rVX~O$nVXiVX~P&[OT!kO~OT!nOf!mO`!_X!^!_X!d!_X!f!_X!h!_X!j!_X!l!_X!o!_X!v!_X!y!_X#O!_X#R!_X#[!_X$j!_X$y!_X$t!_Xi!_X~OT!nOf!mO`!`X!^!`X!d!`X!f!`X!h!`X!j!`X!l!`X!o!`X!v!`X!y!`X#O!`X#R!`X#[!`X$j!`X$y!`X$t!`Xi!`X~O`!tO!d!uO!f!vO!h!wO!j!xO!l!yO~O!^![a!o![a!v![a!y![a#O![a#R![a#[![a$j![a$y![a$t![a~P+cO$n#OOoVXrVXtVXuVXvVXwVXxVXyVX{VX!SVX!TVX!UVX!XVX#aVX#kVX#mVX#rVX#pVX~P&[OT!kO!S#PO~O!^QO!oSO!vUO!yVO#OXO#RYO#[[O~P%ZO$r#RO!^!ma!o!ma!v!ma!y!ma#O!ma#R!ma#[!ma$j!ma$y!ma$t!ma~Of!mOk#XOo#UOr#VOt#XOu#XOv#XOw#XOx#XOy#XO{#WO}qO!P#ZO!Q#ZO!S#[O!T#[O!U#[O!X#]O#a#_O~OT!nO!^!rX!o!rX!v!rX!y!rX#O!rX#R!rX#[!rX$j!rX$r!rX$y!rX$t!rX~P/bO#k#iO~P%ZO$n#mO~O$n#nO~O$n#pO~OT#rO#T#rO~O#^#tO!^#Ya!o#Ya!v#Ya!y#Ya#O#Ya#R#Ya#[#Ya$j#Ya$y#Ya$t#Ya~Of!mO$n#vO~O$n#xO~O!^!ta!o!ta!v!ta!y!ta#O!ta#R!ta#[!ta$j!ta$y!ta$t!ta~P/eO!^!|a!o!|a!v!|a!y!|a#O!|a#R!|a#[!|a$j!|a$y!|a$t!|a~P/eO$m!jOTVa`VafVa!^Va!dVa!fVa!hVa!jVa!lVa!oVa!vVa!yVa#OVa#RVa#[Va$jVa$yVakVaoVarVatVauVavVawVaxVayVa{Va}Va!PVa!QVa!SVa!TVa!UVa!XVa#aVa$rVa$nVa$tVa#kVaiVa#mVa#rVa#pVa#TVa#cVa#hVa#uVa#vVa#yVa#{Va$QVa$TVa$VVa~OT!nO~O$t#{O~O`!tO~O!^![i!o![i!v![i!y![i#O![i#R![i#[![i$j![i$y![i$t![i~P+cO$t$RO~P%ZO$t$SO~P/eO!^!mi!o!mi!v!mi!y!mi#O!mi#R!mi#[!mi$j!mi$y!mi$t!mi~P!PO$r$UO!^!mi!o!mi!v!mi!y!mi#O!mi#R!mi#[!mi$j!mi$y!mi$t!mi~O{#WO!X#]O~O$n$ZO~O}qO#cyO~O#k#iO~P/eO#k#iO#p$fO#r$gO~O!S$oO!qsO$t$nO~P%ZOT$qO#v$qO~O$r$sO!^!wi!o!wi!v!wi!y!wi#O!wi#R!wi#[!wi$j!wi$y!wi$t!wi~O#V$uO#X$vO!^#SX!o#SX!v#SX!y#SX#O#SX#R#SX#[#SX$j#SX$r#SX$y#SX$t#SX~O$r$xO!^#Pi!o#Pi!v#Pi!y#Pi#O#Pi#R#Pi#[#Pi$j#Pi$y#Pi$t#Pi~O#T$zO~OT${O`!tO}qO!PzO!QzO#T!TO#cyO#h{O#u}O#v!TO#y!PO#{!QO$Q!UO$T!XO$V!YO~O$n%UO~OT%VO`!tO}qO!PzO!QzO#T!TO#cyO#h{O#u}O#v!TO#y!PO#{!QO$Q!UO$T!XO$V!YO~O$m!jO~Oi%ZO`!ba!^!ba!d!ba!f!ba!h!ba!j!ba!l!ba!o!ba!v!ba!y!ba#O!ba#R!ba#[!ba$j!ba$y!ba$t!ba~O$r%_O$t%`O~P/eO!^!mq!o!mq!v!mq!y!mq#O!mq#R!mq#[!mq$j!mq$y!mq$t!mq~P!PO$r%bO!^!mq!o!mq!v!mq!y!mq#O!mq#R!mq#[!mq$j!mq$y!mq$t!mq~O$n%cO~Ok#XOt#XOu#XOv#XOw#XOx#XOy#XO{#WO}qO!P#ZO!Q#ZO!S#[O!T#[O!U#[O!X#]O#a#_OTpifpiopi!^pi!opi!vpi!ypi#Opi#Rpi#[pi$jpi$rpi$ypi$tpi#kpi#mpi#rpi`pi!dpi!fpi!hpi!jpi!lpi#ppi#Tpi#cpi#hpi#upi#vpi#ypi#{pi$Qpi$Tpi$Vpi~Or#VO~PDYOrpi~PDYO!S#[O!T#[O!U#[OTpifpikpiopirpitpiupivpiwpixpiypi{pi}pi!Xpi!^pi!opi!vpi!ypi#Opi#Rpi#[pi#api$jpi$rpi$ypi$tpi#kpi#mpi#rpi`pi!dpi!fpi!hpi!jpi!lpi#ppi#Tpi#cpi#hpi#upi#vpi#ypi#{pi$Qpi$Tpi$Vpi~O!P#ZO!Q#ZO~PGvO!Ppi!Qpi~PGvO#m%jO~P/eO$t%lO~O$t%mO~P/eO$t%mO~O!^QO~O!^!wq!o!wq!v!wq!y!wq#O!wq#R!wq#[!wq$j!wq$y!wq$t!wq~P!PO$r%pO!^!wq!o!wq!v!wq!y!wq#O!wq#R!wq#[!wq$j!wq$y!wq$t!wq~O!^#Pq!o#Pq!v#Pq!y#Pq#O#Pq#R#Pq#[#Pq$j#Pq$y#Pq$t#Pq~OT#rO#T#rO~PMmO$r%rO~PMmO$m!jO$n#OOfVXkVXoVXrVXtVXuVXvVXwVXxVXyVX{VX}VX!PVX!QVX!SVX!TVX!UVX!XVX#aVX$ZgX~OT%tO~PNpOb%vOd%wO~O$r&TOT$bX`$bX}$bX!P$bX!Q$bX#T$bX#c$bX#h$bX#u$bX#v$bX#y$bX#{$bX$Q$bX$T$bX$V$bX$t$bX~O$t&VO~P>}O$Z&WO~O$r&YOT$iX`$iX}$iX!P$iX!Q$iX#T$iX#c$iX#h$iX#u$iX#v$iX#y$iX#{$iX$Q$iX$T$iX$V$iX$t$iX~O$t&[O~P@TOi%ZO`!bi!^!bi!d!bi!f!bi!h!bi!j!bi!l!bi!o!bi!v!bi!y!bi#O!bi#R!bi#[!bi$j!bi$y!bi$t!bi~O$r&`O$t&aO~O$t&aO~P%ZO!^!my!o!my!v!my!y!my#O!my#R!my#[!my$j!my$y!my$t!my~P!PO$r&eO$t!YX~P/eO$t&fO~O#r#na~P/eO$t&iO~P/eO!^!wy!o!wy!v!wy!y!wy#O!wy#R!wy#[!wy$j!wy$y!wy$t!wy~P!POT#rO#T#rO!^#Py!o#Py!v#Py!y#Py#O#Py#R#Py#[#Py$j#Py$y#Py$t#Py~O[&lOTWa`Wa}Wa!PWa!QWa#TWa#cWa#hWa#uWa#vWa#yWa#{Wa$QWa$TWa$VWa$rWa$tWa~Of!mOi%ZO~O$n&rO~O$t&|O~O`!bq!^!bq!d!bq!f!bq!h!bq!j!bq!l!bq!o!bq!v!bq!y!bq#O!bq#R!bq#[!bq$j!bq$y!bq$t!bq~P/eO$t'PO~P%ZO$r$ca$t$ca~P/eO$t'QO~O$r'RO$t!Ya~O$t!Ya~P%ZO#k#iq#p#iq#r#iq~P/eO$t'SO~P/eO$n'WO~Ok#XOt#XOu#XOv#XOw#XOx#XOy#XO{#WO}qO!P#ZO!Q#ZO!S#[O!T#[O!U#[O!X#]O#a#_Ofmiomi~Or#VO~P!-qOrmi~P!-qO!S#[O!T#[O!U#[Ofmikmiomirmitmiumivmiwmixmiymi{mi}mi!Xmi#ami~O!P#ZO!Q#ZO~P!/ZO!Pmi!Qmi~P!/ZOTli`li#Tli#cli#hli#uli#vli#yli#{li$Qli$Tli$Vli$rli$tli~P/eO`!by!^!by!d!by!f!by!h!by!j!by!l!by!o!by!v!by!y!by#O!by#R!by#[!by$j!by$y!by$t!by~P/eO$t!Yi~P%ZOk'ZO~O$t'^O~O$t'aO~OP!T!S!Q~",
+      goto: "H}${PPP$|%QPP%U&n&r&u&xP&{'T'ZP'hP'hP'kP'}(mP(yP&{)P)VP)m*lP+UPPPPPP+pP,^P.RPP.oPPP)m/_P0P0]0w1UP1f1f1k2o2sP2sP2sP2sP2sP0w2wP3UP3[3m0w3xP0w4VP4dP0w4jP0w4wP5UP5^P5^P0w5aP5nP)m5qP6]P7l8o7l9rP:u:{P;RP;U;[P;`P7l;jPP<m=pP=pP<m>s>s?vP7l@yPA|P1p)P)PP$|$|BPPBTBZCmCsC}D^DdDrDxESPPPPPEYE^EdPGkPGt7l>s)mPHyTcOdT`OdUjR!z$O#Q!WTfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'WQ!d`Q!ebQ%y$}S'T&o'[R'_'ZT%Q#v%SR%u${R&n%uR&m%uS%Q#v%ST%W#x%YX$}#v#x%S%YS!zn!}Q$O!{X$|#v#x%S%YR%x$|Q!pjQ!slQ#gxQ#w!dQ&S%OR&p%yQ!ojQ!rlQ#fxQ#z!pQ#|!sQ$c#gW%T#v#x%S%YQ&z&SR'V&pQ%[#}Q&^%]Q&o%yR'['VQ'U&oR'`'[X%P#v#x%S%Yr#ax!h!i#Q#h$Q$k$m%d%i%n&]&b&h&j&{&}R%}%O!y![Tfgrw|!]!`#O#R#a#b#c#d#e#l#n$U$Z$j$p$s%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'Wv#bx!h!i#Q#h$Q$^$k$m%d%i%n&]&b&h&j&u&{&}R&O%Oz#cx!h!i#Q#h$Q$^$_$k$m%d%i%n&]&b&h&j&u&v&{&}R&P%O|#Xx!h!i#Q#h$Q$^$_$k$m%O%d%i%n&]&b&h&j&u&v&{&}T$X#Y%z#QzTfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'Wz#Yx!h!i#Q#h$Q$^$_$k$m%d%i%n&]&b&h&j&u&v&{&}Q$]#`Q%z%OR&t%|!O#dx!h!i#Q#h$Q$^$_$`$k$m%d%i%n&]&b&h&j&u&v&w&{&}R&Q%O!S#ex!h!i#Q#h$Q$^$_$`$a$k$m%d%i%n&]&b&h&j&u&v&w&x&{&}R&R%Oz#^x!h!i#Q#h$Q$^$_$k$m%d%i%n&]&b&h&j&u&v&{&}Q$Y#YQ%{%OR&q%zQ%e$ZQ&c%cQ'X&rR']'WSeOdS!qkrQ$l#mQ%e$ZQ&X%UQ&c%cQ'X&rR']'Wg^O_dkr#m$Z%U%c&r'WfRO_dkr#m$Z%U%c&r'WR%o$rVmR!z$OUlR!z$O!y!ZTfgrw|!]!`#O#R#a#b#c#d#e#l#n$U$Z$j$p$s%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'WT!|n!}T!{n!}gTO_dkr#m$Z%U%c&r'WQwTR$p#nQvTQ#TwQ#q!`]$T#R$U$s%a%b%pcuTw!`#R$U$s%a%b%pgfO_dkr#m$Z%U%c&r'WgWO_dkr#m$Z%U%c&r'WQ!`WR!aZggO_dkr#m$Z%U%c&r'WgZO_dkr#m$Z%U%c&r'WQ#s!aV%q$x%r&kR$w#rg]O_dkr#m$Z%U%c&r'WR#u!bz#`x!h!i#Q#h$Q$^$_$k$m%d%i%n&]&b&h&j&u&v&{&}R%|%O#Q!STfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'WQ$[#`Q%f$]Q&s%|R'Y&t#R!YTfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'W#R!]Tfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'W#R|Tfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'WX#j|#h#k$dX#l|#h#k$dR%k$kQ$i#kR%h$dT$j#k$dQ$h#kS%g$d$iR&g%h#R!OTfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'W#R!TTfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'W#R!RTfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'W#R!WTfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'W#R!VTfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'W#R!^Tfgrw|!]!`#O#R#a#b#c#d#e#l#n#v#x$U$Z$j$p$s%S%Y%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'WR$r#pTbOdQdOR!gd#QiR`bfgr|!]!z#O#a#b#c#d#e#l#n#v#x$O$Z$j$p$}%S%Y%[%_%c%k%o%}&O&P&Q&R&W&^&`&e&o&r'O'R'W'Z'[bpTw!`#R$U$s%a%b%pT!lipQ%S#vR&U%SQ%^$QS&_%^&dR&d%dd_Odkr#m$Z%U%c&r'WR!c_Q!}nR$P!}Q#SvU$V#S$W$tQ$W#TR$t#qQ$y#sR%s$yQ#k|Q$d#hT$e#k$dQ%Y#xR&Z%YT%R#v%SX%O#v#x%S%YbxTw!`#R$U$s%a%b%pQ!hfQ!igQ#QrQ#h|Q#o!]Q$Q#OQ$^#aQ$_#bQ$`#cQ$a#dQ$b#eQ$k#lQ$m#nW%d$Z%c&r'WQ%i$jQ%n$pQ&]%[Y&b%_&`&e'O'RQ&h%kQ&j%oQ&u%}Q&v&OQ&w&PQ&x&QQ&y&RQ&{&WR&}&^QnRQ#}!zR%]$O!x![Tfgrw|!]!`#O#R#a#b#c#d#e#l#n$U$Z$j$p$s%[%_%a%b%c%k%o%p%}&O&P&Q&R&W&^&`&e&r'O'R'WX%P#v#x%S%YT%X#x%Y",
+      nodeNames: "\u26A0 Comment Program TableStatement Kw Identifier table Ref ColumnDef DataType PrimaryKey Kw primary_key JoinDef JoinType Kw join Kw one Kw many Kw as Alias Kw on BinaryExpression = ComputedDef BinaryExpression Kw or BinaryExpression Kw and ComparisonOp != <> < > <= >= Kw like Kw not AddOp + - MulOp * / % InExpression Kw in InValueList QueryStatement FromClause Kw from TableName Subquery SubqueryExpression JoinClause Kw inner Kw left Kw right Kw full Kw cross SelectClause Kw select Kw distinct SelectItem Wildcard WhereClause Kw where GroupByClause Kw group Kw by HavingClause Kw having OrderByClause Kw order OrderItem Number Kw asc Kw desc LimitClause Kw limit Kw offset NullTestExpression Kw is Kw null UnaryExpression UnaryOperator CaseExpression Kw case WhenClause Kw when Kw then ElseClause Kw else Kw end ExistsExpression Kw exists String Boolean Kw true Kw false Null FunctionCall Count Kw count ExtractExpression Kw extract ExtractUnit Param Parenthetical InExpression NullTestExpression : ViewStatement ExtendStatement Kw extend",
+      maxTerm: 180,
       nodeProps: [
-        ["group", -6, 23, 56, 107, 119, 123, 128, "Expression", -12, 24, 27, 28, 34, 47, 93, 103, 112, 113, 118, 120, 127, "Expression Expression", -2, 54, 55, "TablePrimary"]
+        ["group", -12, 7, 97, 112, 114, 127, 130, 131, 136, 137, 138, 141, 145, "Expression Expression", -9, 26, 29, 32, 53, 63, 107, 146, 147, 148, "Expression", -2, 61, 62, "TablePrimary"]
       ],
       skippedNodes: [0, 1],
-      repeatNodeCount: 9,
-      tokenData: "*g~RnX^#Ppq#Pqr#trs$Ptu$nuv%`wx%exy%}yz&Sz{&X{|&^|}&c}!O&h!O!P'X!P!Q'^!Q![(m!]!^)W!^!_)]!_!`)r!`!a)w!c!}*U#T#o*U#y#z#P$f$g#P#BY#BZ#P$IS$I_#P$I|$JO#P$JT$JU#P$KV$KW#P&FU&FV#P~#UY$d~X^#Ppq#P#y#z#P$f$g#P#BY#BZ#P$IS$I_#P$I|$JO#P$JT$JU#P$KV$KW#P&FU&FV#P~#wP!_!`#z~$PO#z~~$STOr$Prs$cs;'S$P;'S;=`$h<%lO$P~$hO#d~~$kP;=`<%l$P~$qS!Q![$}!c!}$}#R#S$}#T#o$}~%SS#k~!Q![$}!c!}$}#R#S$}#T#o$}~%eO$V~~%hTOw%ewx$cx;'S%e;'S;=`%w<%lO%e~%zP;=`<%l%e~&SO$e~~&XO$k~~&^O!o~~&cOq~~&hO$l~~&mPp~}!O&p~&uSP~OY&pZ;'S&p;'S;=`'R<%lO&p~'UP;=`<%l&p~'^O$g~~'cP$U~z{'f~'iTOz'fz{'x{;'S'f;'S;=`(g<%lO'f~'{VOz'fz{'x{!P'f!P!Q(b!Q;'S'f;'S;=`(g<%lO'f~(gOP~~(jP;=`<%l'f~(rQ#P~!O!P(x!Q![(m~({P!Q![)O~)TP#P~!Q![)O~)]O$o~~)bQ#|~!_!`)h!`!a)m~)mO$O~~)rO#{~~)wOi~~)|P#}~!_!`*P~*UO$P~~*ZST~!Q![*U!c!}*U#R#S*U#T#o*U",
+      repeatNodeCount: 10,
+      tokenData: "*o~RoX^#Spq#Sqr#wrs$Stu$quv%cwx%hxy&Qyz&Vz{&[{|&a|}&f}!O&k!O!P'[!P!Q'a!Q![(p![!])Z!]!^)`!^!_)e!_!`)z!`!a*P!c!}*^#T#o*^#y#z#S$f$g#S#BY#BZ#S$IS$I_#S$I|$JO#S$JT$JU#S$KV$KW#S&FU&FV#S~#XY$l~X^#Spq#S#y#z#S$f$g#S#BY#BZ#S$IS$I_#S$I|$JO#S$JT$JU#S$KV$KW#S&FU&FV#S~#zP!_!`#}~$SOt~~$VTOr$Srs$fs;'S$S;'S;=`$k<%lO$S~$kO#v~~$nP;=`<%l$S~$tS!Q![%Q!c!}%Q#R#S%Q#T#o%Q~%VS$V~!Q![%Q!c!}%Q#R#S%Q#T#o%Q~%hO!U~~%kTOw%hwx$fx;'S%h;'S;=`%z<%lO%h~%}P;=`<%l%h~&VO$n~~&[O$t~~&aO!S~~&fO!P~~&kO$r~~&pP!Q~}!O&s~&xSP~OY&sZ;'S&s;'S;=`'U<%lO&s~'XP;=`<%l&s~'aO$m~~'fP!T~z{'i~'lTOz'iz{'{{;'S'i;'S;=`(j<%lO'i~(OVOz'iz{'{{!P'i!P!Q(e!Q;'S'i;'S;=`(j<%lO'i~(jOP~~(mP;=`<%l'i~(uQ#T~!O!P({!Q![(p~)OP!Q![)R~)WP#T~!Q![)R~)`O$Z~~)eO$y~~)jQv~!_!`)p!`!a)u~)uOx~~)zOu~~*POk~~*UPw~!_!`*X~*^Oy~~*cST~!Q![*^!c!}*^#R#S*^#T#o*^",
       tokenizers: [0],
       topRules: { "Program": [0, 2] },
       specialized: [{ term: 5, get: (value, stack) => specializeIdentifier(value, stack) << 1, external: specializeIdentifier }, { term: 5, get: (value) => spec_Identifier[value] || -1 }],
-      tokenPrec: 2599
+      tokenPrec: 2964
     });
   }
 });
@@ -1203,6 +1494,7 @@ function isFence(event) {
 var COMPONENT_ATTRIBUTE_KEYS, GSQL_FENCE, COMPONENT_TAG, ATTRIBUTE;
 var init_markdown = __esm({
   "../lang/markdown.ts"() {
+    "use strict";
     init_parser();
     COMPONENT_ATTRIBUTE_KEYS = ["x", "y", "y2", "series", "value", "category"];
     GSQL_FENCE = /^([ \t]*)(`{3,})g?sql[^\n]*\n([\s\S]*?)^\1\2[ \t]*$/gim;
@@ -1211,6 +1503,74 @@ var init_markdown = __esm({
   }
 });
 
+// ../lang/snowflake.ts
+function uppercaseMalloyQuery(query) {
+  query.baseTableName = uppercaseIdentifier(query.baseTableName);
+  for (let stage of query.pipeline || []) {
+    let fields = stage.queryFields || [];
+    fields.forEach((field) => uppercaseColumnField(field));
+    let filters = stage.filterList || [];
+    filters.forEach((filter) => uppercaseExpression(filter?.e));
+  }
+}
+function uppercaseTable(table2) {
+  if (table2.upperCased) return;
+  table2.upperCased = true;
+  table2.name = uppercaseIdentifier(table2.name);
+  if (table2.primaryKey) table2.primaryKey = uppercaseIdentifier(table2.primaryKey);
+  if (table2.tableName) table2.tableName = uppercaseQualified(table2.tableName);
+  if (table2.tablePath) table2.tablePath = uppercaseQualified(table2.tablePath);
+  table2.fields?.forEach((field) => uppercaseField(field));
+  if (table2.query) uppercaseMalloyQuery(table2.query);
+}
+function uppercaseField(field) {
+  if (!field) return;
+  if (isJoinField(field)) {
+    field.name = uppercaseIdentifier(field.name);
+    if (field.tableName) field.tableName = uppercaseQualified(field.tableName);
+    if (field.tablePath) field.tablePath = uppercaseQualified(field.tablePath);
+    if (field.structPath) field.structPath = field.structPath.map(uppercaseIdentifier);
+    if (field.path) field.path = field.path.map(uppercaseIdentifier);
+    if (field.onExpression) uppercaseExpression(field.onExpression);
+    uppercaseTable(field);
+  } else {
+    uppercaseColumnField(field);
+  }
+}
+function uppercaseColumnField(field) {
+  if (!field) return;
+  field.name = uppercaseIdentifier(field.name);
+  if (field.path) field.path = field.path.map(uppercaseIdentifier);
+  if (field.structPath) field.structPath = field.structPath.map(uppercaseIdentifier);
+  if (field.tableName) field.tableName = uppercaseQualified(field.tableName);
+  if (field.tablePath) field.tablePath = uppercaseQualified(field.tablePath);
+  if (field.e) uppercaseExpression(field.e);
+}
+function uppercaseExpression(expr) {
+  if (!expr) return;
+  walkExpression(expr, (node) => {
+    if (Array.isArray(node.path)) node.path = node.path.map(uppercaseIdentifier);
+    if (Array.isArray(node.structPath)) node.structPath = node.structPath.map(uppercaseIdentifier);
+  });
+}
+function uppercaseIdentifier(value) {
+  if (!value) return value || "";
+  return value.toString().toUpperCase();
+}
+function uppercaseQualified(value) {
+  if (!value) return value;
+  return value.split(".").map((part) => part.startsWith('"') && part.endsWith('"') ? part : uppercaseIdentifier(part)).join(".");
+}
+function isJoinField(field) {
+  return !!field?.join;
+}
+var init_snowflake = __esm({
+  "../lang/snowflake.ts"() {
+    "use strict";
+    init_util();
+  }
+});
+
 // ../lang/core.ts
 import { registerDialect, StandardSQLDialect, QueryModel, expandBlueprintMap } from "@graphenedata/malloy";
 import { readFile } from "node:fs/promises";
@@ -1225,15 +1585,19 @@ function getDiagnostics() {
 async function loadWorkspace(dir, includeMd) {
   let files = await glob(includeMd ? "**/*.{gsql,md}" : "**/*.gsql", { cwd: dir, ignore: ["node_modules/**"] });
   for await (let file of files) {
-    let contents = await readFile(path2.join(dir, file), "utf-8");
-    updateFile(contents, file);
+    try {
+      let contents = await readFile(path2.join(dir, file), "utf-8");
+      updateFile(contents, file);
+    } catch (e) {
+      console.error("Failed to read file", file, e.message);
+    }
   }
 }
-function updateFile(contents, path9) {
-  FILE_MAP[path9] ||= { path: path9, contents, tree: null, tables: [], queries: [] };
-  FILE_MAP[path9].contents = contents;
-  FILE_MAP[path9].tree = null;
-  return FILE_MAP[path9];
+function updateFile(contents, path10) {
+  FILE_MAP[path10] ||= { path: path10, contents, tree: null, tables: [], queries: [] };
+  FILE_MAP[path10].contents = contents;
+  FILE_MAP[path10].tree = null;
+  return FILE_MAP[path10];
 }
 function analyze(contents, type) {
   clearDiagnostics();
@@ -1246,6 +1610,7 @@ function analyze(contents, type) {
     recordSyntaxErrors(fi);
     findTables(fi);
   });
+  Object.values(FILE_MAP).forEach(applyExtends);
   Object.values(FILE_MAP).flatMap((f) => f.tables).forEach(analyzeTable);
   if (contents) {
     let fi = FILE_MAP["input"];
@@ -1258,13 +1623,21 @@ function analyze(contents, type) {
 }
 function toSql(query, params = {}) {
   if (query.rawSql) return query.rawSql;
-  let contents = {};
-  let gsqlTables = Object.values(FILE_MAP).filter((f) => f.path !== "input").flatMap((f) => f.tables);
-  gsqlTables.forEach((t) => contents[t.name] = t);
-  let inputTables = [...FILE_MAP["input"]?.tables || [], ...query.subQuerySources];
-  inputTables.forEach((t) => contents[t.name] = { ...t, query: t.query && fillInParams(t.query, params) });
-  if (!query.malloyQuery) throw new Error("Cannot compile query without Malloy query");
-  let malloyQuery = fillInParams(query.malloyQuery, params);
+  let contents = Object.fromEntries(Object.values(FILE_MAP).flatMap((fi) => {
+    return fi.tables.map((t) => {
+      t = structuredClone(t);
+      if (fi.path == "input" && t.query) fillInParams(t.query, params);
+      if (config.dialect == "snowflake") uppercaseTable(t);
+      return [t.name, t];
+    });
+  }));
+  query = structuredClone(query);
+  fillInParams(query, params);
+  if (config.dialect == "snowflake") uppercaseMalloyQuery(query);
+  let tableQueries = Object.values(contents).map((t) => t.query);
+  let joinQueries = Object.values(contents).flatMap((t) => t.fields.map((f) => f.query));
+  let allQueries = [...tableQueries, ...joinQueries, query].filter((q) => !!q);
+  allQueries.forEach((q) => q.structRef = contents[q.baseTableName]);
   let qm = new QueryModel({
     name: "generated_model",
     contents,
@@ -1272,18 +1645,20 @@ function toSql(query, params = {}) {
     dependencies: {},
     exports: []
   });
-  return qm.compileQuery(malloyQuery).sql;
+  return qm.compileQuery(query).sql;
 }
 var BigQueryDialect;
 var init_core = __esm({
   "../lang/core.ts"() {
+    "use strict";
     init_analyze();
     init_params();
     init_util();
     init_config();
-    init_functions();
+    init_functionDefs();
     init_parser();
     init_markdown();
+    init_snowflake();
     BigQueryDialect = class extends StandardSQLDialect {
       constructor() {
         super();
@@ -1349,6 +1724,7 @@ function printTable(rows) {
 var styleText;
 var init_printer = __esm({
   "printer.ts"() {
+    "use strict";
     init_core();
     styleText = (style, text) => {
       try {
@@ -1361,21 +1737,20 @@ var init_printer = __esm({
 });
 
 // background.ts
-import { spawn } from "child_process";
+import { spawn, exec } from "child_process";
+import { promisify } from "util";
 import { fileURLToPath } from "url";
 import fs2 from "fs-extra";
 import path3 from "path";
 async function runServeInBackground() {
-  let root = process.cwd();
-  let grapheneCache = getGrapheneCache(root);
+  let grapheneCache = getGrapheneCache(config.root);
   let logFile = path3.join(grapheneCache, "serve.log");
   await fs2.ensureDir(grapheneCache);
-  await stopGrapheneIfRunning(root);
   let log = fs2.openSync(logFile, "w");
   let entryPoint = process.argv[1] || fileURLToPath(import.meta.url);
-  let childArgs = [...process.execArgv, entryPoint, "serve", "--fg", ...process.argv.slice(3)];
+  let childArgs = [...process.execArgv, entryPoint, "serve"];
   let child = spawn(process.execPath, childArgs, {
-    cwd: root,
+    cwd: config.root,
     detached: true,
     env: { ...process.env },
     stdio: ["ignore", log, log]
@@ -1394,7 +1769,6 @@ async function runServeInBackground() {
       }
     });
     child.once("exit", () => {
-      process.stdout.write(fs2.readFileSync(logFile));
       reject(new Error("Exited before server started"));
     });
     child.once("error", (e) => reject(e));
@@ -1403,15 +1777,9 @@ async function runServeInBackground() {
 function getGrapheneCache(root) {
   return path3.join(root, "node_modules", ".graphene");
 }
-function getPidFilePath(root) {
-  return path3.join(getGrapheneCache(root), process.env.NODE_ENV == "test" ? "test.pid" : "serve.pid");
-}
-function targetPids(pid) {
-  if (process.platform === "win32") return [pid];
-  return [pid, -pid];
-}
 function sendSignal(pid, signal) {
-  for (let target of targetPids(pid)) {
+  let pids = process.platform === "win32" ? [pid] : [pid, -pid];
+  for (let target of pids) {
     try {
       process.kill(target, signal);
     } catch (err) {
@@ -1422,244 +1790,83 @@ function sendSignal(pid, signal) {
   }
   return true;
 }
-async function stopGrapheneIfRunning(root) {
-  if (!await isServerRunning()) return;
-  let pidFile = getPidFilePath(root);
-  let pid = await readPid(pidFile);
+async function stopGrapheneIfRunning() {
+  let port = Number(process.env.GRAPHENE_PORT) || 4e3;
+  let pid = await getPidOnPort(port);
   if (!pid) return;
   console.log(`Stopping server (${pid})`);
   sendSignal(pid, "SIGTERM");
   let end = Date.now() + 5e3;
-  while (Date.now() < end && isServerRunning()) {
+  while (Date.now() < end) {
+    if (!await getPidOnPort(port)) break;
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
-  if (!isServerRunning()) return;
-  sendSignal(pid, "SIGKILL");
-  await fs2.remove(pidFile);
-}
-async function readPid(pidFile) {
-  if (!await fs2.pathExists(pidFile)) return void 0;
-  let contents = (await fs2.readFile(pidFile, "utf8")).trim();
-  if (!contents) return void 0;
-  let pid = Number.parseInt(contents, 10);
-  if (Number.isNaN(pid)) return void 0;
-  return pid;
-}
-async function isServerRunning() {
-  let pidFile = getPidFilePath(config.root);
-  let pid = await readPid(pidFile);
-  if (!pid) return false;
+  if (await getPidOnPort(port)) {
+    sendSignal(pid, "SIGKILL");
+  }
+  if (await getPidOnPort(port)) {
+    console.error("Failed to stop previous Graphene server");
+  }
+}
+async function isServerRunning(portOverride) {
+  let port = portOverride || Number(process.env.GRAPHENE_PORT) || 4e3;
+  return !!await getPidOnPort(port);
+}
+async function getPidOnPort(port) {
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    fs2.removeSync(pidFile);
-    return false;
+    if (process.platform === "win32") {
+      let { stdout } = await execAsync(`netstat -ano | findstr :${port}`);
+      let lines = stdout.trim().split("\n");
+      for (let line of lines) {
+        let parts = line.trim().split(/\s+/);
+        if (parts.length < 5) continue;
+        let localAddress = parts[1];
+        let pid = parseInt(parts[parts.length - 1], 10);
+        if (localAddress.endsWith(`:${port}`)) {
+          return pid;
+        }
+      }
+    } else {
+      return new Promise((resolve) => {
+        let child = spawn("lsof", ["-i", `:${port}`, "-t", "-sTCP:LISTEN"]);
+        let stdout = "";
+        child.stdout.on("data", (d) => stdout += d.toString());
+        child.on("close", (code) => {
+          if (code !== 0) return resolve(void 0);
+          let pid = parseInt(stdout.trim(), 10);
+          resolve(isNaN(pid) ? void 0 : pid);
+        });
+        child.on("error", () => resolve(void 0));
+      });
+    }
+  } catch (e) {
+    console.warn("Failed to check for server:", e.message);
+    return void 0;
   }
+  return void 0;
 }
+var execAsync;
 var init_background = __esm({
   "background.ts"() {
+    "use strict";
     init_config();
+    execAsync = promisify(exec);
   }
 });
 
-// connections/bigQuery.ts
-var bigQuery_exports = {};
-__export(bigQuery_exports, {
-  BigQueryConnection: () => BigQueryConnection
-});
-import { BigQuery, BigQueryDate, BigQueryTimestamp } from "@google-cloud/bigquery";
-var BigQueryConnection;
-var init_bigQuery = __esm({
-  "connections/bigQuery.ts"() {
-    init_config();
-    BigQueryConnection = class {
-      client;
-      constructor(options = {}) {
-        options.projectId ||= config.bigquery?.projectId;
-        if (process.env.GOOGLE_CREDENTIALS_CONTENT) {
-          let parsed = JSON.parse(process.env.GOOGLE_CREDENTIALS_CONTENT);
-          options.projectId = parsed.project_id;
-          options.credentials = parsed;
-        }
-        if (!options.projectId) throw new Error("projectId must be set in config or provided in service account credentials");
-        this.client = new BigQuery({ ...options, userAgent: "Graphene" });
-      }
-      async runQuery(sql) {
-        let [job] = await this.client.createQueryJob({ query: sql, useLegacySql: false });
-        let [rows] = await job.getQueryResults({ maxResults: 1e4 });
-        let metadata = job.metadata || (await job.getMetadata())[0];
-        let totalRows = Number(metadata?.statistics?.query?.totalRows ?? rows.length);
-        rows.forEach((r) => {
-          Object.entries(r).forEach(([k, v]) => {
-            if (v instanceof BigQueryTimestamp) r[k] = v.value;
-            if (v instanceof BigQueryDate) r[k] = v.value;
-          });
-        });
-        return { rows, totalRows };
-      }
-    };
+// mockFiles.ts
+var mockFileMap;
+var init_mockFiles = __esm({
+  "mockFiles.ts"() {
+    "use strict";
+    mockFileMap = {};
   }
 });
 
-// connections/duckdb.ts
-var duckdb_exports = {};
-__export(duckdb_exports, {
-  DuckDBConnection: () => DuckDBConnection
-});
-import { promises as fs3 } from "fs";
+// check.ts
+import fs3 from "fs-extra";
+import os from "os";
 import path4 from "path";
-import { DuckDBTimestampValue, DuckDBInstance, DuckDBDateValue } from "@duckdb/node-api";
-var DuckDBConnection;
-var init_duckdb = __esm({
-  "connections/duckdb.ts"() {
-    init_config();
-    DuckDBConnection = class {
-      options;
-      ready;
-      connection = null;
-      constructor(options) {
-        this.options = options || {};
-        this.ready = this.initialize();
-      }
-      async initialize() {
-        let dbPath = this.options.path;
-        if (!dbPath) {
-          let files = await fs3.readdir(config.root);
-          dbPath = files.find((f) => f.endsWith(".duckdb"));
-          if (!dbPath) throw new Error("No .duckdb file found in current directory");
-          dbPath = path4.resolve(config.root, dbPath);
-        }
-        let db = await DuckDBInstance.create(":memory:");
-        this.connection = await db.connect();
-        let escapedPath = dbPath.replace(/'/g, "''");
-        await this.connection.run(`attach '${escapedPath}' as graphene_cli (READ_ONLY);`);
-        await this.connection.run("use graphene_cli;");
-      }
-      async runQuery(sql) {
-        await this.ready;
-        let reader = await this.connection.runAndReadAll(sql);
-        let rows = reader.getRowObjects().map((record) => {
-          let out = {};
-          for (let [k, v] of Object.entries(record)) {
-            if (typeof v === "bigint") out[k] = Number(v);
-            else if (v === null) out[k] = null;
-            else if (v instanceof DuckDBTimestampValue) out[k] = new Date(Number(v.micros / 1000n)).toUTCString();
-            else if (v instanceof DuckDBDateValue) out[k] = v.toString();
-            else if (typeof v === "object") throw new Error(`Unsupported datatype ${v.constructor?.name}`);
-            else out[k] = v;
-          }
-          return out;
-        });
-        return { rows };
-      }
-    };
-  }
-});
-
-// connections/snowflake.ts
-var snowflake_exports = {};
-__export(snowflake_exports, {
-  SnowflakeConnection: () => SnowflakeConnection
-});
-import { createPrivateKey } from "node:crypto";
-import snowflake from "snowflake-sdk";
-var SnowflakeConnection;
-var init_snowflake = __esm({
-  "connections/snowflake.ts"() {
-    init_config();
-    SnowflakeConnection = class {
-      ready;
-      connection;
-      constructor(opts) {
-        this.ready = this.initialize(opts || {});
-      }
-      async initialize(opts) {
-        let privateKeyPath = process.env.SNOWFLAKE_PRI_KEY_PATH || config.snowflake?.privateKeyPath;
-        let privateKeyPass = process.env.SNOWFLAKE_PRI_PASSPHRASE;
-        let authOptions = {};
-        if (privateKeyPath) {
-          authOptions = { privateKeyPath, privateKeyPass };
-        } else if (opts.privateKey) {
-          let privateKey = createPrivateKey({ key: opts.privateKey, format: "pem", passphrase: privateKeyPass });
-          authOptions = { privateKey: privateKey.export({ format: "pem", type: "pkcs8" }) };
-        }
-        snowflake.configure({ logLevel: process.env.SNOWFLAKE_LOG_LEVEL || "WARN", logFilePath: "/dev/null" });
-        this.connection = snowflake.createConnection({
-          ...opts,
-          ...config.snowflake || {},
-          ...authOptions,
-          authenticator: "SNOWFLAKE_JWT",
-          application: "Graphene"
-        });
-        await new Promise((resolve, reject) => {
-          this.connection.connect((err, conn) => err ? reject(err) : resolve(conn));
-        });
-      }
-      async runQuery(sql) {
-        await this.ready;
-        return await new Promise((resolve, reject) => {
-          let rows = [];
-          this.connection.execute({
-            sqlText: sql,
-            streamResult: true,
-            complete: (error, statement) => {
-              if (error) {
-                reject(new Error(`Snowflake query failed: ${error.message || error}`));
-                return;
-              }
-              let stream = statement.streamRows();
-              stream.on("error", (err) => reject(err));
-              stream.on("readable", function(row) {
-                while ((row = this.read()) !== null) {
-                  rows.push(row);
-                }
-              });
-              stream.on("end", () => {
-                let totalRows = Number(statement.getNumRows());
-                resolve({ rows, totalRows });
-              });
-            }
-          });
-        });
-      }
-    };
-  }
-});
-
-// connections/index.ts
-async function getConnection() {
-  if (config.dialect === "bigquery") {
-    let mod = await Promise.resolve().then(() => (init_bigQuery(), bigQuery_exports));
-    return new mod.BigQueryConnection();
-  } else if (config.dialect === "duckdb") {
-    let mod = await Promise.resolve().then(() => (init_duckdb(), duckdb_exports));
-    return new mod.DuckDBConnection({});
-  } else if (config.dialect === "snowflake") {
-    let mod = await Promise.resolve().then(() => (init_snowflake(), snowflake_exports));
-    return new mod.SnowflakeConnection({});
-  } else {
-    throw new Error(`Unsupported dialect: ${config.dialect}`);
-  }
-}
-var init_connections = __esm({
-  "connections/index.ts"() {
-    init_config();
-  }
-});
-
-// mockFiles.ts
-var mockFileMap;
-var init_mockFiles = __esm({
-  "mockFiles.ts"() {
-    mockFileMap = {};
-  }
-});
-
-// check.ts
-import fs4 from "fs-extra";
-import os from "os";
-import path5 from "path";
 import { spawn as spawn2 } from "child_process";
 import { WebSocketServer } from "ws";
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -1676,7 +1883,7 @@ async function check(options) {
     if (process.env.NODE_ENV == "test" && mockFileMap[mdFile]) {
       updateFile(mockFileMap[mdFile], mdFile);
     } else {
-      let content = readFileSync2(path5.resolve(config.root, mdFile), "utf-8");
+      let content = readFileSync2(path4.resolve(config.root, mdFile), "utf-8");
       updateFile(content, mdFile);
     }
   }
@@ -1731,12 +1938,12 @@ async function check(options) {
   }
   if (resp?.screenshot) {
     let filename = `graphene-screenshot-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.png`;
-    let screenshotPath = path5.join(os.tmpdir(), filename);
+    let screenshotPath = path4.join(os.tmpdir(), filename);
     let base64Data = resp.screenshot.replace(/^data:image\/png;base64,/, "");
-    await fs4.writeFile(screenshotPath, base64Data, "base64");
+    await fs3.writeFile(screenshotPath, base64Data, "base64");
     log("Screenshot saved to", screenshotPath);
   }
-  return !!errors.length;
+  return errors.length == 0;
 }
 async function sendCheckRequest({ host, pageUrl, chart }) {
   let abort = new AbortController();
@@ -1770,11 +1977,11 @@ function normalizeMdFile(mdFile) {
     return clean;
   }
   let absolute = [
-    path5.resolve(process.cwd(), clean),
-    path5.resolve(config.root, clean)
-  ].find((p) => fs4.existsSync(p)) || null;
+    path4.resolve(process.cwd(), clean),
+    path4.resolve(config.root, clean)
+  ].find((p) => fs3.existsSync(p)) || null;
   if (!absolute) return null;
-  let relative = path5.relative(config.root, absolute);
+  let relative = path4.relative(config.root, absolute);
   return relative;
 }
 async function proxyCheckRequest(req, res) {
@@ -1833,6 +2040,7 @@ function checkVitePlugin() {
 var browserConnections, pendingRequests;
 var init_check = __esm({
   "check.ts"() {
+    "use strict";
     init_core();
     init_printer();
     init_mockFiles();
@@ -1843,9 +2051,482 @@ var init_check = __esm({
   }
 });
 
-// mdCompile.ts
-import fs5 from "fs";
+// auth.ts
+import fs4 from "node:fs/promises";
+import path5 from "path";
+import os2 from "os";
+import { spawn as spawn3 } from "child_process";
+import http from "http";
+async function readStore() {
+  try {
+    let txt2 = await fs4.readFile(credsPath, "utf8");
+    return JSON.parse(txt2) || {};
+  } catch {
+    return {};
+  }
+}
+async function readEntry() {
+  let store = await readStore();
+  return store[config.root];
+}
+async function updateEntry(cred) {
+  let store = await readStore();
+  cred.refresh_token ||= store[config.root]?.refresh_token;
+  cred.expires_at = Date.now() + cred.expires_in;
+  store[config.root] = cred;
+  await fs4.mkdir(path5.dirname(credsPath), { recursive: true, mode: 448 });
+  await fs4.writeFile(credsPath, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+  if (process.platform !== "win32") {
+    await fs4.chmod(credsPath, 384).catch(() => {
+    });
+  }
+}
+function openInBrowser(url) {
+  try {
+    let plat = process.platform;
+    let cmd = "xdg-open";
+    if (plat == "darwin") cmd = "open";
+    if (plat == "win32") cmd = "start";
+    let p = spawn3(cmd, [url], { stdio: "ignore", shell: plat === "win32" });
+    p.unref();
+  } catch {
+    console.log(`Open this URL to authenticate:
+${url}`);
+  }
+}
+function base64url(buf) {
+  let b64 = Buffer.from(buf).toString("base64");
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function randomBytes(len = 32) {
+  return crypto.getRandomValues(new Uint8Array(len));
+}
+async function startLoopback() {
+  let server = http.createServer();
+  await new Promise((r) => server.listen(0, "127.0.0.1", () => r()));
+  let addr = server.address();
+  if (!addr || typeof addr !== "object") throw new Error("Couldnt start oauth callback server");
+  let redirectBase = `http://localhost:${addr.port}`;
+  let waitForCode = new Promise((resolve) => {
+    server.on("request", (req, res) => {
+      let url = new URL(req.url || "/", redirectBase);
+      if (url.pathname !== "/callback") {
+        res.statusCode = 404;
+        res.end("Not Found");
+        return;
+      }
+      let code = url.searchParams.get("code") || "";
+      let state = url.searchParams.get("state") || "";
+      res.statusCode = 200;
+      res.setHeader("content-type", "text/html; charset=utf-8");
+      res.end("<html><body>Login complete. You may close this window.</body></html>");
+      resolve({ code, state });
+    });
+  });
+  return { url: redirectBase, waitForCode, close: () => server.close() };
+}
+async function loginPkce(opener) {
+  let verifier = base64url(randomBytes(48));
+  let data = new TextEncoder().encode(verifier);
+  let digest = await crypto.subtle.digest("SHA-256", data);
+  let code_challenge = base64url(digest);
+  let state = base64url(randomBytes(16));
+  let loop = await startLoopback();
+  let redirect_uri = `${loop.url}/callback`;
+  let authorizeUrl = new URL(`${config.host}/authenticate`);
+  authorizeUrl.search = new URLSearchParams({
+    redirect_uri,
+    code_challenge,
+    state,
+    client_id: AUTH_CLIENT_ID,
+    response_type: "code",
+    code_challenge_method: "S256",
+    scope: AUTH_SCOPES
+  }).toString();
+  if (opener) await opener(authorizeUrl.toString());
+  else openInBrowser(authorizeUrl.toString());
+  let result = await loop.waitForCode;
+  if (!result.code) throw new Error("No authorization code received");
+  if (result.state !== state) throw new Error("State mismatch");
+  let res = await fetch(`${config.host}/_api/oauth2/token`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code: result.code,
+      redirect_uri,
+      client_id: AUTH_CLIENT_ID,
+      code_verifier: verifier
+    })
+  });
+  if (!res.ok) throw new Error(`token exchange failed: ${res.status}`);
+  let tokenResp = await res.json();
+  await updateEntry(tokenResp);
+}
+async function refreshAccessToken() {
+  let refresh_token = (await readEntry())?.refresh_token;
+  let res = await fetch(new URL("/_api/oauth2/token", config.host).toString(), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ grant_type: "refresh_token", refresh_token, client_id: AUTH_CLIENT_ID })
+  });
+  if (!res.ok) throw new Error(`refresh failed: ${res.status}`);
+  let json = await res.json();
+  await updateEntry(json);
+}
+async function authenticatedFetch(pathOrUrl, init = {}) {
+  let entry = await readEntry();
+  if (!entry) throw new Error("Not logged in; run `graphene login`");
+  if (!entry.access_token || entry.expires_at < Date.now()) {
+    await refreshAccessToken();
+    entry = await readEntry();
+  }
+  let token = entry?.access_token;
+  if (!token) throw new Error("Failed to obtain access token");
+  let url = new URL(pathOrUrl, config.host);
+  let headers = new Headers(init.headers || {});
+  headers.set("authorization", `Bearer ${token}`);
+  let res = await fetch(url.toString(), { ...init, headers });
+  if (res.status === 401 || res.status === 403) {
+    await refreshAccessToken();
+    token = (await readEntry())?.access_token;
+    if (token) {
+      headers.set("cookie", `access_token=${token}`);
+      res = await fetch(url.toString(), { ...init, headers });
+    }
+  }
+  return res;
+}
+var AUTH_CLIENT_ID, AUTH_SCOPES, cfgDir, credsPath;
+var init_auth = __esm({
+  "auth.ts"() {
+    "use strict";
+    init_config();
+    AUTH_CLIENT_ID = "connected-app-test-4685a2a0-1cb9-4a81-a6bf-01a3efe7b981";
+    AUTH_SCOPES = "offline_access";
+    cfgDir = process.env.XDG_CONFIG_HOME || path5.join(os2.homedir(), ".config");
+    credsPath = path5.join(cfgDir, "graphene", "credentials.json");
+  }
+});
+
+// connections/bigQuery.ts
+var bigQuery_exports = {};
+__export(bigQuery_exports, {
+  BigQueryConnection: () => BigQueryConnection
+});
+import { BigQuery, BigQueryDate, BigQueryTimestamp } from "@google-cloud/bigquery";
+import { readFileSync as readFileSync3 } from "fs";
+function sqlStringLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+var BigQueryConnection;
+var init_bigQuery = __esm({
+  "connections/bigQuery.ts"() {
+    "use strict";
+    init_config();
+    BigQueryConnection = class {
+      client;
+      projectId;
+      defaultNamespace;
+      constructor(options = {}) {
+        options.projectId ||= config.bigquery?.projectId;
+        if (process.env.GOOGLE_CREDENTIALS_CONTENT) {
+          let parsed = JSON.parse(process.env.GOOGLE_CREDENTIALS_CONTENT);
+          options.projectId = parsed.project_id;
+          options.credentials = parsed;
+        }
+        if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+          let tmp = JSON.parse(readFileSync3(process.env.GOOGLE_APPLICATION_CREDENTIALS, { encoding: "utf-8" }));
+          options.projectId = tmp.project_id;
+        }
+        if (!options.projectId) throw new Error("projectId must be set in config or provided in service account credentials");
+        this.projectId = options.projectId;
+        this.client = new BigQuery({ ...options, userAgent: "Graphene" });
+        this.defaultNamespace = config.namespace;
+      }
+      async runQuery(sql) {
+        let [job] = await this.client.createQueryJob({ query: sql, useLegacySql: false });
+        let [rows] = await job.getQueryResults({ maxResults: 1e4 });
+        let metadata = job.metadata || (await job.getMetadata())[0];
+        let totalRows = Number(metadata?.statistics?.query?.totalRows ?? rows.length);
+        rows.forEach((r) => {
+          Object.entries(r).forEach(([k, v]) => {
+            if (v instanceof BigQueryTimestamp) r[k] = v.value;
+            if (v instanceof BigQueryDate) r[k] = v.value;
+          });
+        });
+        return { rows, totalRows };
+      }
+      async listDatasets() {
+        let [datasets] = await this.client.getDatasets();
+        return datasets.map((d) => d.id || d.metadata.datasetReference?.datasetId);
+      }
+      async listTables(dataset) {
+        if (!dataset) throw new Error("BigQuery requires a dataset");
+        let res = await this.runQuery(`select table_schema as table_schema, table_name as table_name
+      from \`${dataset}.INFORMATION_SCHEMA.TABLES\`
+      where table_type in ('BASE TABLE', 'VIEW') order by table_name`);
+        return res.rows.map((r) => `${r["table_schema"]}.${r["table_name"]}`);
+      }
+      async describeTable(target) {
+        let parts = target.split(".");
+        let table2 = parts.pop() || "";
+        let dataset = parts.join(".");
+        let sql = `
+      select column_name as column_name, data_type as data_type, ordinal_position as ordinal_position
+      from \`${dataset}.INFORMATION_SCHEMA.COLUMNS\`
+      where lower(table_name) = lower(${sqlStringLiteral(table2)})
+      order by ordinal_position
+    `.trim();
+        let res = await this.runQuery(sql);
+        return res.rows.map((row) => {
+          return { name: String(row["column_name"]), dataType: String(row["data_type"]) };
+        });
+      }
+    };
+  }
+});
+
+// connections/duckdb.ts
+var duckdb_exports = {};
+__export(duckdb_exports, {
+  DuckDBConnection: () => DuckDBConnection
+});
+import { promises as fs5 } from "fs";
 import path6 from "path";
+import { DuckDBTimestampValue, DuckDBInstance, DuckDBDateValue } from "@duckdb/node-api";
+function sqlStringLiteral2(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+var DuckDBConnection;
+var init_duckdb = __esm({
+  "connections/duckdb.ts"() {
+    "use strict";
+    init_config();
+    DuckDBConnection = class {
+      options;
+      ready;
+      connection = null;
+      constructor(options) {
+        this.options = options || {};
+        this.ready = this.initialize();
+      }
+      async initialize() {
+        let dbPath = this.options.path;
+        if (!dbPath) {
+          let files = await fs5.readdir(config.root);
+          dbPath = files.find((f) => f.endsWith(".duckdb"));
+          if (!dbPath) throw new Error("No .duckdb file found in current directory");
+          dbPath = path6.resolve(config.root, dbPath);
+        }
+        let db = await DuckDBInstance.create(":memory:");
+        this.connection = await db.connect();
+        let escapedPath = dbPath.replace(/'/g, "''");
+        await this.connection.run(`attach '${escapedPath}' as graphene_cli (READ_ONLY);`);
+        await this.connection.run("use graphene_cli;");
+      }
+      async runQuery(sql) {
+        await this.ready;
+        let reader = await this.connection.runAndReadAll(sql);
+        let rows = reader.getRowObjects().map((record) => {
+          let out = {};
+          for (let [k, v] of Object.entries(record)) {
+            if (typeof v === "bigint") out[k] = Number(v);
+            else if (v === null) out[k] = null;
+            else if (v instanceof DuckDBTimestampValue) out[k] = new Date(Number(v.micros / 1000n)).toUTCString();
+            else if (v instanceof DuckDBDateValue) out[k] = v.toString();
+            else if (typeof v === "object") throw new Error(`Unsupported datatype ${v.constructor?.name}`);
+            else out[k] = v;
+          }
+          return out;
+        });
+        return { rows };
+      }
+      async listDatasets() {
+        return await Promise.resolve([]);
+      }
+      async listTables() {
+        let sql = `
+      select table_schema as table_schema, table_name as table_name
+      from information_schema.tables
+      where table_type in ('BASE TABLE', 'VIEW') and table_schema not in ('information_schema', 'pg_catalog')
+      order by table_schema, table_name
+    `.trim();
+        let res = await this.runQuery(sql);
+        return res.rows.map((row) => String(row["table_name"]));
+      }
+      async describeTable(target) {
+        let parts = target.split(".");
+        let table2 = parts.pop() || "";
+        let schema = parts[0];
+        let schemaFilter = schema ? `lower(table_schema) = lower(${sqlStringLiteral2(schema)})` : "table_schema not in ('information_schema', 'pg_catalog')";
+        let sql = `
+      select column_name as column_name, data_type as data_type, ordinal_position as ordinal_position
+      from information_schema.columns
+      where lower(table_name) = lower(${sqlStringLiteral2(table2)}) and ${schemaFilter}
+      order by ordinal_position
+    `.trim();
+        let res = await this.runQuery(sql);
+        return res.rows.map((row) => {
+          return { name: String(row["column_name"]), dataType: String(row["data_type"]) };
+        });
+      }
+    };
+  }
+});
+
+// connections/snowflake.ts
+var snowflake_exports = {};
+__export(snowflake_exports, {
+  SnowflakeConnection: () => SnowflakeConnection
+});
+import { createPrivateKey } from "node:crypto";
+import snowflake from "snowflake-sdk";
+function getSnowflakeNamespace() {
+  throw new Error("Not yet implemented");
+}
+function snowflakeIdent(value) {
+  if (!value) throw new Error("Snowflake identifiers cannot be empty");
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function sqlStringLiteral3(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+var SnowflakeConnection;
+var init_snowflake2 = __esm({
+  "connections/snowflake.ts"() {
+    "use strict";
+    init_config();
+    SnowflakeConnection = class {
+      ready;
+      connection;
+      constructor(opts) {
+        this.ready = this.initialize(opts || {});
+      }
+      async initialize(opts) {
+        let privateKeyPath = process.env.SNOWFLAKE_PRI_KEY_PATH || config.snowflake?.privateKeyPath;
+        let privateKeyPass = process.env.SNOWFLAKE_PRI_PASSPHRASE;
+        let authOptions = {};
+        if (privateKeyPath) {
+          authOptions = { privateKeyPath, privateKeyPass };
+        } else if (opts.privateKey) {
+          let privateKey = createPrivateKey({ key: opts.privateKey, format: "pem", passphrase: privateKeyPass });
+          authOptions = { privateKey: privateKey.export({ format: "pem", type: "pkcs8" }) };
+        }
+        snowflake.configure({ logLevel: process.env.SNOWFLAKE_LOG_LEVEL || "WARN", logFilePath: "/dev/null" });
+        this.connection = snowflake.createConnection({
+          ...opts,
+          ...config.snowflake || {},
+          ...authOptions,
+          authenticator: "SNOWFLAKE_JWT",
+          application: "Graphene"
+        });
+        await new Promise((resolve, reject) => {
+          this.connection.connect((err, conn) => err ? reject(err) : resolve(conn));
+        });
+      }
+      async runQuery(sql) {
+        await this.ready;
+        return await new Promise((resolve, reject) => {
+          let rows = [];
+          this.connection.execute({
+            sqlText: sql,
+            streamResult: true,
+            complete: (error, statement) => {
+              if (error) {
+                reject(new Error(`Snowflake query failed: ${error.message || error}`));
+                return;
+              }
+              let stream = statement.streamRows();
+              stream.on("error", (err) => reject(err));
+              stream.on("readable", function(row) {
+                while ((row = this.read()) !== null) {
+                  rows.push(row);
+                }
+              });
+              stream.on("end", () => {
+                let totalRows = Number(statement.getNumRows());
+                resolve({ rows, totalRows });
+              });
+            }
+          });
+        });
+      }
+      async listDatasets() {
+        await Promise.resolve();
+        throw new Error("Not yet implemented");
+      }
+      async listTables() {
+        let { database } = getSnowflakeNamespace();
+        let tablesRef = `${snowflakeIdent(database)}.${snowflakeIdent("INFORMATION_SCHEMA")}.${snowflakeIdent("TABLES")}`;
+        let sql = `
+      select table_schema as "table_schema", table_name as "table_name"
+      from ${tablesRef}
+      where table_type in ('BASE TABLE', 'VIEW')
+      order by table_schema, table_name
+    `.trim();
+        let res = await this.runQuery(sql);
+        return res.rows.map((row) => String(row["table_name"] || ""));
+      }
+      async describeTable(target) {
+        let parts = target.split(".");
+        let table2 = parts.pop() || "";
+        let database = parts.shift() || "";
+        let schema = parts.join(".");
+        let columnsRef = `${snowflakeIdent(database)}.${snowflakeIdent("INFORMATION_SCHEMA")}.${snowflakeIdent("COLUMNS")}`;
+        let sql = `
+      select column_name as "column_name", data_type as "data_type", ordinal_position as ordinal_position
+      from ${columnsRef}
+      where upper(table_schema) = upper(${sqlStringLiteral3(schema)}) and upper(table_name) = upper(${sqlStringLiteral3(table2)})
+      order by ordinal_position
+    `.trim();
+        let res = await this.runQuery(sql);
+        return res.rows.map((row) => {
+          return { name: String(row["column_name"]), dataType: String(row["data_type"]) };
+        });
+      }
+    };
+  }
+});
+
+// connections/index.ts
+async function getConnection() {
+  if (config.dialect === "bigquery") {
+    let mod = await Promise.resolve().then(() => (init_bigQuery(), bigQuery_exports));
+    return new mod.BigQueryConnection();
+  } else if (config.dialect === "duckdb") {
+    let mod = await Promise.resolve().then(() => (init_duckdb(), duckdb_exports));
+    return new mod.DuckDBConnection({});
+  } else if (config.dialect === "snowflake") {
+    let mod = await Promise.resolve().then(() => (init_snowflake2(), snowflake_exports));
+    return new mod.SnowflakeConnection({});
+  } else {
+    throw new Error(`Unsupported dialect: ${config.dialect}`);
+  }
+}
+async function runQuery(sql) {
+  if (config.host) {
+    let resp = await authenticatedFetch("/_api/query", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sql })
+    });
+    return await resp.json();
+  }
+  let conn = await getConnection();
+  return await conn.runQuery(sql);
+}
+var init_connections = __esm({
+  "connections/index.ts"() {
+    "use strict";
+    init_config();
+    init_auth();
+  }
+});
+
+// mdCompile.ts
+import fs6 from "fs";
+import path7 from "path";
 import { visit } from "unist-util-visit";
 import sanitizeHtml from "sanitize-html";
 function extractQueries() {
@@ -1922,13 +2603,14 @@ ${content}`;
 }
 function componentNames() {
   if (cachedComponentNames) return cachedComponentNames;
-  let files = fs5.readdirSync(path6.join(import.meta.dirname, "../ui/components"));
-  cachedComponentNames = files.map((f) => path6.basename(f, ".svelte")).filter((f) => !f.startsWith("_"));
+  let files = fs6.readdirSync(path7.join(import.meta.dirname, "../ui/components"));
+  cachedComponentNames = files.map((f) => path7.basename(f, ".svelte")).filter((f) => !f.startsWith("_"));
   return cachedComponentNames || [];
 }
 var cachedComponentNames;
 var init_mdCompile = __esm({
   "mdCompile.ts"() {
+    "use strict";
     cachedComponentNames = null;
   }
 });
@@ -1940,16 +2622,15 @@ __export(serve2_exports, {
 });
 import { createServer, optimizeDeps } from "vite";
 import { svelte, vitePreprocess } from "@sveltejs/vite-plugin-svelte";
-import fs6 from "fs-extra";
-import crypto from "crypto";
+import fs7 from "fs-extra";
+import crypto2 from "crypto";
 import { mdsvex } from "mdsvex";
-import path7 from "path";
+import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function serve2() {
-  uiRoot = path7.join(fileURLToPath2(import.meta.url), "../../ui");
+  uiRoot = path8.join(fileURLToPath2(import.meta.url), "../../ui");
   let port = Number(process.env.GRAPHENE_PORT) || 4e3;
-  await fs6.ensureDir(path7.resolve(config.root, "node_modules/.graphene"));
-  await fs6.writeFile(path7.resolve(config.root, `node_modules/.graphene/${process.env.NODE_ENV == "test" ? "test" : "serve"}.pid`), String(process.pid));
+  await fs7.ensureDir(path8.resolve(config.root, "node_modules/.graphene"));
   let server = await createServer({
     root: config.root,
     plugins: [
@@ -1970,7 +2651,6 @@ async function serve2() {
       updateWorkspacePlugin,
       mockFilesForTests()
     ],
-    publicDir: path7.resolve(uiRoot),
     server: {
       port,
       fs: { strict: false },
@@ -1978,7 +2658,7 @@ async function serve2() {
     },
     resolve: {
       alias: {
-        graphene: path7.resolve(uiRoot, "web.js")
+        graphene: path8.resolve(uiRoot, "web.js")
       }
     }
     // optimizeDeps: { // this seems prudent in tests, but currently breaks because ssf needs to be optimized, even in tests
@@ -1988,9 +2668,7 @@ async function serve2() {
   });
   await optimizeDeps(server.config);
   await server.listen();
-  if (process.env.NODE_ENV !== "test") {
-    console.log(`Server running at http://localhost:${port}`);
-  }
+  console.log(`Server running at http://localhost:${port}`);
   return server;
 }
 async function handleQuery(req, res) {
@@ -2007,14 +2685,13 @@ async function handleQuery(req, res) {
   }
   if (queries.length > 1) throw new Error("Found multiple queries, which could be a parsing error");
   let sql = toSql(queries[0], params);
-  let hash = crypto.createHash("SHA1").update(sql).digest("hex");
+  let hash = crypto2.createHash("SHA1").update(sql).digest("hex");
   res.setHeader("ETag", hash);
   if (hashes.includes(hash) && req.headers["cache-control"] != "no-cache") {
     res.statusCode = 304;
     return res.end();
   }
-  let connection = await getConnection();
-  let queryResults = await connection.runQuery(sql);
+  let queryResults = await runQuery(sql);
   let totalRows = queryResults.totalRows ?? queryResults.rows.length;
   if (totalRows > queryResults.rows.length) throw new Error("Query returns too many rows");
   let fields = queries[0].fields.map((f) => ({ name: f.name, type: f.type }));
@@ -2032,7 +2709,7 @@ async function handlePage(server, res, filePath, mount) {
       <meta charset="UTF-8" />
       <meta name="viewport" content="width=device-width, initial-scale=1.0" />
       <title>Graphene</title>
-      <link rel="icon" href="/assets/favicon.ico" />
+      <link rel="icon" href="/favicon.ico" />
       <link rel="preconnect" href="https://fonts.googleapis.com">
       <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
       <link href="https://fonts.googleapis.com/css2?family=Inter:wght@100..900&display=swap" rel="stylesheet">
@@ -2066,6 +2743,7 @@ function mockFilesForTests() {
 var uiRoot, workspaceLoadPromise, updateWorkspacePlugin, handleRequestPlugin;
 var init_serve2 = __esm({
   "serve2.ts"() {
+    "use strict";
     init_core();
     init_connections();
     init_mdCompile();
@@ -2090,9 +2768,13 @@ var init_serve2 = __esm({
             let [pathName] = (req.url || "").split("?");
             if (pathName == "/_api/query") return await handleQuery(req, res);
             if (pathName == "/__ct") return await handlePage(s, res, "__ct", false);
+            if (pathName == "/favicon.ico") {
+              res.setHeader("Content-Type", "image/x-icon");
+              return res.end(await fs7.readFile(path8.resolve(uiRoot, "assets/favicon.ico")));
+            }
             if (!pathName || pathName == "/") pathName = "index";
-            let mdPath = path7.join(config.root, pathName + ".md");
-            if (await fs6.exists(mdPath)) {
+            let mdPath = path8.join(config.root, pathName + ".md");
+            if (await fs7.exists(mdPath)) {
               await handlePage(s, res, mdPath, true);
             } else {
               next();
@@ -2113,11 +2795,14 @@ init_printer();
 init_core();
 init_config();
 init_background();
-init_connections();
 init_check();
+init_connections();
+init_auth();
 import { Command } from "commander";
-import fs7 from "fs-extra";
-import path8 from "path";
+import fs8 from "fs-extra";
+import path9 from "path";
+import dotenv from "dotenv";
+dotenv.config({ quiet: true });
 var program = new Command();
 program.name("graphene").description("Graphene CLI").version("1.0.0");
 program.hook("preAction", async () => {
@@ -2139,26 +2824,54 @@ program.command("run").description("Run a query against your database").argument
   let queries = analyze(gsql);
   if (!validQuery(queries)) return;
   let sql = toSql(queries[0]);
-  let connection = await getConnection();
-  let res = await connection.runQuery(sql);
+  let res = await runQuery(sql);
   printTable(res.rows);
 });
-program.command("serve").description("Run the local server").option("--fg", "Run the server in the foreground").action(async (options) => {
-  if (options.fg || process.env.DEBUG) {
-    let mod = await Promise.resolve().then(() => (init_serve2(), serve2_exports));
-    await mod.serve2();
-  } else {
+program.command("schema").description("Inspect database tables or describe a table").argument("[schema | table]", "Optional schema or table name to describe").action(async (tableArg) => {
+  let connection = await getConnection();
+  let datasets = await connection.listDatasets();
+  if (!tableArg && datasets.length > 1) {
+    return console.log(`Datasets available:
+${datasets.join("\n")}`);
+  }
+  let dsToList = null;
+  if (datasets.includes(tableArg)) dsToList = tableArg;
+  else if (!tableArg && datasets.length == 1) dsToList = datasets[0];
+  else if (!tableArg && config.namespace) dsToList = config.namespace;
+  else if (!tableArg && config.dialect == "duckdb") dsToList = "<default>";
+  if (dsToList) {
+    let tables = await connection.listTables(dsToList);
+    return console.log(`Tables${dsToList ? ` in ${dsToList}` : ""}:
+${tables.join("\n")}`);
+  }
+  let cols = await connection.describeTable(tableArg);
+  if (!cols.length) return console.log(`Table ${tableArg} not found`);
+  console.log(`table ${tableArg} (`);
+  cols.forEach((col) => console.log(`  ${col.name} ${col.dataType}`));
+  console.log(")");
+});
+program.command("serve").description("Run the local server").option("--bg", "Run the server in the background").action(async (options) => {
+  await stopGrapheneIfRunning();
+  if (options.bg) {
     await runServeInBackground();
     process.exit(0);
+  } else {
+    let mod = await Promise.resolve().then(() => (init_serve2(), serve2_exports));
+    await mod.serve2();
   }
 });
 program.command("stop").description("Stop the local server").action(async () => {
-  await stopGrapheneIfRunning(process.cwd());
+  await stopGrapheneIfRunning();
 });
 program.command("check").description("Check the project for errors, optionally capturing a page screenshot").argument("[mdFile]", "Markdown file to check (e.g., index.md)").option("-c, --chart <chartTitle>", "Title of a specific chart to capture").action(async (mdArg, options) => {
   let res = await check({ mdArg, chart: options.chart });
   process.exit(res ? 0 : 1);
 });
+program.command("login").description("Log in to Graphene Cloud").action(async () => {
+  await loginPkce();
+  console.log("Successfully logged in");
+  process.exit(0);
+});
 program.parse(process.argv);
 async function readInput(arg) {
   if (!arg || arg === "-") {
@@ -2170,9 +2883,9 @@ async function readInput(arg) {
       process.stdin.resume();
     });
   }
-  let absolutePath = path8.resolve(arg);
-  if (fs7.existsSync(absolutePath)) {
-    return await fs7.promises.readFile(absolutePath, "utf-8");
+  let absolutePath = path9.resolve(arg);
+  if (fs8.existsSync(absolutePath)) {
+    return await fs8.promises.readFile(absolutePath, "utf-8");
   }
   return arg;
 }