@malloydata/malloy 0.0.296 → 0.0.297

package/dist/api/asynchronous.js

@@ -45,16 +45,20 @@ exports.compileQuery = compileQuery;
 exports.runQuery = runQuery;
 const Core = __importStar(require("./core"));
 const util_1 = require("./util");
+const timing_1 = require("../timing");
 async function fetchNeeds(needs, fetchers) {
     var _a, _b, _c, _d, _e, _f, _g;
     var _h, _j;
+    const timer = new timing_1.Timer('fetch_needs');
     if (needs === undefined) {
         throw new Error("Expected compiler to have needs because it didn't return a result");
     }
     const result = {};
     if (needs.connections) {
         for (const connection of needs.connections) {
+            const t = new timing_1.Timer('lookup_connection');
             const info = await fetchers.connections.lookupConnection(connection.name);
+            timer.contribute([t.stop()]);
             (_a = result.connections) !== null && _a !== void 0 ? _a : (result.connections = []);
             result.connections.push({
                 ...connection,
@@ -65,7 +69,9 @@ async function fetchNeeds(needs, fetchers) {
     if (needs.files) {
         for (const file of needs.files) {
             // TODO handle checking if the cache has the file...
+            const t = new timing_1.Timer('read_url');
             const info = await fetchers.urls.readURL(new URL(file.url));
+            timer.contribute([t.stop()]);
             (_b = result.files) !== null && _b !== void 0 ? _b : (result.files = []);
             if (typeof info === 'string') {
                 result.files.push({
@@ -89,12 +95,16 @@ async function fetchNeeds(needs, fetchers) {
             tableSchemasByConnection[tableSchema.connection_name].push(tableSchema);
         }
         for (const connectionName in tableSchemasByConnection) {
+            const t1 = new timing_1.Timer('lookup_connection');
             const connection = await fetchers.connections.lookupConnection(connectionName);
+            timer.contribute([t1.stop()]);
             const tableNames = tableSchemasByConnection[connectionName].map(t => t.name);
+            const t2 = new timing_1.Timer('fetch_table_schemas');
             const schemas = await Promise.all(tableNames.map(async (tableName) => ({
                 name: tableName,
                 schema: await connection.fetchSchemaForTable(tableName),
             })));
+            timer.contribute([t2.stop()]);
             (_e = result.table_schemas) !== null && _e !== void 0 ? _e : (result.table_schemas = []);
             for (const schema of schemas) {
                 result.table_schemas.push({
@@ -112,12 +122,16 @@ async function fetchNeeds(needs, fetchers) {
             sqlSchemasByConnectionName[sqlSchema.connection_name].push(sqlSchema);
         }
         for (const connectionName in sqlSchemasByConnectionName) {
+            const t1 = new timing_1.Timer('lookup_connection');
             const connection = await fetchers.connections.lookupConnection(connectionName);
+            timer.contribute([t1.stop()]);
             const sqlQueries = sqlSchemasByConnectionName[connectionName].map(t => t.sql);
+            const t2 = new timing_1.Timer('lookup_sql_schemas');
             const schemas = await Promise.all(sqlQueries.map(async (sql) => ({
                 sql,
                 schema: await connection.fetchSchemaForSQLQuery(sql),
             })));
+            timer.contribute([t2.stop()]);
             (_g = result.sql_schemas) !== null && _g !== void 0 ? _g : (result.sql_schemas = []);
             for (const schema of schemas) {
                 result.sql_schemas.push({
@@ -128,49 +142,60 @@ async function fetchNeeds(needs, fetchers) {
             }
         }
     }
-    return result;
+    return { needs: result, timingInfo: timer.stop() };
 }
 async function compileModel(request, fetchers) {
+    const timer = new timing_1.Timer('compile_model');
     const state = Core.newCompileModelState(request);
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileModel(state);
+        timer.incorporate(result.timing_info);
         if (result.model || Core.hasErrors(result.logs)) {
-            return result;
+            return { ...result, timing_info: timer.stop() };
         }
-        const needs = await fetchNeeds(result.compiler_needs, fetchers);
+        const { needs, timingInfo } = await fetchNeeds(result.compiler_needs, fetchers);
+        timer.incorporate(timingInfo);
         Core.updateCompileModelState(state, needs);
     }
 }
 async function compileSource(request, fetchers) {
+    const timer = new timing_1.Timer('compile_source');
     const state = Core.newCompileSourceState(request);
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileSource(state, request.name);
+        timer.incorporate(result.timing_info);
         if (result.source || Core.hasErrors(result.logs)) {
-            return result;
+            return { ...result, timing_info: timer.stop() };
         }
-        const needs = await fetchNeeds(result.compiler_needs, fetchers);
+        const { needs, timingInfo } = await fetchNeeds(result.compiler_needs, fetchers);
+        timer.incorporate(timingInfo);
         Core.updateCompileModelState(state, needs);
     }
 }
 async function compileQuery(request, fetchers) {
+    const timer = new timing_1.Timer('compile_query');
     const state = Core.newCompileQueryState(request);
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileQuery(state);
+        timer.incorporate(result.timing_info);
         if (result.result || Core.hasErrors(result.logs)) {
-            return result;
+            return { ...result, timing_info: timer.stop() };
         }
-        const needs = await fetchNeeds(result.compiler_needs, fetchers);
+        const { needs, timingInfo } = await fetchNeeds(result.compiler_needs, fetchers);
+        timer.incorporate(timingInfo);
         Core.updateCompileModelState(state, needs);
     }
 }
 async function runQuery(request, fetchers) {
     var _a, _b;
+    const timer = new timing_1.Timer('run_query');
     const compiled = await compileQuery(request, fetchers);
+    timer.incorporate(compiled.timing_info);
     if (compiled.result === undefined) {
-        return compiled;
+        return { ...compiled, timing_info: timer.stop() };
     }
     const defaultURL = request.model_url;
     if (compiled.result.sql === undefined) {
@@ -187,14 +212,19 @@ async function runQuery(request, fetchers) {
         };
     }
     try {
+        const t1 = new timing_1.Timer('lookup_connection');
         const connection = await fetchers.connections.lookupConnection(compiled.result.connection_name);
+        timer.contribute([t1.stop()]);
+        const t2 = new timing_1.Timer('run_sql');
         const data = await connection.runSQL(compiled.result.sql, compiled.result.schema);
+        timer.contribute([t2.stop()]);
         return {
             ...compiled,
             result: {
                 ...compiled.result,
                 data,
             },
+            timing_info: timer.stop(),
         };
     }
     catch (error) {
@@ -209,6 +239,7 @@ async function runQuery(request, fetchers) {
                     range: util_1.DEFAULT_LOG_RANGE,
                 },
             ],
+            timing_info: timer.stop(),
         };
     }
 }

package/dist/api/core.d.ts

@@ -7,16 +7,19 @@ export type CompileResponse = {
     modelDef: ModelDef;
     compilerNeeds?: undefined;
     logs?: LogMessage[];
+    timingInfo: Malloy.TimingInfo;
 } | {
     model?: undefined;
     modelDef?: undefined;
     compilerNeeds: Malloy.CompilerNeeds;
     logs?: LogMessage[];
+    timingInfo: Malloy.TimingInfo;
 } | {
     model?: undefined;
     modelDef?: undefined;
     compilerNeeds?: undefined;
     logs: LogMessage[];
+    timingInfo: Malloy.TimingInfo;
 };
 export declare function compileQuery(request: Malloy.CompileQueryRequest, state?: CompileQueryState): Malloy.CompileQueryResponse;
 export interface CompileModelState {

package/dist/api/core.js

@@ -59,6 +59,7 @@ const sql_block_1 = require("../model/sql_block");
 const annotation_1 = require("../annotation");
 const malloy_tag_1 = require("@malloydata/malloy-tag");
 const util_1 = require("./util");
+const timing_1 = require("../timing");
 // TODO find where this should go...
 function tableKey(connectionName, tablePath) {
     return `${connectionName}:${tablePath}`;
@@ -299,12 +300,15 @@ function statedCompileSource(state, name) {
     return extractSource(_statedCompileModel(state), name, state.translator.sourceURL);
 }
 function _statedCompileModel(state) {
+    const timer = new timing_1.Timer('compile_model');
     let extendingModel = undefined;
+    let extendingResult = undefined;
     if (state.extending) {
         if (!state.extending.done) {
-            const extendingResult = _statedCompileModel(state.extending);
+            extendingResult = _statedCompileModel(state.extending);
+            timer.contribute([extendingResult.timingInfo]);
             if (!state.extending.done) {
-                return extendingResult;
+                return { ...extendingResult, timingInfo: timer.stop() };
             }
         }
         extendingModel = state.extending.translator.modelDef;
@@ -312,15 +316,20 @@ function _statedCompileModel(state) {
     if (!state.hasSource) {
         return {
             compilerNeeds: convertCompilerNeeds(undefined, [state.translator.sourceURL], undefined),
+            timingInfo: timer.stop(),
         };
     }
     const result = state.translator.translate(extendingModel);
+    timer.incorporate(result.timingInfo);
     if (result.final) {
         state.done = true;
+        const timingInfo = timer.stop();
         if (result.modelDef) {
+            const model = (0, to_stable_1.modelDefToModelInfo)(result.modelDef);
             return {
-                model: (0, to_stable_1.modelDefToModelInfo)(result.modelDef),
+                model,
                 modelDef: result.modelDef,
+                timingInfo,
             };
         }
         else {
@@ -329,18 +338,24 @@ function _statedCompileModel(state) {
             }
             return {
                 logs: result.problems,
+                timingInfo,
             };
         }
     }
     else {
         const compilerNeeds = convertCompilerNeeds(result.compileSQL, result.urls, result.tables);
-        return { compilerNeeds, logs: result.problems };
+        const timingInfo = timer.stop();
+        return { compilerNeeds, logs: result.problems, timingInfo };
     }
 }
 function wrapResponse(response, defaultURL) {
     const logs = response.logs ? (0, util_1.mapLogs)(response.logs, defaultURL) : undefined;
     if (response.compilerNeeds) {
-        return { compiler_needs: response.compilerNeeds, logs };
+        return {
+            compiler_needs: response.compilerNeeds,
+            logs,
+            timing_info: response.timingInfo,
+        };
     }
     else {
         let translations = undefined;
@@ -352,7 +367,12 @@ function wrapResponse(response, defaultURL) {
                 },
             ];
         }
-        return { model: response.model, logs, translations };
+        return {
+            model: response.model,
+            logs,
+            translations,
+            timing_info: response.timingInfo,
+        };
     }
 }
 function _compileModel(modelURL, compilerNeeds, extendURL, state) {
@@ -383,12 +403,17 @@ function extractSource(result, name, defaultURL) {
                         range: util_1.DEFAULT_LOG_RANGE,
                     },
                 ],
+                timing_info: result.timingInfo,
             };
         }
-        return { source, logs };
+        return { source, logs, timing_info: result.timingInfo };
     }
     else {
-        return { compiler_needs: result.compilerNeeds, logs };
+        return {
+            compiler_needs: result.compilerNeeds,
+            logs,
+            timing_info: result.timingInfo,
+        };
     }
 }
 function hasErrors(log) {
@@ -416,7 +441,9 @@ function newCompileQueryState(request) {
 }
 function statedCompileQuery(state) {
     var _a, _b;
+    const timer = new timing_1.Timer('compile_query');
     const result = _statedCompileModel(state);
+    timer.incorporate(result.timingInfo);
     // TODO this can expose the internal URL... is there a better way to handle URL-less errors from the compiler?
     const defaultURL = state.translator.sourceURL;
     const logs = result.logs ? (0, util_1.mapLogs)(result.logs, defaultURL) : undefined;
@@ -424,6 +451,7 @@ function statedCompileQuery(state) {
         const queries = result.modelDef.queryList;
         if (queries.length === 0) {
             return {
+                timing_info: timer.stop(),
                 logs: [
                     ...(logs !== null && logs !== void 0 ? logs : []),
                     {
@@ -440,10 +468,12 @@ function statedCompileQuery(state) {
         const schema = result.model.anonymous_queries[index].schema;
         const annotations = (_a = result.model.anonymous_queries[index].annotations) !== null && _a !== void 0 ? _a : [];
         try {
+            const sqlTimer = new timing_1.Timer('generate_sql');
             const queryModel = new model_1.QueryModel(result.modelDef);
             const translatedQuery = queryModel.compileQuery(query, {
                 defaultRowLimit: state.defaultRowLimit,
             });
+            timer.contribute([sqlTimer.stop()]);
             const modelAnnotations = (0, annotation_1.annotationToTaglines)(result.modelDef.annotation).map(l => ({
                 value: l,
             }));
@@ -486,6 +516,7 @@ function statedCompileQuery(state) {
                         .toString(),
                 });
             }
+            const timingInfo = timer.stop();
             return {
                 result: {
                     sql: translatedQuery.sql,
@@ -497,9 +528,11 @@ function statedCompileQuery(state) {
                     source_annotations: annotationsOrUndefined(sourceAnnotations),
                 },
                 default_row_limit_added: translatedQuery.defaultRowLimitAdded,
+                timing_info: timingInfo,
             };
         }
         catch (error) {
+            const timingInfo = timer.stop();
             return {
                 logs: [
                     ...(logs !== null && logs !== void 0 ? logs : []),
@@ -510,11 +543,16 @@ function statedCompileQuery(state) {
                         range: util_1.DEFAULT_LOG_RANGE,
                     },
                 ],
+                timing_info: timingInfo,
             };
         }
     }
     else {
-        return { compiler_needs: result.compilerNeeds, logs };
+        return {
+            compiler_needs: result.compilerNeeds,
+            logs,
+            timing_info: timer.stop(),
+        };
     }
 }
 function annotationsOrUndefined(annotations) {

package/dist/api/sessioned.js

@@ -45,6 +45,7 @@ exports.compileQuery = compileQuery;
 const Malloy = __importStar(require("@malloydata/malloy-interfaces"));
 const Core = __importStar(require("./core"));
 const uuid_1 = require("uuid");
+const timing_1 = require("../timing");
 function sessionInfosMatch(a, b) {
     if (a.type === 'compile_model') {
         if (b.type !== 'compile_model')
@@ -109,6 +110,7 @@ class SessionManager {
             state,
             expires,
             sessionId: this.newSessionId(),
+            timer: new timing_1.Timer('compile_model'),
         };
     }
     newCompileSourceSession(request, sessionInfo, options) {
@@ -120,6 +122,7 @@ class SessionManager {
             state,
             expires,
             sessionId: this.newSessionId(),
+            timer: new timing_1.Timer('compile_source'),
         };
     }
     newCompileQuerySession(request, sessionInfo, options) {
@@ -131,6 +134,7 @@ class SessionManager {
             state,
             expires,
             sessionId: this.newSessionId(),
+            timer: new timing_1.Timer('compile_query'),
         };
     }
     findCompileModelSession(sessionId, sessionInfo) {
@@ -155,6 +159,10 @@ class SessionManager {
             this.findCompileModelSession(options.session_id, sessionInfo);
         this.purgeExpired({ except: options === null || options === void 0 ? void 0 : options.session_id });
         if (session) {
+            if (session.waitingTimer) {
+                session.timer.contribute([session.waitingTimer.stop()]);
+                session.waitingTimer = undefined;
+            }
             if (options === null || options === void 0 ? void 0 : options.ttl) {
                 session.expires = this.getExpires(options.ttl);
             }
@@ -165,10 +173,21 @@ class SessionManager {
             this.sessions.set(session.sessionId, session);
         }
         const result = Core.statedCompileModel(session.state);
-        if (result.model || this.hasErrors(result.logs)) {
+        session.timer.incorporate(result.timing_info);
+        const done = result.model || this.hasErrors(result.logs);
+        if (done) {
             this.killSession(session.sessionId);
         }
-        return { ...result, session_id: session.sessionId };
+        // TODO not really using it as "stop", but more like "current"
+        const timingInfo = session.timer.stop();
+        if (!done) {
+            session.waitingTimer = new timing_1.Timer('session_wait');
+        }
+        return {
+            ...result,
+            session_id: session.sessionId,
+            timing_info: timingInfo,
+        };
     }
     findCompileSourceSession(sessionId, sessionInfo) {
         const session = this.findSession(sessionId, sessionInfo);
@@ -187,6 +206,10 @@ class SessionManager {
             this.findCompileSourceSession(options.session_id, sessionInfo);
         this.purgeExpired({ except: options === null || options === void 0 ? void 0 : options.session_id });
         if (session) {
+            if (session.waitingTimer) {
+                session.timer.contribute([session.waitingTimer.stop()]);
+                session.waitingTimer = undefined;
+            }
             if (options === null || options === void 0 ? void 0 : options.ttl) {
                 session.expires = this.getExpires(options.ttl);
             }
@@ -197,10 +220,20 @@ class SessionManager {
             this.sessions.set(session.sessionId, session);
         }
         const result = Core.statedCompileSource(session.state, request.name);
-        if (result.source || this.hasErrors(result.logs)) {
+        session.timer.incorporate(result.timing_info);
+        const done = result.source || this.hasErrors(result.logs);
+        if (done) {
             this.killSession(session.sessionId);
         }
-        return { ...result, session_id: session.sessionId };
+        const timingInfo = session.timer.stop();
+        if (!done) {
+            session.waitingTimer = new timing_1.Timer('session_wait');
+        }
+        return {
+            ...result,
+            session_id: session.sessionId,
+            timing_info: timingInfo,
+        };
     }
     findCompileQuerySession(sessionId, sessionInfo) {
         const session = this.findSession(sessionId, sessionInfo);
@@ -220,6 +253,10 @@ class SessionManager {
             this.findCompileQuerySession(options.session_id, sessionInfo);
         this.purgeExpired({ except: options === null || options === void 0 ? void 0 : options.session_id });
         if (session) {
+            if (session.waitingTimer) {
+                session.timer.contribute([session.waitingTimer.stop()]);
+                session.waitingTimer = undefined;
+            }
             if (options === null || options === void 0 ? void 0 : options.ttl) {
                 session.expires = this.getExpires(options.ttl);
             }
@@ -230,10 +267,20 @@ class SessionManager {
             this.sessions.set(session.sessionId, session);
         }
         const result = Core.statedCompileQuery(session.state);
-        if (result.result || this.hasErrors(result.logs)) {
+        session.timer.incorporate(result.timing_info);
+        const done = result.result || this.hasErrors(result.logs);
+        if (done) {
             this.killSession(session.sessionId);
         }
-        return { ...result, session_id: session.sessionId };
+        const timingInfo = session.timer.stop();
+        if (!done) {
+            session.waitingTimer = new timing_1.Timer('session_wait');
+        }
+        return {
+            ...result,
+            session_id: session.sessionId,
+            timing_info: timingInfo,
+        };
     }
 }
 const SESSION_MANAGER = new SessionManager();

package/dist/dialect/trino/dialect_functions.js

@@ -15,7 +15,7 @@ const util_1 = require("../functions/util");
  * So in this file we are experimenting with various ways to define things.
  * The most general and powerful is to write a DefinitionBlueprint or
  * OverloadedDefinitionBlueprint, naming it with the name of the function
- * you want to add, and then to add that name to the dialcect function list.
+ * you want to add, and then to add that name to the dialect function list.
  *
  * Experimentally, there is also a function def which creates a
  * DefinitionBlueprint for you. For simple blueprints, you can use the wrapper
@@ -235,7 +235,7 @@ const hll_accumulate_moving = {
             'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
         },
         impl: {
-            function: 'APPROX_SET',
+            sql: 'APPROX_SET(${value}, 0.0040625)',
             needsWindowOrderBy: true,
             between: { preceding: 'preceding', following: 0 },
         },
@@ -251,7 +251,7 @@ const hll_accumulate_moving = {
             'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
         },
         impl: {
-            function: 'APPROX_SET',
+            sql: 'APPROX_SET(${value}, 0.0040625)',
             needsWindowOrderBy: true,
             between: { preceding: 'preceding', following: 'following' },
         },
@@ -265,7 +265,7 @@ const hll_combine_moving = {
         },
         returns: { calculation: { sql_native: 'hyperloglog' } },
         impl: {
-            function: 'MERGE',
+            sql: 'MERGE(${value})',
             needsWindowOrderBy: true,
             between: { preceding: 'preceding', following: 0 },
         },
@@ -284,32 +284,100 @@ const hll_combine_moving = {
         },
     },
 };
-const hll_estimate_moving = {
-    preceding: {
-        takes: {
-            'value': { sql_native: 'hyperloglog' },
-            'preceding': { literal: 'number' },
-        },
-        returns: { calculation: 'number' },
-        impl: {
-            function: 'CARDINALITY',
-            needsWindowOrderBy: true,
-            between: { preceding: 'preceding', following: 0 },
-        },
+// T-Digest functions for approximate quantile analytics
+const tdigest_agg = {
+    default: {
+        takes: { 'value': { dimension: 'number' } },
+        returns: { measure: { sql_native: 'tdigest' } },
+        impl: { function: 'TDIGEST_AGG' },
+        isSymmetric: true,
     },
-    following: {
+    with_weight: {
+        takes: { 'value': { dimension: 'number' }, 'weight': { dimension: 'number' } },
+        returns: { measure: { sql_native: 'tdigest' } },
+        impl: { function: 'TDIGEST_AGG' },
+        isSymmetric: true,
+    },
+    with_weight_and_compression: {
         takes: {
-            'value': { sql_native: 'hyperloglog' },
-            'preceding': { literal: 'number' },
-            'following': { literal: 'number' },
-        },
-        returns: { calculation: 'number' },
-        impl: {
-            function: 'CARDINALITY',
-            needsWindowOrderBy: true,
-            between: { preceding: 'preceding', following: 'following' },
+            'value': { dimension: 'number' },
+            'weight': { dimension: 'number' },
+            'compression': { literal: 'number' },
         },
+        returns: { measure: { sql_native: 'tdigest' } },
+        impl: { function: 'TDIGEST_AGG' },
+        isSymmetric: true,
+    },
+};
+const merge_tdigest = {
+    takes: { 'tdigest_val': { sql_native: 'tdigest' } },
+    returns: { measure: { sql_native: 'tdigest' } },
+    impl: { function: 'MERGE' },
+    isSymmetric: true,
+};
+const value_at_quantile = {
+    takes: { 'tdigest_val': { sql_native: 'tdigest' }, 'quantile': 'number' },
+    returns: 'number',
+    impl: { function: 'VALUE_AT_QUANTILE' },
+};
+const quantile_at_value = {
+    takes: { 'tdigest_val': { sql_native: 'tdigest' }, 'value': 'number' },
+    returns: 'number',
+    impl: { function: 'QUANTILE_AT_VALUE' },
+};
+const scale_tdigest = {
+    takes: { 'tdigest_val': { sql_native: 'tdigest' }, 'scale_factor': 'number' },
+    returns: { sql_native: 'tdigest' },
+    impl: { function: 'SCALE_TDIGEST' },
+};
+const values_at_quantiles = {
+    takes: {
+        'tdigest_val': { sql_native: 'tdigest' },
+        'quantiles': { array: 'number' },
     },
+    returns: { array: 'number' },
+    impl: { function: 'VALUES_AT_QUANTILES' },
+};
+const trimmed_mean = {
+    takes: {
+        'tdigest_val': { sql_native: 'tdigest' },
+        'lower_quantile': 'number',
+        'upper_quantile': 'number',
+    },
+    returns: 'number',
+    impl: { function: 'TRIMMED_MEAN' },
+};
+const destructure_tdigest = {
+    takes: { 'tdigest_val': { sql_native: 'tdigest' } },
+    returns: {
+        record: {
+            'centroid_means': { array: 'number' },
+            'centroid_weights': { array: 'number' },
+            'min_value': 'number',
+            'max_value': 'number',
+            'sum_value': 'number',
+            'count_value': 'number',
+        },
+    },
+    impl: { function: 'DESTRUCTURE_TDIGEST' },
+};
+const construct_tdigest = {
+    takes: {
+        'centroid_means': { array: 'number' },
+        'centroid_weights': { array: 'number' },
+        'min_value': 'number',
+        'max_value': 'number',
+        'sum_value': 'number',
+        'count_value': 'number',
+        'compression': 'number',
+    },
+    returns: { sql_native: 'tdigest' },
+    impl: { function: 'CONSTRUCT_TDIGEST' },
+};
+const merge_tdigest_array = {
+    takes: { 'tdigest_array': { array: { sql_native: 'tdigest' } } },
+    returns: { sql_native: 'tdigest' },
+    impl: { function: 'MERGE_TDIGEST' },
 };
 /**
  * This map is for functions which exist in both Presto and Trino.
@@ -388,9 +456,6 @@ exports.TRINO_DIALECT_FUNCTIONS = {
         returns: { dimension: { sql_native: 'hyperloglog' } },
         impl: { sql: 'CAST(${value} AS HyperLogLog)' },
     },
-    hll_accumulate_moving,
-    hll_combine_moving,
-    hll_estimate_moving,
     ...(0, util_1.def)('variance', { 'n': 'number' }, { measure: 'number' }),
     // scalar functions
     ...(0, util_1.def)('bitwise_and', { 'val1': 'number', 'val2': 'number' }, 'number'),
@@ -507,38 +572,18 @@ exports.PRESTO_DIALECT_FUNCTIONS = {
             impl: { sql: 'APPROX_SET(${value}, 0.0040625)' },
         },
     },
-    hll_accumulate_moving: {
-        preceding: {
-            takes: {
-                'value': { dimension: T },
-                'preceding': { literal: 'number' },
-            },
-            returns: { calculation: { sql_native: 'hyperloglog' } },
-            generic: {
-                'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
-            },
-            impl: {
-                sql: 'APPROX_SET(${value}, 0.0040625)',
-                needsWindowOrderBy: true,
-                between: { preceding: 'preceding', following: 0 },
-            },
-        },
-        following: {
-            takes: {
-                'value': { dimension: T },
-                'preceding': { literal: 'number' },
-                'following': { literal: 'number' },
-            },
-            returns: { calculation: { sql_native: 'hyperloglog' } },
-            generic: {
-                'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
-            },
-            impl: {
-                sql: 'APPROX_SET(${value}, 0.0040625)',
-                needsWindowOrderBy: true,
-                between: { preceding: 'preceding', following: 'following' },
-            },
-        },
-    },
+    hll_accumulate_moving,
+    hll_combine_moving,
+    // T-Digest functions
+    tdigest_agg,
+    merge_tdigest,
+    value_at_quantile,
+    quantile_at_value,
+    scale_tdigest,
+    values_at_quantiles,
+    trimmed_mean,
+    destructure_tdigest,
+    construct_tdigest,
+    merge_tdigest_array,
 };
 //# sourceMappingURL=dialect_functions.js.map

package/dist/lang/malloy-to-ast.d.ts

@@ -11,6 +11,8 @@ import type { HasString, HasID } from './parse-utils';
 import type { CastType } from '../model';
 import type { AccessModifierLabel, DocumentLocation, DocumentRange, Note } from '../model/malloy_types';
 import { Tag } from '@malloydata/malloy-tag';
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import { Timer } from '../timing';
 declare class ErrorNode extends ast.SourceQueryElement {
     elementType: string;
 }
@@ -30,7 +32,13 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     readonly parseInfo: MalloyParseInfo;
     readonly msgLog: MessageLogger;
     compilerFlags: Tag;
+    readonly timer: Timer;
     constructor(parseInfo: MalloyParseInfo, msgLog: MessageLogger, compilerFlags: Tag);
+    run(): {
+        ast: ast.MalloyElement;
+        compilerFlags: Tag;
+        timingInfo: Malloy.TimingInfo;
+    };
     /**
      * Mostly used to flag a case where the grammar and the type system are
      * no longer in sync. A visitor was written based on a grammar which
@@ -205,6 +213,7 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitImportStatement(pcx: parse.ImportStatementContext): ast.ImportStatement;
     visitDebugExpr(pcx: parse.DebugExprContext): ast.ExpressionDef;
     visitSampleStatement(pcx: parse.SampleStatementContext): ast.SampleProperty;
+    updateCompilerFlags(tags: ast.ModelAnnotation): void;
     visitDocAnnotations(pcx: parse.DocAnnotationsContext): ast.ModelAnnotation;
     visitIgnoredObjectAnnotations(pcx: parse.IgnoredObjectAnnotationsContext): IgnoredElement;
     visitIgnoredModelAnnotations(pcx: parse.IgnoredModelAnnotationsContext): IgnoredElement;

package/dist/lang/malloy-to-ast.js

@@ -68,6 +68,7 @@ const malloy_types_1 = require("../model/malloy_types");
 const malloy_tag_1 = require("@malloydata/malloy-tag");
 const utils_1 = require("./utils");
 const malloy_filter_1 = require("@malloydata/malloy-filter");
+const timing_1 = require("../timing");
 class ErrorNode extends ast.SourceQueryElement {
     constructor() {
         super(...arguments);
@@ -92,10 +93,22 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         this.parseInfo = parseInfo;
         this.msgLog = msgLog;
         this.compilerFlags = compilerFlags;
+        this.timer = new timing_1.Timer('generate_ast');
+        const parseCompilerFlagsTimer = new timing_1.Timer('parse_compiler_flags');
         for (const flag of DEFAULT_COMPILER_FLAGS) {
             const withNewTag = malloy_tag_1.Tag.fromTagLine(flag, 0, this.compilerFlags);
             this.compilerFlags = withNewTag.tag;
         }
+        this.timer.contribute([parseCompilerFlagsTimer.stop()]);
+    }
+    run() {
+        const ast = this.visit(this.parseInfo.root);
+        const compilerFlags = this.compilerFlags;
+        return {
+            ast,
+            compilerFlags,
+            timingInfo: this.timer.stop(),
+        };
     }
     /**
      * Mostly used to flag a case where the grammar and the type system are
@@ -1254,6 +1267,11 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const enabled = pcx.sampleSpec().TRUE() !== undefined;
         return new ast.SampleProperty({ enable: enabled });
     }
+    updateCompilerFlags(tags) {
+        const parseCompilerFlagsTimer = new timing_1.Timer('parse_compiler_flags');
+        this.compilerFlags = tags.getCompilerFlags(this.compilerFlags, this.msgLog);
+        this.timer.contribute([parseCompilerFlagsTimer.stop()]);
+    }
     visitDocAnnotations(pcx) {
         const allNotes = pcx.DOC_ANNOTATION().map(note => {
             return {
@@ -1262,7 +1280,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
             };
         });
         const tags = new ast.ModelAnnotation(allNotes);
-        this.compilerFlags = tags.getCompilerFlags(this.compilerFlags, this.msgLog);
+        this.updateCompilerFlags(tags);
         return tags;
     }
     visitIgnoredObjectAnnotations(pcx) {

package/dist/lang/parse-malloy.d.ts

@@ -4,7 +4,7 @@ import { BaseMessageLogger } from './parse-log';
 import type { ZoneData } from './zone';
 import { Zone } from './zone';
 import { ReferenceList } from './reference-list';
-import type { ASTResponse, CompletionsResponse, DataRequestResponse, ProblemResponse, FatalResponse, FinalResponse, HelpContextResponse, MetadataResponse, ModelDataRequest, NeedURLData, TranslateResponse, ModelAnnotationResponse, TablePathResponse } from './translate-response';
+import type { ResponseBase, ASTResponse, CompletionsResponse, DataRequestResponse, ProblemResponse, FatalResponse, FinalResponse, HelpContextResponse, MetadataResponse, ModelDataRequest, NeedURLData, TranslateResponse, ModelAnnotationResponse, TablePathResponse } from './translate-response';
 import { Tag } from '@malloydata/malloy-tag';
 import type { MalloyParseInfo } from './malloy-parse-info';
 import type { EventStream } from '../runtime_types';
@@ -25,7 +25,7 @@ export type StepResponses = DataRequestResponse | ASTResponse | TranslateRespons
 interface TranslationStep {
     step(that: MalloyTranslation): StepResponses;
 }
-interface ParseData extends ProblemResponse, NeedURLData, FinalResponse {
+interface ParseData extends ResponseBase, ProblemResponse, NeedURLData, FinalResponse {
     parse: MalloyParseInfo;
 }
 export type ParseResponse = Partial<ParseData>;

package/dist/lang/parse-malloy.js

@@ -73,8 +73,10 @@ const model_annotation_walker_1 = require("./parse-tree-walkers/model-annotation
 const find_table_path_walker_1 = require("./parse-tree-walkers/find-table-path-walker");
 const annotation_1 = require("../annotation");
 const run_malloy_parser_1 = require("./run-malloy-parser");
+const timing_1 = require("../timing");
 class ParseStep {
     step(that) {
+        const stepTimer = new timing_1.Timer('parse_step');
         if (this.response) {
             return this.response;
         }
@@ -94,6 +96,7 @@ class ParseStep {
             }
             return { urls: [that.sourceURL] };
         }
+        const parseModelTimer = new timing_1.Timer('parse_malloy');
         const source = srcEnt.value === '' ? '\n' : srcEnt.value;
         this.sourceInfo = (0, utils_1.getSourceInfo)(source);
         let parse;
@@ -104,6 +107,7 @@ class ParseStep {
             that.root.logError('parse-exception', { message: parseException.message });
             parse = undefined;
         }
+        stepTimer.contribute([parseModelTimer.stop()]);
         if (that.root.logger.hasErrors()) {
             this.response = {
                 parse,
@@ -113,7 +117,7 @@ class ParseStep {
         else {
             this.response = { parse };
         }
-        return this.response;
+        return { ...this.response, timingInfo: stepTimer.stop() };
     }
     runParser(source, sourceInfo, that) {
         const parse = (0, run_malloy_parser_1.runMalloyParser)(source, that.sourceURL, sourceInfo, that.root.logger, that.grammarRule);
@@ -167,7 +171,7 @@ class ImportsAndTablesStep {
         if (that.root.logger.hasErrors()) {
             // Since we knew we parsed without errors, this would only be from
             // having a malformed URL on an import reference.
-            return null;
+            return { timingInfo: parseReq.timingInfo };
         }
         let allMissing = {};
         const missingTables = that.root.schemaZone.getUndefined();
@@ -184,10 +188,13 @@ class ImportsAndTablesStep {
         }
         const missingImports = ((_a = that.root.importZone.getUndefined()) !== null && _a !== void 0 ? _a : []).filter(url => that.root.pretranslatedModels.get(url) === undefined);
         if (missingImports.length > 0) {
-            allMissing = { ...allMissing, urls: missingImports };
+            allMissing = {
+                ...allMissing,
+                urls: missingImports,
+            };
         }
         if ((0, translate_response_1.isNeedResponse)(allMissing)) {
-            return allMissing;
+            return { ...allMissing, timingInfo: parseReq.timingInfo };
         }
         for (const child of that.childTranslators.values()) {
             if (that.root.pretranslatedModels.get(child.sourceURL)) {
@@ -198,7 +205,7 @@ class ImportsAndTablesStep {
                 return kidNeeds;
             }
         }
-        return null;
+        return { timingInfo: parseReq.timingInfo };
     }
 }
 class ASTStep {
@@ -207,11 +214,13 @@ class ASTStep {
         this.walked = false;
     }
     step(that) {
+        const stepTimer = new timing_1.Timer('ast_step');
         if (this.response) {
             return this.response;
         }
         const mustResolve = this.importStep.step(that);
-        if (mustResolve) {
+        stepTimer.incorporate(mustResolve === null || mustResolve === void 0 ? void 0 : mustResolve.timingInfo);
+        if ((0, translate_response_1.isNeedResponse)(mustResolve)) {
             return mustResolve;
         }
         const parseResponse = that.parseStep.response;
@@ -224,17 +233,19 @@ class ASTStep {
         if (!parse) {
             throw new Error('TRANSLATOR INTERNAL ERROR: Translator parse response had no errors, but also no parser');
         }
+        stepTimer.incorporate(parseResponse.timingInfo);
         const secondPass = new malloy_to_ast_1.MalloyToAST(parse, that.root.logger, that.compilerFlags);
-        const newAst = secondPass.visit(parse.root);
-        that.compilerFlags = secondPass.compilerFlags;
-        if (newAst.elementType === 'unimplemented') {
-            newAst.logError('untranslated-parse-node', 'INTERNAL COMPILER ERROR: Untranslated parse node');
+        const { ast: newAST, compilerFlags, timingInfo } = secondPass.run();
+        stepTimer.contribute([timingInfo]);
+        that.compilerFlags = compilerFlags;
+        if (newAST.elementType === 'unimplemented') {
+            newAST.logError('untranslated-parse-node', 'INTERNAL COMPILER ERROR: Untranslated parse node');
         }
         if (!this.walked) {
             // The DocumentStatement.needs method has largely replaced the need to walk
             // the AST once it has been translated, this one check remains, though
             // it should probably never be hit
-            for (const walkedTo of newAst.walk()) {
+            for (const walkedTo of newAST.walk()) {
                 if (walkedTo instanceof ast.Unimplemented) {
                     walkedTo.logError('untranslated-parse-node', 'INTERNAL COMPILER ERROR: Untranslated parse node');
                 }
@@ -256,13 +267,13 @@ class ASTStep {
                 return kidNeeds;
             }
         }
-        newAst.setTranslator(that);
+        newAST.setTranslator(that);
         this.response = {
             ...that.problemResponse(), // these problems will by definition all be warnings
-            ast: newAst,
+            ast: newAST,
             final: true,
         };
-        return this.response;
+        return { ...this.response, timingInfo: stepTimer.stop() };
     }
 }
 class MetadataStep {
@@ -397,6 +408,7 @@ class TranslateStep {
         this.importedAnnotations = false;
     }
     step(that, extendingModel) {
+        const stepTimer = new timing_1.Timer('translate_step');
         if (this.response) {
             return this.response;
         }
@@ -411,13 +423,16 @@ class TranslateStep {
         }
         // begin with the compiler flags of the model we are extending
         if (extendingModel && !this.importedAnnotations) {
+            const parseCompilerFlagsTimer = new timing_1.Timer('parse_compiler_flags');
             const tagParse = (0, annotation_1.annotationToTag)(extendingModel.annotation, {
                 prefix: /^##! /,
             });
+            stepTimer.contribute([parseCompilerFlagsTimer.stop()]);
             that.compilerFlags = tagParse.tag;
             this.importedAnnotations = true;
         }
         const astResponse = this.astStep.step(that);
+        stepTimer.incorporate(astResponse.timingInfo);
         if ((0, translate_response_1.isNeedResponse)(astResponse)) {
             return astResponse;
         }
@@ -429,15 +444,18 @@ class TranslateStep {
             if (astResponse.ast instanceof ast.Document) {
                 const doc = astResponse.ast;
                 doc.initModelDef(extendingModel);
-                for (;;) {
-                    const docCompile = doc.compile();
-                    if (docCompile.needs) {
-                        return docCompile.needs;
-                    }
-                    else {
-                        that.modelDef = docCompile.modelDef;
-                        break;
-                    }
+                const translateModelTimer = new timing_1.Timer('compile_malloy');
+                const docCompile = doc.compile();
+                const translateTiming = translateModelTimer.stop();
+                stepTimer.contribute([translateTiming]);
+                if (docCompile.needs) {
+                    return {
+                        ...docCompile.needs,
+                        timingInfo: stepTimer.stop(),
+                    };
+                }
+                else {
+                    that.modelDef = docCompile.modelDef;
                 }
             }
             else {
@@ -463,7 +481,7 @@ class TranslateStep {
                 final: true,
             };
         }
-        return this.response;
+        return { ...this.response, timingInfo: stepTimer.stop() };
     }
 }
 class MalloyTranslation {

package/dist/lang/translate-response.d.ts

@@ -1,3 +1,4 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
 import type { Annotation, ModelDef } from '../model/malloy_types';
 import type { MalloyElement } from './ast';
 import type { LogMessage } from './parse-log';
@@ -5,6 +6,9 @@ import type { DocumentSymbol } from './parse-tree-walkers/document-symbol-walker
 import type { DocumentCompletion } from './parse-tree-walkers/document-completion-walker';
 import type { DocumentHelpContext } from './parse-tree-walkers/document-help-context-walker';
 import type { PathInfo } from './parse-tree-walkers/find-table-path-walker';
+export interface ResponseBase {
+    timingInfo?: Malloy.TimingInfo;
+}
 /**
  * The translation interface is essentially a request/response protocol, and
  * this is the list of all the "protocol" messages.
@@ -34,34 +38,34 @@ export interface NeedCompileSQL {
 }
 interface NeededData extends NeedURLData, NeedSchemaData, NeedCompileSQL {
 }
-export type DataRequestResponse = Partial<NeededData> | null;
+export type DataRequestResponse = Partial<NeededData> & ResponseBase;
 export declare function isNeedResponse(dr: DataRequestResponse): dr is NeededData;
 export type ModelDataRequest = NeedCompileSQL | undefined;
-interface ASTData extends ProblemResponse, NeededData, FinalResponse {
+interface ASTData extends ResponseBase, ProblemResponse, NeededData, FinalResponse {
     ast: MalloyElement;
 }
 export type ASTResponse = Partial<ASTData>;
-interface Metadata extends NeededData, ProblemResponse, FinalResponse {
+interface Metadata extends ResponseBase, NeededData, ProblemResponse, FinalResponse {
     symbols: DocumentSymbol[];
 }
 export type MetadataResponse = Partial<Metadata>;
-interface ModelAnnotationData extends NeededData, ProblemResponse, FinalResponse {
+interface ModelAnnotationData extends ResponseBase, NeededData, ProblemResponse, FinalResponse {
     modelAnnotation: Annotation;
 }
 export type ModelAnnotationResponse = Partial<ModelAnnotationData>;
-interface Completions extends NeededData, ProblemResponse, FinalResponse {
+interface Completions extends ResponseBase, NeededData, ProblemResponse, FinalResponse {
     completions: DocumentCompletion[];
 }
 export type CompletionsResponse = Partial<Completions>;
-interface HelpContext extends NeededData, ProblemResponse, FinalResponse {
+interface HelpContext extends ResponseBase, NeededData, ProblemResponse, FinalResponse {
     helpContext: DocumentHelpContext | undefined;
 }
 export type HelpContextResponse = Partial<HelpContext>;
-interface TranslatedResponseData extends NeededData, ProblemResponse, FinalResponse {
+interface TranslatedResponseData extends ResponseBase, NeededData, ProblemResponse, FinalResponse {
     modelDef: ModelDef;
     fromSources: string[];
 }
-interface TablePath extends NeededData, ProblemResponse, FinalResponse {
+interface TablePath extends ResponseBase, NeededData, ProblemResponse, FinalResponse {
     pathInfo: PathInfo[];
 }
 export type TablePathResponse = Partial<TablePath>;

package/dist/timing.d.ts

@@ -0,0 +1,11 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
+export declare class Timer {
+    readonly name: string;
+    readonly startTime: number;
+    private endTime;
+    private detailedTiming;
+    constructor(name: string);
+    incorporate(timing: Malloy.TimingInfo | undefined): void;
+    contribute(timings: Malloy.TimingInfo[] | undefined): void;
+    stop(): Malloy.TimingInfo;
+}

package/dist/timing.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+class Timer {
+    constructor(name) {
+        this.name = name;
+        this.endTime = undefined;
+        this.detailedTiming = [];
+        this.startTime = performance.now();
+    }
+    incorporate(timing) {
+        this.contribute(timing === null || timing === void 0 ? void 0 : timing.detailed_timing);
+    }
+    contribute(timings) {
+        this.detailedTiming.push(...(timings !== null && timings !== void 0 ? timings : []));
+    }
+    stop() {
+        this.endTime = performance.now();
+        return {
+            name: this.name,
+            duration_ms: this.endTime - this.startTime,
+            detailed_timing: [...this.detailedTiming.values()],
+        };
+    }
+}
+exports.Timer = Timer;
+//# sourceMappingURL=timing.js.map

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.296";
+export declare const MALLOY_VERSION = "0.0.297";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.296';
+exports.MALLOY_VERSION = '0.0.297';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.296",
+  "version": "0.0.297",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.296",
-    "@malloydata/malloy-interfaces": "0.0.296",
-    "@malloydata/malloy-tag": "0.0.296",
+    "@malloydata/malloy-filter": "0.0.297",
+    "@malloydata/malloy-interfaces": "0.0.297",
+    "@malloydata/malloy-tag": "0.0.297",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",