@malloydata/render 0.0.133-dev240318205756 → 0.0.133-dev240320200749

package/dist/bundle/bundled_renderer.js

@@ -5414,6 +5414,468 @@ ${(0, utils_1.indent)(sql)}
     }
   });
 
+  // ../malloy/dist/dialect/trino/functions/trino_functions.js
+  var require_trino_functions = __commonJS({
+    "../malloy/dist/dialect/trino/functions/trino_functions.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.TRINO_FUNCTIONS = void 0;
+      var functions_1 = require_functions();
+      exports.TRINO_FUNCTIONS = functions_1.FUNCTIONS.clone();
+      exports.TRINO_FUNCTIONS.seal();
+    }
+  });
+
+  // ../malloy/dist/dialect/trino/functions/index.js
+  var require_functions6 = __commonJS({
+    "../malloy/dist/dialect/trino/functions/index.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.TRINO_FUNCTIONS = void 0;
+      var trino_functions_1 = require_trino_functions();
+      Object.defineProperty(exports, "TRINO_FUNCTIONS", { enumerable: true, get: function() {
+        return trino_functions_1.TRINO_FUNCTIONS;
+      } });
+    }
+  });
+
+  // ../malloy/dist/dialect/trino/trino.js
+  var require_trino = __commonJS({
+    "../malloy/dist/dialect/trino/trino.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.TrinoDialect = void 0;
+      var utils_1 = require_utils();
+      var malloy_types_1 = require_malloy_types();
+      var functions_1 = require_functions6();
+      var dialect_1 = require_dialect();
+      function timestampMeasureable(units) {
+        return [
+          "microsecond",
+          "millisecond",
+          "second",
+          "minute",
+          "hour",
+          "day"
+        ].includes(units);
+      }
+      function dateMeasureable(units) {
+        return ["day", "week", "month", "quarter", "year"].includes(units);
+      }
+      var extractMap = {
+        "day_of_week": "dayofweek",
+        "day_of_year": "dayofyear"
+      };
+      function qtz(qi) {
+        const tz = qi.queryTimezone;
+        if (tz && tz !== "UTC") {
+          return tz;
+        }
+      }
+      var TrinoDialect = class extends dialect_1.Dialect {
+        constructor() {
+          super(...arguments);
+          this.name = "trino";
+          this.defaultNumberType = "FLOAT64";
+          this.defaultDecimalType = "NUMERIC";
+          this.udfPrefix = "__udf";
+          this.hasFinalStage = false;
+          this.divisionIsInteger = false;
+          this.supportsSumDistinctFunction = false;
+          this.unnestWithNumbers = false;
+          this.defaultSampling = { enable: false };
+          this.supportUnnestArrayAgg = false;
+          this.supportsAggDistinct = false;
+          this.supportsCTEinCoorelatedSubQueries = false;
+          this.dontUnionIndex = true;
+          this.supportsQualify = true;
+          this.supportsSafeCast = true;
+          this.supportsNesting = true;
+          this.cantPartitionWindowFunctionsOnExpressions = true;
+          this.keywords = `
+  ALL
+  AND
+  ANY
+  ARRAY
+  AS
+  ASC
+  ASSERT_ROWS_MODIFIED
+  AT
+  BETWEEN
+  BY
+  CASE
+  CAST
+  COLLATE
+  CONTAINS
+  CREATE
+  CROSS
+  CUBE
+  CURRENT
+  DEFAULT
+  DEFINE
+  DESC
+  DISTINCT
+  ELSE
+  END
+  ENUM
+  ESCAPE
+  EXCEPT
+  EXCLUDE
+  EXISTS
+  EXTRACT
+  FALSE
+  FETCH
+  FOLLOWING
+  FOR
+  FROM
+  FULL
+  GROUP
+  GROUPING
+  GROUPS
+  HASH
+  HAVING
+  IF
+  IGNORE
+  IN
+  INNER
+  INTERSECT
+  INTERVAL
+  INTO
+  IS
+  JOIN
+  LATERAL
+  LEFT
+  LIKE
+  LIMIT
+  LOOKUP
+  MERGE
+  NATURAL
+  NEW
+  NO
+  NOT
+  NULL
+  NULLS
+  OF
+  ON
+  OR
+  ORDER
+  OUTER
+  OVER
+  PARTITION
+  PRECEDING
+  PROTO
+  RANGE
+  RECURSIVE
+  RESPECT
+  RIGHT
+  ROLLUP
+  ROWS
+  SELECT
+  SET
+  SOME
+  STRUCT
+  TABLESAMPLE
+  THEN
+  TO
+  TREAT
+  TRUE
+  UNBOUNDED
+  UNION
+  UNNEST
+  USING
+  WHEN
+  WHERE
+  WINDOW
+  WITH
+  WITHIN`.split(/\s/);
+        }
+        quoteTablePath(tablePath) {
+          return `${tablePath.replace(/malloytest/g, "malloy_demo.faa")}`;
+        }
+        sqlGroupSetTable(groupSetCount) {
+          return `CROSS JOIN (SELECT row_number() OVER() -1  group_set FROM UNNEST(SEQUENCE(0,${groupSetCount})))`;
+        }
+        sqlAnyValue(groupSet, fieldName) {
+          return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${fieldName} END)`;
+        }
+        // can array agg or any_value a struct...
+        sqlAggregateTurtle(groupSet, fieldList, orderBy, limit) {
+          let tail = "";
+          if (limit !== void 0) {
+            tail += ` LIMIT ${limit}`;
+          }
+          const fields = fieldList.map((f4) => `
+ '${f4.sqlOutputName}' VALUE ${f4.sqlExpression}`).join(", ");
+          return `cast(COALESCE(SLICE(COALESCE(ARRAY_AGG(CASE WHEN group_set=${groupSet} THEN JSON_PARSE(JSON_OBJECT(${fields})) END 
+ ${orderBy} -- ${tail}
+), ARRAY[]), 1, ${limit}), ARRAY[]) as json)`;
+        }
+        sqlAnyValueTurtle(groupSet, fieldList) {
+          const fields = fieldList.map((f4) => `
+ '${f4.sqlOutputName}' VALUE ${f4.sqlExpression}`).join(", ");
+          return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN JSON_OBJECT(${fields}))`;
+        }
+        sqlAnyValueLastTurtle(name, groupSet, sqlName) {
+          return `ANY_VALUE(CASE WHEN group_set=${groupSet} THEN ${name} END) as ${sqlName}`;
+        }
+        sqlCoaleseMeasuresInline(groupSet, fieldList) {
+          const fields = fieldList.map((f4) => `${f4.sqlExpression} as ${f4.sqlOutputName}`).join(", ");
+          const nullValues = fieldList.map((f4) => `NULL as ${f4.sqlOutputName}`).join(", ");
+          return `COALESCE(ANY_VALUE(CASE WHEN group_set=${groupSet} THEN STRUCT(${fields}) END), STRUCT(${nullValues}))`;
+        }
+        //
+        // this code used to be:
+        //
+        //   from += `JOIN UNNEST(GENERATE_ARRAY(0,${this.maxGroupSet},1)) as group_set\n`;
+        //
+        // BigQuery will allocate more resources if we use a CROSS JOIN so we do that instead.
+        //
+        sqlUnnestAlias(source3, alias, fieldList, needDistinctKey, isArray2, _isInNestedPipeline) {
+          if (isArray2) {
+            if (needDistinctKey) {
+              return `LEFT JOIN UNNEST(ARRAY(( SELECT AS STRUCT row_number() over() as __row_id, value FROM UNNEST(${source3}) value))) as ${alias}`;
+            } else {
+              return `LEFT JOIN UNNEST(ARRAY((SELECT AS STRUCT value FROM unnest(${source3}) value))) as ${alias}`;
+            }
+          } else if (needDistinctKey) {
+            return `LEFT JOIN UNNEST(ARRAY(( SELECT AS STRUCT row_number() over() as __row_id, * FROM UNNEST(${source3})))) as ${alias}`;
+          } else {
+            return `LEFT JOIN UNNEST(${source3}) as ${alias}`;
+          }
+        }
+        sqlSumDistinctHashedKey(sqlDistinctKey) {
+          sqlDistinctKey = `CAST(${sqlDistinctKey} AS STRING)`;
+          const upperPart = `cast(cast(concat('0x', substr(to_hex(md5(${sqlDistinctKey})), 1, 15)) as int64) as numeric) * 4294967296`;
+          const lowerPart = `cast(cast(concat('0x', substr(to_hex(md5(${sqlDistinctKey})), 16, 8)) as int64) as numeric)`;
+          const precisionShiftMultiplier = "0.000000001";
+          return `(${upperPart} + ${lowerPart}) * ${precisionShiftMultiplier}`;
+        }
+        sqlGenerateUUID() {
+          return "GENERATE_UUID()";
+        }
+        sqlFieldReference(alias, fieldName, _fieldType, _isNested, _isArray) {
+          return `${alias}.${fieldName}`;
+        }
+        sqlUnnestPipelineHead(isSingleton, sourceSQLExpression) {
+          let p3 = sourceSQLExpression;
+          if (isSingleton) {
+            p3 = `[${p3}]`;
+          }
+          return `UNNEST(${p3})`;
+        }
+        sqlCreateFunction(id2, funcText) {
+          return `CREATE TEMPORARY FUNCTION ${id2}(__param ANY TYPE) AS ((
+${(0, utils_1.indent)(funcText)}));
+`;
+        }
+        sqlCreateTableAsSelect(tableName, sql) {
+          return `
+CREATE TABLE IF NOT EXISTS \`${tableName}\`
+OPTIONS (
+    expiration_timestamp=TIMESTAMP_ADD(current_timestamp(),  INTERVAL 1 hour)
+)
+AS (
+${(0, utils_1.indent)(sql)}
+);
+`;
+        }
+        sqlCreateFunctionCombineLastStage(lastStageName) {
+          return `SELECT ARRAY((SELECT AS STRUCT * FROM ${lastStageName}))
+`;
+        }
+        sqlSelectAliasAsStruct(alias) {
+          return `(SELECT AS STRUCT ${alias}.*)`;
+        }
+        sqlMaybeQuoteIdentifier(identifier) {
+          return identifier;
+        }
+        sqlNow() {
+          return (0, malloy_types_1.mkExpr)`CURRENT_TIMESTAMP()`;
+        }
+        sqlTrunc(qi, sqlTime, units) {
+          const tz = qtz(qi);
+          const tzAdd = tz ? `, "${tz}"` : "";
+          if (sqlTime.valueType === "date") {
+            if (dateMeasureable(units)) {
+              return (0, malloy_types_1.mkExpr)`DATE_TRUNC(${sqlTime.value},${units})`;
+            }
+            return (0, malloy_types_1.mkExpr)`TIMESTAMP(${sqlTime.value}${tzAdd})`;
+          }
+          return (0, malloy_types_1.mkExpr)`TIMESTAMP_TRUNC(${sqlTime.value},${units}${tzAdd})`;
+        }
+        sqlExtract(qi, expr2, units) {
+          const extractTo = extractMap[units] || units;
+          const tz = expr2.valueType === "timestamp" && qtz(qi);
+          const tzAdd = tz ? ` AT TIME ZONE '${tz}'` : "";
+          return (0, malloy_types_1.mkExpr)`EXTRACT(${extractTo} FROM ${expr2.value}${tzAdd})`;
+        }
+        sqlAlterTime(op, expr2, n7, timeframe) {
+          let theTime = expr2.value;
+          let computeType = expr2.valueType;
+          if (timeframe !== "day" && timestampMeasureable(timeframe)) {
+            computeType = "timestamp";
+            if (expr2.valueType !== "timestamp") {
+              theTime = (0, malloy_types_1.mkExpr)`TIMESTAMP(${theTime})`;
+            }
+          } else if (expr2.valueType === "timestamp") {
+            theTime = (0, malloy_types_1.mkExpr)`DATETIME(${theTime})`;
+            computeType = "datetime";
+          }
+          const funcName = computeType.toUpperCase() + (op === "+" ? "_ADD" : "_SUB");
+          const newTime = (0, malloy_types_1.mkExpr)`${funcName}(${theTime}, INTERVAL ${n7} ${timeframe})`;
+          if (computeType === expr2.valueType) {
+            return newTime;
+          }
+          return (0, malloy_types_1.mkExpr)`${expr2.valueType.toUpperCase()}(${newTime})`;
+        }
+        ignoreInProject(fieldName) {
+          return fieldName === "_PARTITIONTIME";
+        }
+        sqlCast(qi, cast) {
+          const op = `${cast.srcType}::${cast.dstType}`;
+          const tz = qtz(qi);
+          if (op === "timestamp::date" && tz) {
+            return (0, malloy_types_1.mkExpr)`DATE(${cast.expr},'${tz}')`;
+          }
+          if (op === "date::timestamp" && tz) {
+            return (0, malloy_types_1.mkExpr)`TIMESTAMP(${cast.expr}, '${tz}')`;
+          }
+          if (cast.srcType !== cast.dstType) {
+            const dstType = typeof cast.dstType === "string" ? this.malloyTypeToSQLType({ type: cast.dstType }) : cast.dstType.raw;
+            const castFunc = cast.safe ? "SAFE_CAST" : "CAST";
+            return (0, malloy_types_1.mkExpr)`${castFunc}(${cast.expr} AS ${dstType})`;
+          }
+          return cast.expr;
+        }
+        sqlRegexpMatch(expr2, regexp) {
+          return (0, malloy_types_1.mkExpr)`REGEXP_CONTAINS(${expr2}, ${regexp})`;
+        }
+        sqlLiteralTime(qi, timeString, type3, timezone) {
+          if (type3 === "date") {
+            return `DATE('${timeString}')`;
+          } else if (type3 === "timestamp") {
+            let timestampArgs = `'${timeString}'`;
+            const tz = timezone || qtz(qi);
+            if (tz && tz !== "UTC") {
+              timestampArgs += `,'${tz}'`;
+            }
+            return `TIMESTAMP(${timestampArgs})`;
+          } else {
+            throw new Error(`Unsupported Literal time format ${type3}`);
+          }
+        }
+        sqlMeasureTime(from, to, units) {
+          const measureMap = {
+            "microsecond": { use: "microsecond", ratio: 1 },
+            "millisecond": { use: "microsecond", ratio: 1e3 },
+            "second": { use: "millisecond", ratio: 1e3 },
+            "minute": { use: "second", ratio: 60 },
+            "hour": { use: "minute", ratio: 60 },
+            "day": { use: "hour", ratio: 24 },
+            "week": { use: "day", ratio: 7 }
+          };
+          let lVal = from.value;
+          let rVal = to.value;
+          if (measureMap[units]) {
+            const { use: measureIn, ratio } = measureMap[units];
+            if (!timestampMeasureable(measureIn)) {
+              throw new Error(`Measure in '${measureIn} not implemented`);
+            }
+            if (from.valueType !== to.valueType) {
+              throw new Error("Can't measure difference between different types");
+            }
+            if (from.valueType === "date") {
+              lVal = (0, malloy_types_1.mkExpr)`TIMESTAMP(${lVal})`;
+              rVal = (0, malloy_types_1.mkExpr)`TIMESTAMP(${rVal})`;
+            }
+            let measured = (0, malloy_types_1.mkExpr)`TIMESTAMP_DIFF(${rVal},${lVal},${measureIn})`;
+            if (ratio !== 1) {
+              measured = (0, malloy_types_1.mkExpr)`FLOOR(${measured}/${ratio.toString()}.0)`;
+            }
+            return measured;
+          }
+          throw new Error(`Measure '${units} not implemented`);
+        }
+        sqlSampleTable(tableSQL, sample) {
+          if (sample !== void 0) {
+            if ((0, malloy_types_1.isSamplingEnable)(sample) && sample.enable) {
+              sample = this.defaultSampling;
+            }
+            if ((0, malloy_types_1.isSamplingRows)(sample)) {
+              throw new Error("StandardSQL doesn't support sampling by rows only percent");
+            } else if ((0, malloy_types_1.isSamplingPercent)(sample)) {
+              return `(SELECT * FROM ${tableSQL}  TABLESAMPLE SYSTEM (${sample.percent} PERCENT))`;
+            }
+          }
+          return tableSQL;
+        }
+        sqlLiteralString(literal) {
+          const noVirgule = literal.replace(/\\/g, "\\\\");
+          return "'" + noVirgule.replace(/'/g, "\\'") + "'";
+        }
+        sqlLiteralRegexp(literal) {
+          const noVirgule = literal.replace(/\\/g, "\\\\");
+          return "'" + noVirgule.replace(/'/g, "\\'") + "'";
+        }
+        getGlobalFunctionDef(name) {
+          return functions_1.TRINO_FUNCTIONS.get(name);
+        }
+        malloyTypeToSQLType(malloyType) {
+          if (malloyType.type === "number") {
+            if (malloyType.numberType === "integer") {
+              return "INT64";
+            } else {
+              return "FLOAT64";
+            }
+          }
+          return malloyType.type;
+        }
+        sqlTypeToMalloyType(_sqlType) {
+          return void 0;
+        }
+        castToString(expression3) {
+          return `CAST(${expression3} as STRING)`;
+        }
+        concat(...values4) {
+          return values4.join(" || ");
+        }
+        validateTypeName(sqlType) {
+          return sqlType.match(/^[A-Za-z\s(),<>0-9]*$/) !== null;
+        }
+      };
+      exports.TrinoDialect = TrinoDialect;
+    }
+  });
+
+  // ../malloy/dist/dialect/trino/index.js
+  var require_trino2 = __commonJS({
+    "../malloy/dist/dialect/trino/index.js"(exports) {
+      "use strict";
+      var __createBinding = exports && exports.__createBinding || (Object.create ? function(o5, m4, k2, k22) {
+        if (k22 === void 0)
+          k22 = k2;
+        var desc = Object.getOwnPropertyDescriptor(m4, k2);
+        if (!desc || ("get" in desc ? !m4.__esModule : desc.writable || desc.configurable)) {
+          desc = { enumerable: true, get: function() {
+            return m4[k2];
+          } };
+        }
+        Object.defineProperty(o5, k22, desc);
+      } : function(o5, m4, k2, k22) {
+        if (k22 === void 0)
+          k22 = k2;
+        o5[k22] = m4[k2];
+      });
+      var __exportStar = exports && exports.__exportStar || function(m4, exports2) {
+        for (var p3 in m4)
+          if (p3 !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p3))
+            __createBinding(exports2, m4, p3);
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      __exportStar(require_trino(), exports);
+    }
+  });
+
   // ../malloy/dist/dialect/dialect_map.js
   var require_dialect_map = __commonJS({
     "../malloy/dist/dialect/dialect_map.js"(exports) {
@@ -5424,6 +5886,7 @@ ${(0, utils_1.indent)(sql)}
       var postgres_1 = require_postgres2();
       var snowflake_1 = require_snowflake2();
       var standardsql_1 = require_standardsql2();
+      var trino_1 = require_trino2();
       var dialectMap = /* @__PURE__ */ new Map();
       function getDialect(name) {
         const d3 = dialectMap.get(name);
@@ -5441,6 +5904,7 @@ ${(0, utils_1.indent)(sql)}
       registerDialect(new standardsql_1.StandardSQLDialect());
       registerDialect(new duckdb_1.DuckDBDialect());
       registerDialect(new snowflake_1.SnowflakeDialect());
+      registerDialect(new trino_1.TrinoDialect());
       function paramsEqual(a5, b4) {
         return a5.params.length === b4.params.length && a5.params.every((param2, i6) => {
           const otherParam = b4.params[i6];
@@ -5515,7 +5979,7 @@ ${(0, utils_1.indent)(sql)}
     "../malloy/dist/dialect/index.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.FUNCTIONS = exports.getDialectFunction = exports.registerDialect = exports.getDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.params = exports.param = exports.sqlFragment = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
+      exports.FUNCTIONS = exports.getDialectFunction = exports.registerDialect = exports.getDialect = exports.TrinoDialect = exports.SnowflakeDialect = exports.DuckDBDialect = exports.PostgresDialect = exports.StandardSQLDialect = exports.qtz = exports.Dialect = exports.sql = exports.literal = exports.params = exports.param = exports.sqlFragment = exports.spread = exports.maxScalar = exports.minAggregate = exports.minScalar = exports.overload = exports.makeParam = exports.anyExprType = exports.arg = void 0;
       var util_1 = require_util();
       Object.defineProperty(exports, "arg", { enumerable: true, get: function() {
         return util_1.arg;
@@ -5579,6 +6043,10 @@ ${(0, utils_1.indent)(sql)}
       Object.defineProperty(exports, "SnowflakeDialect", { enumerable: true, get: function() {
         return snowflake_1.SnowflakeDialect;
       } });
+      var trino_1 = require_trino2();
+      Object.defineProperty(exports, "TrinoDialect", { enumerable: true, get: function() {
+        return trino_1.TrinoDialect;
+      } });
       var dialect_map_1 = require_dialect_map();
       Object.defineProperty(exports, "getDialect", { enumerable: true, get: function() {
         return dialect_map_1.getDialect;