Add string_agg function, partition_by and order_by for analytic functions, and partition_by and limit for string_agg

packages/malloy-syntax-highlight/grammars/malloy/malloy.monarch.ts

@@ -220,6 +220,7 @@ export const monarch: Monaco.IMonarchLanguage = {
       [/\bmeasure\b/, 'keyword.control.measure'],
       [/\bnest\b/, 'keyword.control.nest'],
       [/\border_by\b/, 'keyword.control.order_by'],
+      [/\bpartition_by\b/, 'keyword.control.partition_by'],
       [/\bprimary_key\b/, 'keyword.control.primary_key'],
       [/\bproject\b/, 'keyword.control.project'],
       [/\bquery\b/, 'keyword.control.query'],

packages/malloy-syntax-highlight/grammars/malloy/malloy.tmGrammar.json

@@ -446,6 +446,10 @@
           "match": "(?i)\\border_by\\b",
           "name": "keyword.control.order_by"
         },
+        {
+          "match": "(?i)\\bpartition_by\\b",
+          "name": "keyword.control.partition_by"
+        },
         {
           "match": "(?i)\\bprimary_key\\b",
           "name": "keyword.control.primary_key"

packages/malloy/src/dialect/dialect_map.ts

@@ -110,14 +110,24 @@ export function getDialectFunction(name: string): FunctionDef | undefined {
           if (!returnEqual(overload, existingOverload)) {
             throw new Error('params match but return types differ!');
           }
-          existingOverload.dialect[dialect.name] = overload.e;
+          existingOverload.dialect[dialect.name] = {
+            e: overload.e,
+            supportsOrderBy: overload.supportsOrderBy,
+            supportsLimit: overload.supportsLimit,
+          };
           handled = true;
         }
         if (!handled) {
           func.overloads.push({
             returnType: overload.returnType,
             params: overload.params,
-            dialect: {[dialect.name]: overload.e},
+            dialect: {
+              [dialect.name]: {
+                e: overload.e,
+                supportsOrderBy: overload.supportsOrderBy,
+                supportsLimit: overload.supportsLimit,
+              },
+            },
             needsWindowOrderBy: overload.needsWindowOrderBy,
             between: overload.between,
             isSymmetric: overload.isSymmetric,

packages/malloy/src/dialect/functions/all_functions.ts

@@ -79,6 +79,7 @@ import {
 import {fnAvgRolling} from './avg_moving';
 import {FunctionMap} from './function_map';
 import {fnCoalesce} from './coalesce';
+import {fnStringAgg, fnStringAggDistinct} from './string_agg';
 import {
   fnSqlBoolean,
   fnSqlDate,
@@ -146,6 +147,8 @@ FUNCTIONS.add('exp', fnExp);
 
 // Aggregate functions
 FUNCTIONS.add('stddev', fnStddev);
+FUNCTIONS.add('string_agg', fnStringAgg);
+FUNCTIONS.add('string_agg_distinct', fnStringAggDistinct);
 
 // Analytic functions
 FUNCTIONS.add('row_number', fnRowNumber);

packages/malloy/src/dialect/functions/string_agg.ts

@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+import {Fragment} from '../../model';
+import {
+  overload,
+  minAggregate,
+  maxScalar,
+  sql,
+  DialectFunctionOverloadDef,
+  makeParam,
+  literal,
+} from './util';
+
+export function fnStringAgg(): DialectFunctionOverloadDef[] {
+  const value = makeParam('value', maxScalar('string'));
+  const separator = makeParam('separator', literal(maxScalar('string')));
+  const orderBy: Fragment = {type: 'aggregate_order_by'};
+  return [
+    overload(
+      minAggregate('string'),
+      [value.param],
+      sql`STRING_AGG(${value.arg}${orderBy})`,
+      {supportsOrderBy: true}
+    ),
+    overload(
+      minAggregate('string'),
+      [value.param, separator.param],
+      sql`STRING_AGG(${value.arg}, ${separator.arg}${orderBy})`,
+      {supportsOrderBy: true}
+    ),
+  ];
+}
+
+export function fnStringAggDistinct(): DialectFunctionOverloadDef[] {
+  const value = makeParam('value', maxScalar('string'));
+  const separator = makeParam('separator', literal(maxScalar('string')));
+  const orderBy: Fragment = {type: 'aggregate_order_by'};
+  return [
+    overload(
+      minAggregate('string'),
+      [value.param],
+      sql`STRING_AGG(DISTINCT ${value.arg}${orderBy})`,
+      {isSymmetric: true, supportsOrderBy: true}
+    ),
+    overload(
+      minAggregate('string'),
+      [value.param, separator.param],
+      sql`STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy})`,
+      {isSymmetric: true, supportsOrderBy: true}
+    ),
+  ];
+}

packages/malloy/src/dialect/functions/util.ts

@@ -37,6 +37,8 @@ export interface DialectFunctionOverloadDef {
   e: Expr;
   needsWindowOrderBy?: boolean;
   isSymmetric?: boolean;
+  supportsOrderBy?: boolean;
+  supportsLimit?: boolean;
   between: {preceding: number | string; following: number | string} | undefined;
 }
 
@@ -213,6 +215,9 @@ export function overload(
   options?: {
     needsWindowOrderBy?: boolean;
     between?: {preceding: number | string; following: number | string};
+    isSymmetric?: boolean;
+    supportsLimit?: boolean;
+    supportsOrderBy?: boolean;
   }
 ): DialectFunctionOverloadDef {
   return {
@@ -221,5 +226,8 @@ export function overload(
     e,
     needsWindowOrderBy: options?.needsWindowOrderBy,
     between: options?.between,
+    isSymmetric: options?.isSymmetric,
+    supportsOrderBy: options?.supportsOrderBy,
+    supportsLimit: options?.supportsLimit,
   };
 }

packages/malloy/src/dialect/postgres/functions/postgres_functions.ts

@@ -22,6 +22,7 @@
  */
 
 import {FUNCTIONS} from '../../functions';
+import {fnStringAgg, fnStringAggDistinct} from './string_agg';
 import {fnByteLength} from './byte_length';
 import {fnEndsWith} from './ends_with';
 import {fnGreatest, fnLeast} from './greatest_and_least';
@@ -54,5 +55,7 @@ POSTGRES_FUNCTIONS.add('trunc', fnTrunc);
 POSTGRES_FUNCTIONS.add('substr', fnSubstr);
 POSTGRES_FUNCTIONS.add('replace', fnReplace);
 POSTGRES_FUNCTIONS.add('ends_with', fnEndsWith);
+POSTGRES_FUNCTIONS.add('string_agg', fnStringAgg);
+POSTGRES_FUNCTIONS.add('string_agg_distinct', fnStringAggDistinct);
 POSTGRES_FUNCTIONS.add('log', fnLog);
 POSTGRES_FUNCTIONS.seal();

packages/malloy/src/dialect/postgres/functions/string_agg.ts

@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+
+import {Fragment} from '../../../model';
+import {
+  overload,
+  minAggregate,
+  maxScalar,
+  sql,
+  DialectFunctionOverloadDef,
+  makeParam,
+  literal,
+} from '../../functions/util';
+
+export function fnStringAgg(): DialectFunctionOverloadDef[] {
+  const value = makeParam('value', maxScalar('string'));
+  const separator = makeParam('separator', literal(maxScalar('string')));
+  const orderBy: Fragment = {type: 'aggregate_order_by'};
+  return [
+    overload(
+      minAggregate('string'),
+      [value.param],
+      sql`STRING_AGG(${value.arg}, ','${orderBy})`,
+      {supportsOrderBy: true}
+    ),
+    overload(
+      minAggregate('string'),
+      [value.param, separator.param],
+      sql`STRING_AGG(${value.arg}, ${separator.arg}${orderBy})`,
+      {supportsOrderBy: true}
+    ),
+  ];
+}
+
+export function fnStringAggDistinct(): DialectFunctionOverloadDef[] {
+  const value = makeParam('value', maxScalar('string'));
+  const separator = makeParam('separator', literal(maxScalar('string')));
+  const orderBy: Fragment = {type: 'aggregate_order_by'};
+  return [
+    overload(
+      minAggregate('string'),
+      [value.param],
+      sql`STRING_AGG(DISTINCT ${value.arg}, ','${orderBy})`,
+      {isSymmetric: true, supportsOrderBy: true}
+    ),
+    overload(
+      minAggregate('string'),
+      [value.param, separator.param],
+      sql`STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy})`,
+      {isSymmetric: true, supportsOrderBy: true}
+    ),
+  ];
+}

packages/malloy/src/dialect/standardsql/functions/standardsql_functions.ts

@@ -22,10 +22,13 @@
  */
 
 import {FUNCTIONS} from '../../functions';
+import {fnStringAgg, fnStringAggDistinct} from './string_agg';
 import {fnChr} from './chr';
 import {fnPi} from './pi';
 
 export const STANDARDSQL_FUNCTIONS = FUNCTIONS.clone();
 STANDARDSQL_FUNCTIONS.add('pi', fnPi);
 STANDARDSQL_FUNCTIONS.add('chr', fnChr);
+STANDARDSQL_FUNCTIONS.add('string_agg', fnStringAgg);
+STANDARDSQL_FUNCTIONS.add('string_agg_distinct', fnStringAggDistinct);
 STANDARDSQL_FUNCTIONS.seal();

packages/malloy/src/dialect/standardsql/functions/string_agg.ts

@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+import {Fragment} from '../../../model';
+import {
+  overload,
+  minAggregate,
+  maxScalar,
+  sql,
+  DialectFunctionOverloadDef,
+  makeParam,
+  literal,
+} from '../../functions/util';
+
+export function fnStringAgg(): DialectFunctionOverloadDef[] {
+  const value = makeParam('value', maxScalar('string'));
+  const separator = makeParam('separator', literal(maxScalar('string')));
+  const orderBy: Fragment = {type: 'aggregate_order_by'};
+  const limit: Fragment = {type: 'aggregate_limit'};
+  return [
+    overload(
+      minAggregate('string'),
+      [value.param],
+      sql`STRING_AGG(${value.arg}${orderBy}${limit})`,
+      {supportsOrderBy: true, supportsLimit: true}
+    ),
+    overload(
+      minAggregate('string'),
+      [value.param, separator.param],
+      sql`STRING_AGG(${value.arg}, ${separator.arg}${orderBy}${limit})`,
+      {supportsOrderBy: true, supportsLimit: true}
+    ),
+  ];
+}
+
+export function fnStringAggDistinct(): DialectFunctionOverloadDef[] {
+  const value = makeParam('value', maxScalar('string'));
+  const separator = makeParam('separator', literal(maxScalar('string')));
+  const orderBy: Fragment = {type: 'aggregate_order_by'};
+  const limit: Fragment = {type: 'aggregate_limit'};
+  return [
+    overload(
+      minAggregate('string'),
+      [value.param],
+      sql`STRING_AGG(DISTINCT ${value.arg}${orderBy}${limit})`,
+      {isSymmetric: true, supportsOrderBy: true, supportsLimit: true}
+    ),
+    overload(
+      minAggregate('string'),
+      [value.param, separator.param],
+      sql`STRING_AGG(DISTINCT ${value.arg}, ${separator.arg}${orderBy}${limit})`,
+      {isSymmetric: true, supportsOrderBy: true, supportsLimit: true}
+    ),
+  ];
+}