@malloydata/malloy 0.0.39-dev230613161129 → 0.0.39

package/dist/dialect/dialect.d.ts

@@ -1,4 +1,5 @@
-import { AtomicFieldType as AtomicFieldTypeInner, DialectFragment, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
+import { DialectFragment, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
+import { DialectFunctionOverloadDef } from './functions';
 interface DialectField {
     type: string;
     sqlExpression: string;
@@ -18,14 +19,6 @@ export interface QueryInfo {
 export declare const dayIndex: number;
 export declare function inDays(units: string): boolean;
 export declare function qtz(qi: QueryInfo): string | undefined;
-/**
- * Someday this might be used to control how a function call in malloy is
- * translated into a function call in SQL. Today this is just so that
- * the expression compiler can know the output type of a function.
- */
-export interface FunctionInfo {
-    returnType: AtomicFieldTypeInner;
-}
 export declare type DialectFieldList = DialectField[];
 export declare abstract class Dialect {
     abstract name: string;
@@ -36,12 +29,13 @@ export declare abstract class Dialect {
     abstract divisionIsInteger: boolean;
     abstract supportsSumDistinctFunction: boolean;
     abstract unnestWithNumbers: boolean;
-    protected abstract functionInfo: Record<string, FunctionInfo>;
     abstract defaultSampling: Sampling;
+    abstract supportsAggDistinct: boolean;
     abstract supportUnnestArrayAgg: boolean;
     abstract supportsCTEinCoorelatedSubQueries: boolean;
     abstract dontUnionIndex: boolean;
     abstract supportsQualify: boolean;
+    abstract getGlobalFunctionDef(name: string): DialectFunctionOverloadDef[] | undefined;
     abstract quoteTablePath(tablePath: string): string;
     abstract sqlGroupSetTable(groupSetCount: number): string;
     abstract sqlAnyValue(groupSet: number, fieldName: string): string;
@@ -69,11 +63,13 @@ export declare abstract class Dialect {
     ignoreInProject(_fieldName: string): boolean;
     abstract sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
     abstract sqlLiteralTime(qi: QueryInfo, timeString: string, type: TimeFieldType, timezone?: string): string;
-    abstract sqlLiteralString(literak: string): string;
-    abstract sqlRegexpMatch(expr: Expr, regex: string): Expr;
-    getFunctionInfo(functionName: string): FunctionInfo | undefined;
+    abstract sqlLiteralString(literal: string): string;
+    abstract sqlLiteralRegexp(literal: string): string;
+    abstract sqlRegexpMatch(expr: Expr, regex: Expr): Expr;
+    sqlLiteralNumber(literal: string): string;
     dialectExpr(qi: QueryInfo, df: DialectFragment): Expr;
     sqlSumDistinct(_key: string, _value: string, _funcName: string): string;
+    sqlAggDistinct(_key: string, _values: string[], _func: (valNames: string[]) => string): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlOrderBy(orderTerms: string[]): string;
     sqlTzStr(qi: QueryInfo): string;

package/dist/dialect/dialect.js

@@ -64,8 +64,8 @@ class Dialect {
     ignoreInProject(_fieldName) {
         return false;
     }
-    getFunctionInfo(functionName) {
-        return this.functionInfo[functionName.toLowerCase()];
+    sqlLiteralNumber(literal) {
+        return literal;
     }
     dialectExpr(qi, df) {
         switch (df.function) {
@@ -96,10 +96,23 @@ class Dialect {
             }
             case 'stringLiteral':
                 return [this.sqlLiteralString(df.literal)];
+            case 'numberLiteral':
+                return [this.sqlLiteralNumber(df.literal)];
+            case 'regexpLiteral':
+                return [this.sqlLiteralRegexp(df.literal)];
         }
     }
     sqlSumDistinct(_key, _value, _funcName) {
-        return 'sqlSumDistinct called bu not implemented';
+        return 'sqlSumDistinct called but not implemented';
+    }
+    // Like sqlSumDistinct, but for an arbitrary aggregate expression
+    sqlAggDistinct(_key, _values, 
+    // A function which takes the value names used internally and produces the SQL operation using those
+    // value names.
+    // TODO maybe this should be flipped around and the SQL should be passed in directly along with the
+    // value names used?
+    _func) {
+        return 'sqlAggDistinct called but not implemented';
     }
     sqlSampleTable(tableSQL, sample) {
         if (sample !== undefined) {

package/dist/dialect/dialect_map.d.ts

@@ -1,3 +1,5 @@
 import { Dialect } from './dialect';
+import { FunctionDef } from '../model';
 export declare function getDialect(name: string): Dialect;
 export declare function registerDialect(d: Dialect): void;
+export declare function getDialectFunction(name: string): FunctionDef | undefined;

package/dist/dialect/dialect_map.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerDialect = exports.getDialect = void 0;
+exports.getDialectFunction = exports.registerDialect = exports.getDialect = void 0;
 const duckdb_1 = require("./duckdb");
 const postgres_1 = require("./postgres");
 const standardsql_1 = require("./standardsql");
@@ -42,4 +42,64 @@ exports.registerDialect = registerDialect;
 registerDialect(new postgres_1.PostgresDialect());
 registerDialect(new standardsql_1.StandardSQLDialect());
 registerDialect(new duckdb_1.DuckDBDialect());
+function paramsEqual(a, b) {
+    return (a.params.length === b.params.length &&
+        a.params.every((param, i) => {
+            const otherParam = b.params[i];
+            return (param.isVariadic === otherParam.isVariadic &&
+                param.name === otherParam.name &&
+                param.allowedTypes.length === otherParam.allowedTypes.length &&
+                param.allowedTypes.every(t => otherParam.allowedTypes.some(ot => t.dataType === ot.dataType &&
+                    t.expressionType === ot.expressionType)));
+        }));
+}
+function paramsCompatible(a, b) {
+    // TODO detect when parameters are not exactly equal, but would cause collision issues...
+    return paramsEqual(a, b);
+}
+function returnEqual(a, b) {
+    return (a.returnType.dataType === b.returnType.dataType &&
+        a.returnType.expressionType === b.returnType.expressionType);
+}
+function getDialectFunction(name) {
+    const func = {
+        type: 'function',
+        name,
+        overloads: [],
+    };
+    let found = false;
+    for (const dialect of dialectMap.values()) {
+        const overloads = dialect.getGlobalFunctionDef(name);
+        if (overloads) {
+            for (const overload of overloads) {
+                let handled = false;
+                for (const existingOverload of func.overloads) {
+                    if (!paramsCompatible(overload, existingOverload)) {
+                        continue;
+                    }
+                    if (!paramsEqual(overload, existingOverload)) {
+                        throw new Error('params are compatible but not equal');
+                    }
+                    if (!returnEqual(overload, existingOverload)) {
+                        throw new Error('params match but return types differ!');
+                    }
+                    existingOverload.dialect[dialect.name] = overload.e;
+                    handled = true;
+                }
+                if (!handled) {
+                    func.overloads.push({
+                        returnType: overload.returnType,
+                        params: overload.params,
+                        dialect: { [dialect.name]: overload.e },
+                        needsWindowOrderBy: overload.needsWindowOrderBy,
+                        between: overload.between,
+                    });
+                }
+            }
+            found = true;
+        }
+    }
+    return found ? func : undefined;
+}
+exports.getDialectFunction = getDialectFunction;
 //# sourceMappingURL=dialect_map.js.map

package/dist/dialect/{duckdb.d.ts → duckdb/duckdb.d.ts}

@@ -1,5 +1,6 @@
-import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../model/malloy_types';
-import { Dialect, DialectFieldList, FunctionInfo, QueryInfo } from './dialect';
+import { DateUnit, Expr, ExtractUnit, Sampling, StructDef, TimeFieldType, TimeValue, TimestampUnit, TypecastFragment } from '../../model/malloy_types';
+import { DialectFunctionOverloadDef } from '../functions';
+import { Dialect, DialectFieldList, QueryInfo } from '../dialect';
 export declare class DuckDBDialect extends Dialect {
     name: string;
     defaultNumberType: string;
@@ -12,10 +13,10 @@ export declare class DuckDBDialect extends Dialect {
         rows: number;
     };
     supportUnnestArrayAgg: boolean;
+    supportsAggDistinct: boolean;
     supportsCTEinCoorelatedSubQueries: boolean;
     dontUnionIndex: boolean;
     supportsQualify: boolean;
-    functionInfo: Record<string, FunctionInfo>;
     get udfPrefix(): string;
     quoteTablePath(tableName: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
@@ -36,17 +37,19 @@ export declare class DuckDBDialect extends Dialect {
     sqlSelectAliasAsStruct(alias: string, physicalFieldNames: string[]): string;
     sqlMaybeQuoteIdentifier(identifier: string): string;
     sqlCreateTableAsSelect(_tableName: string, _sql: string): string;
-    getFunctionInfo(functionName: string): FunctionInfo | undefined;
     sqlMeasureTime(from: TimeValue, to: TimeValue, units: string): Expr;
     sqlNow(): Expr;
     sqlTrunc(qi: QueryInfo, sqlTime: TimeValue, units: TimestampUnit): Expr;
     sqlExtract(qi: QueryInfo, from: TimeValue, units: ExtractUnit): Expr;
     sqlAlterTime(op: '+' | '-', expr: TimeValue, n: Expr, timeframe: DateUnit): Expr;
     sqlCast(qi: QueryInfo, cast: TypecastFragment): Expr;
-    sqlRegexpMatch(expr: Expr, regexp: string): Expr;
+    sqlRegexpMatch(expr: Expr, regexp: Expr): Expr;
     sqlLiteralTime(qi: QueryInfo, timeString: string, type: TimeFieldType, timezone: string | undefined): string;
     sqlSumDistinct(key: string, value: string, funcName: string): string;
+    sqlAggDistinct(key: string, values: string[], func: (valNames: string[]) => string): string;
     sqlSampleTable(tableSQL: string, sample: Sampling | undefined): string;
     sqlOrderBy(orderTerms: string[]): string;
     sqlLiteralString(literal: string): string;
+    sqlLiteralRegexp(literal: string): string;
+    getGlobalFunctionDef(name: string): DialectFunctionOverloadDef[] | undefined;
 }

package/dist/dialect/{duckdb.js → duckdb/duckdb.js}

@@ -23,9 +23,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBDialect = void 0;
-const malloy_types_1 = require("../model/malloy_types");
-const utils_1 = require("../model/utils");
-const dialect_1 = require("./dialect");
+const malloy_types_1 = require("../../model/malloy_types");
+const utils_1 = require("../../model/utils");
+const functions_1 = require("./functions");
+const dialect_1 = require("../dialect");
 // need to refactor runSQL to take a SQLBlock instead of just a sql string.
 const hackSplitComment = '-- hack: split on this';
 const castMap = {
@@ -48,12 +49,10 @@ class DuckDBDialect extends dialect_1.Dialect {
         this.unnestWithNumbers = true;
         this.defaultSampling = { rows: 50000 };
         this.supportUnnestArrayAgg = true;
+        this.supportsAggDistinct = true;
         this.supportsCTEinCoorelatedSubQueries = true;
         this.dontUnionIndex = true;
         this.supportsQualify = true;
-        this.functionInfo = {
-            'concat': { returnType: 'string' },
-        };
     }
     // hack until they support temporary macros.
     get udfPrefix() {
@@ -187,9 +186,6 @@ class DuckDBDialect extends dialect_1.Dialect {
     sqlCreateTableAsSelect(_tableName, _sql) {
         throw new Error('Not implemented Yet');
     }
-    getFunctionInfo(functionName) {
-        return this.functionInfo[functionName];
-    }
     sqlMeasureTime(from, to, units) {
         let lVal = from.value;
         let rVal = to.value;
@@ -291,6 +287,16 @@ class DuckDBDialect extends dialect_1.Dialect {
       )
     )`;
     }
+    sqlAggDistinct(key, values, func) {
+        return `(
+      SELECT ${func(values.map((v, i) => `a.val${i}`))} as value
+      FROM (
+        SELECT UNNEST(list(distinct {key:${key}, ${values
+            .map((v, i) => `val${i}: ${v}`)
+            .join(',')}})) a
+      )
+    )`;
+    }
     // sqlSumDistinct(key: string, value: string): string {
     //   const _factor = 32;
     //   const precision = 0.000001;
@@ -320,6 +326,12 @@ class DuckDBDialect extends dialect_1.Dialect {
     sqlLiteralString(literal) {
         return "'" + literal.replace(/'/g, "''") + "'";
     }
+    sqlLiteralRegexp(literal) {
+        return "'" + literal.replace(/'/g, "''") + "'";
+    }
+    getGlobalFunctionDef(name) {
+        return functions_1.DUCKDB_FUNCTIONS.get(name);
+    }
 }
 exports.DuckDBDialect = DuckDBDialect;
 //# sourceMappingURL=duckdb.js.map

package/dist/dialect/duckdb/functions/byte_length.d.ts

@@ -0,0 +1,2 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare function fnByteLength(): DialectFunctionOverloadDef[];

package/dist/dialect/duckdb/functions/byte_length.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnByteLength = void 0;
+const util_1 = require("../../functions/util");
+function fnByteLength() {
+    return [
+        (0, util_1.overload)((0, util_1.minScalar)('number'), [(0, util_1.param)('value', (0, util_1.anyExprType)('string'))], (0, util_1.sql) `(BIT_LENGTH(${(0, util_1.arg)('value')}) / 8)`),
+    ];
+}
+exports.fnByteLength = fnByteLength;
+//# sourceMappingURL=byte_length.js.map

package/dist/dialect/duckdb/functions/div.d.ts

@@ -0,0 +1,2 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare function fnDiv(): DialectFunctionOverloadDef[];

package/dist/dialect/duckdb/functions/div.js

@@ -0,0 +1,38 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnDiv = void 0;
+const util_1 = require("../../functions/util");
+function fnDiv() {
+    const dividend = (0, util_1.makeParam)('dividend', (0, util_1.anyExprType)('number'));
+    const divisor = (0, util_1.makeParam)('divisor', (0, util_1.anyExprType)('number'));
+    return [
+        (0, util_1.overload)((0, util_1.minScalar)('number'), [dividend.param, divisor.param], 
+        // TODO In DuckDB 0.8 there is a new // operator which does integer division.
+        // When we upgrade, we should switch this to use that instead.
+        (0, util_1.sql) `CASE WHEN ${dividend.arg} / ${divisor.arg} < 0 THEN CEIL(${dividend.arg} / ${divisor.arg}) ELSE FLOOR(${dividend.arg} / ${divisor.arg}) END`),
+    ];
+}
+exports.fnDiv = fnDiv;
+//# sourceMappingURL=div.js.map

package/dist/dialect/duckdb/functions/duckdb_functions.d.ts

@@ -0,0 +1 @@
+export declare const DUCKDB_FUNCTIONS: import("../../functions/function_map").FunctionMap;

package/dist/dialect/duckdb/functions/duckdb_functions.js

@@ -0,0 +1,52 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DUCKDB_FUNCTIONS = void 0;
+const functions_1 = require("../../functions");
+const byte_length_1 = require("./byte_length");
+const div_1 = require("./div");
+const ends_with_1 = require("./ends_with");
+const greatest_and_least_1 = require("./greatest_and_least");
+const is_inf_1 = require("./is_inf");
+const is_nan_1 = require("./is_nan");
+const log_1 = require("./log");
+const rand_1 = require("./rand");
+const replace_1 = require("./replace");
+const trunc_1 = require("./trunc");
+const unicode_1 = require("./unicode");
+exports.DUCKDB_FUNCTIONS = functions_1.FUNCTIONS.clone();
+exports.DUCKDB_FUNCTIONS.add('trunc', trunc_1.fnTrunc);
+exports.DUCKDB_FUNCTIONS.add('rand', rand_1.fnRand);
+exports.DUCKDB_FUNCTIONS.add('is_nan', is_nan_1.fnIsNan);
+exports.DUCKDB_FUNCTIONS.add('is_inf', is_inf_1.fnIsInf);
+exports.DUCKDB_FUNCTIONS.add('greatest', greatest_and_least_1.fnGreatest);
+exports.DUCKDB_FUNCTIONS.add('least', greatest_and_least_1.fnLeast);
+exports.DUCKDB_FUNCTIONS.add('div', div_1.fnDiv);
+exports.DUCKDB_FUNCTIONS.add('byte_length', byte_length_1.fnByteLength);
+exports.DUCKDB_FUNCTIONS.add('unicode', unicode_1.fnUnicode);
+exports.DUCKDB_FUNCTIONS.add('replace', replace_1.fnReplace);
+exports.DUCKDB_FUNCTIONS.add('ends_with', ends_with_1.fnEndsWith);
+exports.DUCKDB_FUNCTIONS.add('log', log_1.fnLog);
+exports.DUCKDB_FUNCTIONS.seal();
+//# sourceMappingURL=duckdb_functions.js.map

package/dist/dialect/duckdb/functions/ends_with.d.ts

@@ -0,0 +1,2 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare function fnEndsWith(): DialectFunctionOverloadDef[];

package/dist/dialect/duckdb/functions/ends_with.js

@@ -0,0 +1,35 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnEndsWith = void 0;
+const util_1 = require("../../functions/util");
+function fnEndsWith() {
+    const value = (0, util_1.makeParam)('value', (0, util_1.anyExprType)('string'));
+    const suffix = (0, util_1.makeParam)('suffix', (0, util_1.anyExprType)('string'));
+    return [
+        (0, util_1.overload)((0, util_1.minScalar)('boolean'), [value.param, suffix.param], (0, util_1.sql) `COALESCE(SUFFIX(${value.arg}, ${suffix.arg}), false)`),
+    ];
+}
+exports.fnEndsWith = fnEndsWith;
+//# sourceMappingURL=ends_with.js.map

package/dist/dialect/duckdb/functions/greatest_and_least.d.ts

@@ -0,0 +1,3 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare const fnGreatest: () => DialectFunctionOverloadDef[];
+export declare const fnLeast: () => DialectFunctionOverloadDef[];

package/dist/dialect/duckdb/functions/greatest_and_least.js

@@ -0,0 +1,58 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnLeast = exports.fnGreatest = void 0;
+const util_1 = require("../../functions/util");
+const types = [
+    'string',
+    'number',
+    'timestamp',
+    'date',
+    'json',
+];
+function greatestOrLeast(fn) {
+    return types.map(type => (0, util_1.overload)((0, util_1.minScalar)(type), [(0, util_1.params)('values', (0, util_1.anyExprType)(type))], 
+    // TODO create a way for a function spec to map SQL to each arg before spreading, or something like that
+    // Currently this SQL is pretty nasty, and we would rather write
+    // CASE WHEN arg1 IS NULL OR arg2 is NULL ... OR argN is NULL THEN NULL ELSE GREATEST(arg1, arg2, ..., argN) END
+    // But we can't do that with today's function spec.
+    // That might look someday like
+    /*
+      sqlFragment(
+        'CASE WHEN ',
+        spread(map(arg('values'), '$ARG IS NULL'), ' OR '),
+        `THEN NULL ELSE ${fn}(`,
+        spread(arg('values')),
+        ') END'
+      ),
+     */
+    [
+        (0, util_1.sqlFragment)('CASE WHEN LEN(LIST_FILTER([', (0, util_1.spread)((0, util_1.arg)('values')), `], x -> x is null)) > 0 THEN NULL ELSE ${fn}(`, (0, util_1.spread)((0, util_1.arg)('values')), ') END'),
+    ]));
+}
+const fnGreatest = () => greatestOrLeast('GREATEST');
+exports.fnGreatest = fnGreatest;
+const fnLeast = () => greatestOrLeast('LEAST');
+exports.fnLeast = fnLeast;
+//# sourceMappingURL=greatest_and_least.js.map

package/dist/dialect/duckdb/functions/index.d.ts

@@ -0,0 +1 @@
+export { DUCKDB_FUNCTIONS } from './duckdb_functions';

package/dist/dialect/duckdb/functions/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DUCKDB_FUNCTIONS = void 0;
+var duckdb_functions_1 = require("./duckdb_functions");
+Object.defineProperty(exports, "DUCKDB_FUNCTIONS", { enumerable: true, get: function () { return duckdb_functions_1.DUCKDB_FUNCTIONS; } });
+//# sourceMappingURL=index.js.map

package/dist/dialect/duckdb/functions/is_inf.d.ts

@@ -0,0 +1,2 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare function fnIsInf(): DialectFunctionOverloadDef[];

package/dist/dialect/duckdb/functions/is_inf.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnIsInf = void 0;
+const util_1 = require("../../functions/util");
+function fnIsInf() {
+    return [
+        (0, util_1.overload)((0, util_1.minScalar)('boolean'), [(0, util_1.param)('value', (0, util_1.anyExprType)('number'))], (0, util_1.sql) `COALESCE(ISINF(${(0, util_1.arg)('value')}), false)`),
+    ];
+}
+exports.fnIsInf = fnIsInf;
+//# sourceMappingURL=is_inf.js.map

package/dist/dialect/duckdb/functions/is_nan.d.ts

@@ -0,0 +1,2 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare function fnIsNan(): DialectFunctionOverloadDef[];

package/dist/dialect/duckdb/functions/is_nan.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnIsNan = void 0;
+const util_1 = require("../../functions/util");
+function fnIsNan() {
+    return [
+        (0, util_1.overload)((0, util_1.minScalar)('boolean'), [(0, util_1.param)('value', (0, util_1.anyExprType)('number'))], (0, util_1.sql) `COALESCE(ISNAN(${(0, util_1.arg)('value')}), false)`),
+    ];
+}
+exports.fnIsNan = fnIsNan;
+//# sourceMappingURL=is_nan.js.map

package/dist/dialect/duckdb/functions/log.d.ts

@@ -0,0 +1,2 @@
+import { DialectFunctionOverloadDef } from '../../functions/util';
+export declare function fnLog(): DialectFunctionOverloadDef[];