@devrev/meerkat-core 0.0.90 → 0.0.93

package/src/cube-measure-transformer/cube-measure-transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-measure-transformer/cube-measure-transformer.ts"],"sourcesContent":["import { Member } from '../types/cube-types/query';\nimport { Measure, TableSchema } from '../types/cube-types/table';\nimport { meerkatPlaceholderReplacer } from '../utils/meerkat-placeholder-replacer';\nimport { memberKeyToSafeKey } from '../utils/member-key-to-safe-key';\n\nexport const cubeMeasureToSQLSelectString = (\n  measures: Member[],\n  tableSchema: TableSchema\n) => {\n  let base = 'SELECT';\n  for (let i = 0; i < measures.length; i++) {\n    const measure = measures[i];\n    if (measure === '*') {\n      base += ` ${tableSchema.name}.*`;\n      continue;\n    }\n    const [tableSchemaName, measureKeyWithoutTable] = measure.split('.');\n\n    const aliasKey = memberKeyToSafeKey(measure);\n    const measureSchema = tableSchema.measures.find(\n      (m) => m.name === measureKeyWithoutTable\n    );\n    if (!measureSchema) {\n      continue;\n    }\n    if (i > 0) {\n      base += ', ';\n    }\n    let meerkatReplacedSqlString = meerkatPlaceholderReplacer(\n      measureSchema.sql,\n      tableSchema.name\n    );\n\n    /**\n     * Here we extract the columns used in the measure and replace them with the safeKey.\n     * We need to do this because the columns used in the measure are not directly available in the joined table.\n     * Thus we need to project them and use them in the join.\n     */\n\n    const columnsUsedInMeasure = getColumnsFromSQL(\n      meerkatReplacedSqlString,\n      tableSchemaName\n    );\n\n    //Replace all the columnsUsedInMeasure with safeKey\n    columnsUsedInMeasure?.forEach((measureKey) => {\n      const column = measureKey.split('.')[1];\n      const memberKey = `${tableSchemaName}.${column}`;\n      const columnKey = memberKeyToSafeKey(memberKey);\n      meerkatReplacedSqlString = meerkatReplacedSqlString.replace(\n        memberKey,\n        columnKey\n      );\n    });\n\n    base += ` ${meerkatReplacedSqlString} AS ${aliasKey} `;\n  }\n  return base;\n};\n\nconst addDimensionToSQLProjection = (\n  dimensions: Member[],\n  selectString: string,\n  tableSchema: TableSchema\n) => {\n  if (dimensions.length === 0) {\n    return selectString;\n  }\n  let newSelectString = selectString;\n  for (let i = 0; i < dimensions.length; i++) {\n    const dimension = dimensions[i];\n    const dimensionKeyWithoutTable = dimension.split('.')[1];\n    const dimensionSchema = tableSchema.dimensions.find(\n      (m) => m.name === dimensionKeyWithoutTable\n    );\n    const aliasKey = memberKeyToSafeKey(dimension);\n\n    if (!dimensionSchema) {\n      continue;\n    }\n    if (i > 0) {\n      newSelectString += ',';\n    }\n    // since alias key is expected to have been unfurled in the base query, we can just use it as is.\n    newSelectString += `  ${aliasKey}`;\n  }\n  return newSelectString;\n};\n\nexport const getSelectReplacedSql = (sql: string, selectString: string) => {\n  /*\n   ** Replaces the select portion of a SQL string with the selectString passed.\n   */\n  const selectRegex = /SELECT\\s\\*/;\n  const match = sql.match(selectRegex);\n  if (!match) {\n    return sql;\n  }\n  const selectIndex = match.index;\n  if (selectIndex === undefined) {\n    throw new Error('SELECT * not found in SQL string');\n  }\n  const selectLength = match[0].length;\n  const beforeSelect = sql.substring(0, selectIndex);\n  const afterSelect = sql.substring(selectIndex + selectLength);\n  return `${beforeSelect}${selectString}${afterSelect}`;\n};\n\n/**\n * Get all the columns used in the measures.\n * This is used for extracting the columns used in the measures needed for the projection.\n * Example: The joins implementation uses this to get the columns used in the measures to join the tables.\n * like the SQL for the measure is `SUM(table.total)` and the table name is `table`, then the column used is `total`\n * table cannot be used directly here because the joined table would have column name ambiguity.\n * Thus these columns are projected and directly used in the join.\n */\nexport const getAllColumnUsedInMeasures = (\n  measures: Measure[],\n  tableSchema: TableSchema\n) => {\n  let columns: string[] = [];\n  measures.forEach((measure) => {\n    const columnMatch = getColumnsFromSQL(measure.sql, tableSchema.name);\n    if (columnMatch && columnMatch.length > 0) {\n      columns = [...columns, ...columnMatch];\n    }\n  });\n  // Remove duplicates\n  return [...new Set(columns)];\n};\n\nconst getColumnsFromSQL = (sql: string, tableName: string) => {\n  const regex = new RegExp(`(${tableName}\\\\.[a-zA-Z0-9_]+)`, 'g');\n  const columnMatch = sql.match(regex);\n  return columnMatch;\n};\n\n/**\n * Replace the first SELECT * from the sqlToReplace with the cube measure\n * @param measures\n * @param tableSchema\n * @param sqlToReplace\n * @returns\n */\nexport const applyProjectionToSQLQuery = (\n  dimensions: Member[],\n  measures: Member[],\n  tableSchema: TableSchema,\n  sqlToReplace: string\n) => {\n  let measureSelectString = cubeMeasureToSQLSelectString(measures, tableSchema);\n\n  if (measures.length > 0 && dimensions.length > 0) {\n    measureSelectString += ', ';\n  }\n  const selectString = addDimensionToSQLProjection(\n    dimensions,\n    measureSelectString,\n    tableSchema\n  );\n\n  return getSelectReplacedSql(sqlToReplace, selectString);\n};\n"],"names":["cubeMeasureToSQLSelectString","getSelectReplacedSql","getAllColumnUsedInMeasures","applyProjectionToSQLQuery","measures","tableSchema","base","i","length","measure","name","tableSchemaName","measureKeyWithoutTable","split","aliasKey","memberKeyToSafeKey","measureSchema","find","m","meerkatReplacedSqlString","meerkatPlaceholderReplacer","sql","columnsUsedInMeasure","getColumnsFromSQL","forEach","measureKey","column","memberKey","columnKey","replace","addDimensionToSQLProjection","dimensions","selectString","newSelectString","dimension","dimensionKeyWithoutTable","dimensionSchema","selectRegex","match","selectIndex","index","undefined","Error","selectLength","beforeSelect","substring","afterSelect","columns","columnMatch","Set","tableName","regex","RegExp","sqlToReplace","measureSelectString"],"mappings":"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"}

package/src/cube-order-by-transformer/cube-order-by-transformer.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-order-by-transformer/cube-order-by-transformer.ts"],"sourcesContent":["import {\n  ExpressionClass,\n  ExpressionType,\n} from '../types/duckdb-serialization-types/serialization/Expression';\nimport { OrderType } from '../types/duckdb-serialization-types/serialization/Nodes';\nimport { ResultModifierType } from '../types/duckdb-serialization-types/serialization/ResultModifier';\nimport { memberKeyToSafeKey } from '../utils/member-key-to-safe-key';\n\nexport const cubeOrderByToAST = (order: { [key: string]: 'asc' | 'desc' }) => {\n  const orderArr = [];\n  for (const key in order) {\n    const value = order[key];\n    const astOrderBy =\n      value === 'asc' ? OrderType.ASCENDING : OrderType.DESCENDING;\n    const orderByAST = {\n      type: astOrderBy,\n      null_order: OrderType.ORDER_DEFAULT,\n      expression: {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        /**\n         * We need to convert the key in the __ format as they are being projected in this format\n         */\n        column_names: [memberKeyToSafeKey(key)],\n      },\n    };\n    orderArr.push(orderByAST);\n  }\n  return {\n    type: ResultModifierType.ORDER_MODIFIER,\n    orders: orderArr,\n  };\n};\n"],"names":["cubeOrderByToAST","order","orderArr","key","value","astOrderBy","OrderType","ASCENDING","DESCENDING","orderByAST","type","null_order","ORDER_DEFAULT","expression","class","ExpressionClass","COLUMN_REF","ExpressionType","alias","column_names","memberKeyToSafeKey","push","ResultModifierType","ORDER_MODIFIER","orders"],"mappings":";+BAQaA;;;eAAAA;;;4BALN;uBACmB;gCACS;oCACA;AAE5B,MAAMA,mBAAmB,CAACC;IAC/B,MAAMC,WAAW,EAAE;IACnB,IAAK,MAAMC,OAAOF,MAAO;QACvB,MAAMG,QAAQH,KAAK,CAACE,IAAI;QACxB,MAAME,aACJD,UAAU,QAAQE,gBAAS,CAACC,SAAS,GAAGD,gBAAS,CAACE,UAAU;QAC9D,MAAMC,aAAa;YACjBC,MAAML;YACNM,YAAYL,gBAAS,CAACM,aAAa;YACnCC,YAAY;gBACVC,OAAOC,2BAAe,CAACC,UAAU;gBACjCN,MAAMO,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACP;;SAEC,GACDC,cAAc;oBAACC,IAAAA,sCAAkB,EAACjB;iBAAK;YACzC;QACF;QACAD,SAASmB,IAAI,CAACZ;IAChB;IACA,OAAO;QACLC,MAAMY,kCAAkB,CAACC,cAAc;QACvCC,QAAQtB;IACV;AACF"}

package/src/cube-to-duckdb/cube-filter-to-duckdb.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-to-duckdb/cube-filter-to-duckdb.ts"],"names":[],"mappings":""}

package/src/filter-params/filter-params-ast.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/filter-params/filter-params-ast.ts"],"sourcesContent":["import { cubeToDuckdbAST } from '../ast-builder/ast-builder';\nimport {\n  FilterType,\n  LogicalAndFilter,\n  LogicalOrFilter,\n  MeerkatQueryFilter,\n  Query,\n  QueryFilter,\n  TableSchema\n} from '../types/cube-types';\nimport { SelectStatement } from '../types/duckdb-serialization-types/serialization/Statement';\n\n/**\n * Get the query filter with only where filterKey matches\n */\n\nexport const traverseAndFilter = (\n  filter: MeerkatQueryFilter,\n  callback: (value: QueryFilter) => boolean\n): MeerkatQueryFilter | null => {\n  if ('member' in filter) {\n    return callback(filter) ? filter : null;\n  }\n\n  if ('and' in filter) {\n    const filteredAndFilters = filter.and\n      .map((subFilter) => traverseAndFilter(subFilter, callback))\n      .filter(Boolean) as MeerkatQueryFilter[];\n    const obj =\n      filteredAndFilters.length > 0 ? { and: filteredAndFilters } : null;\n    return obj as LogicalAndFilter;\n  }\n\n  if ('or' in filter) {\n    const filteredOrFilters = filter.or\n      .map((subFilter) => traverseAndFilter(subFilter, callback))\n      .filter(Boolean);\n    const obj = filteredOrFilters.length > 0 ? { or: filteredOrFilters } : null;\n    return obj as LogicalOrFilter;\n  }\n\n  return null;\n};\n\n\nexport const getFilterByMemberKey = (\n  filters: MeerkatQueryFilter[] | undefined,\n  memberKey: string\n): MeerkatQueryFilter[] => {\n  if (!filters) return [];\n  return filters\n    .map((filter) => traverseAndFilter(filter, (value) =>  value.member === memberKey))\n    .filter(Boolean) as MeerkatQueryFilter[];\n};\n\n/**\n * Syntax for filter params in SQL:\n * FILTER_PARAMS.cube_name.member_name.filter(sql_expression)\n * Example:\n *  SELECT *\n *  FROM orders\n *  WHERE ${FILTER_PARAMS.order_facts.date.filter('date')}\n * @param sql\n */\nexport const detectAllFilterParamsFromSQL = (\n  sql: string\n): {\n  memberKey: string;\n  filterExpression: string;\n  matchKey: string;\n}[] => {\n  const regex = /\\${FILTER_PARAMS\\.(\\w+\\.\\w+)\\.filter\\('(\\w+)'\\)}/g;\n  const matches = [];\n  let match;\n  while ((match = regex.exec(sql)) !== null) {\n    matches.push({\n      memberKey: match[1],\n      filterExpression: match[2],\n      matchKey: match[0],\n    });\n  }\n  return matches;\n};\n\n\n\nexport const getFilterParamsAST = (\n  query: Query,\n  tableSchema: TableSchema,\n  filterType: FilterType = 'PROJECTION_FILTER'\n): {\n  memberKey: string;\n  ast: SelectStatement | null;\n  matchKey: string;\n}[] => {\n  const filterParamKeys = detectAllFilterParamsFromSQL(tableSchema.sql);\n  const filterParamsAST = [];\n  \n  for (const filterParamKey of filterParamKeys) {\n    const filters = getFilterByMemberKey(\n      query.filters,\n      filterParamKey.memberKey\n    );\n   \n    if (filters && filters.length > 0) {\n      filterParamsAST.push({\n        memberKey: filterParamKey.memberKey,\n        matchKey: filterParamKey.matchKey,\n        ast: cubeToDuckdbAST(\n          { filters, measures: [], dimensions: [] },\n          tableSchema,\n          {\n            filterType\n          }\n        ),\n      });\n    }\n  }\n\n  return filterParamsAST;\n};\n\ntype FilterParamsSQL = {\n  memberKey: string;\n  sql: string;\n  matchKey: string;\n}\n\nconst replaceWhereClauseWithFiltersParamsSQL = (baseSQL: string, filterParamsSQL: FilterParamsSQL[]) => {\n  let finalSQL = baseSQL;\n\n  for (const filterParam of filterParamsSQL) {\n    /**\n     * Get SQL expression after WHERE clause\n     */\n    const whereClause = filterParam.sql.split('WHERE')[1];\n    /**\n     * Replace filter param with SQL expression\n     */\n    finalSQL = finalSQL.replace(filterParam.matchKey, whereClause);\n  }\n  return finalSQL\n}\n\nexport const applyFilterParamsToBaseSQL = (\n  baseSQL: string,\n  filterParamsSQL: FilterParamsSQL[]\n) => {\n  let finalSQL = replaceWhereClauseWithFiltersParamsSQL(baseSQL, filterParamsSQL);\n  for (const filterParam of filterParamsSQL) {\n    /**\n     * Get SQL expression after WHERE clause\n     */\n    const whereClause = filterParam.sql.split('WHERE')[1];\n    /**\n     * Replace filter param with SQL expression\n     */\n    finalSQL = finalSQL.replace(filterParam.matchKey, whereClause);\n  }\n  /**\n   * Find all remaining filter params and replace them with TRUE\n   */\n  const remainingFilterParams = detectAllFilterParamsFromSQL(finalSQL);\n\n  for (const filterParam of remainingFilterParams) {\n    finalSQL = finalSQL.replace(filterParam.matchKey, 'TRUE');\n  }\n  return finalSQL;\n};\n"],"names":["traverseAndFilter","getFilterByMemberKey","detectAllFilterParamsFromSQL","getFilterParamsAST","applyFilterParamsToBaseSQL","filter","callback","filteredAndFilters","and","map","subFilter","Boolean","obj","length","filteredOrFilters","or","filters","memberKey","value","member","sql","regex","matches","match","exec","push","filterExpression","matchKey","query","tableSchema","filterType","filterParamKeys","filterParamsAST","filterParamKey","ast","cubeToDuckdbAST","measures","dimensions","replaceWhereClauseWithFiltersParamsSQL","baseSQL","filterParamsSQL","finalSQL","filterParam","whereClause","split","replace","remainingFilterParams"],"mappings":"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"}

package/src/get-filter-params-sql/get-filter-params-sql.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/get-filter-params-sql/get-filter-params-sql.ts"],"sourcesContent":["import { astDeserializerQuery, deserializeQuery } from \"../ast-deserializer/ast-deserializer\";\nimport { getFilterParamsAST } from \"../filter-params/filter-params-ast\";\nimport { FilterType, Query, TableSchema } from \"../types/cube-types\";\n\nexport const getFilterParamsSQL = async ({\n  query,\n  tableSchema,\n  filterType,\n  getQueryOutput\n}: {\n  query: Query;\n  tableSchema: TableSchema;\n  filterType?: FilterType;\n  getQueryOutput: (query: string) => Promise<any>;\n}) => {\n  const filterParamsAST = getFilterParamsAST(\n    query,\n    tableSchema,\n    filterType\n  );\n  const filterParamsSQL = [];\n  for (const filterParamAST of filterParamsAST) {\n    if (!filterParamAST.ast) {\n      continue;\n    }\n\n    const queryOutput = await getQueryOutput(astDeserializerQuery(filterParamAST.ast))\n    const sql = deserializeQuery(queryOutput);\n\n    filterParamsSQL.push({\n      memberKey: filterParamAST.memberKey,\n      sql: sql,\n      matchKey: filterParamAST.matchKey,\n    });\n  }\n  return filterParamsSQL;\n};\n"],"names":["getFilterParamsSQL","query","tableSchema","filterType","getQueryOutput","filterParamsAST","getFilterParamsAST","filterParamsSQL","filterParamAST","ast","queryOutput","astDeserializerQuery","sql","deserializeQuery","push","memberKey","matchKey"],"mappings":";+BAIaA;;;eAAAA;;;iCAJ0C;iCACpB;AAG5B,MAAMA,qBAAqB,OAAO,EACvCC,KAAK,EACLC,WAAW,EACXC,UAAU,EACVC,cAAc,EAMf;IACC,MAAMC,kBAAkBC,IAAAA,mCAAkB,EACxCL,OACAC,aACAC;IAEF,MAAMI,kBAAkB,EAAE;IAC1B,KAAK,MAAMC,kBAAkBH,gBAAiB;QAC5C,IAAI,CAACG,eAAeC,GAAG,EAAE;YACvB;QACF;QAEA,MAAMC,cAAc,MAAMN,eAAeO,IAAAA,qCAAoB,EAACH,eAAeC,GAAG;QAChF,MAAMG,MAAMC,IAAAA,iCAAgB,EAACH;QAE7BH,gBAAgBO,IAAI,CAAC;YACnBC,WAAWP,eAAeO,SAAS;YACnCH,KAAKA;YACLI,UAAUR,eAAeQ,QAAQ;QACnC;IACF;IACA,OAAOT;AACT"}

package/src/get-final-base-sql/get-final-base-sql.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/get-final-base-sql/get-final-base-sql.ts"],"sourcesContent":["import { applyFilterParamsToBaseSQL } from \"../filter-params/filter-params-ast\";\nimport { getFilterParamsSQL } from \"../get-filter-params-sql/get-filter-params-sql\";\nimport { getWrappedBaseQueryWithProjections } from \"../get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections\";\nimport { Query } from \"../types/cube-types/query\";\nimport { TableSchema } from \"../types/cube-types/table\";\n\nexport const getFinalBaseSQL = async ({\n  query,\n  getQueryOutput,\n  tableSchema,\n}: { query: Query, tableSchema: TableSchema, getQueryOutput: (query: string) => Promise<any> }) => {\n  /**\n   * Apply transformation to the supplied base query.\n   * This involves updating the filter placeholder with the actual filter values.\n   */\n  const baseFilterParamsSQL = await getFilterParamsSQL({\n    query: query,\n    tableSchema,\n    filterType: 'BASE_FILTER',\n    getQueryOutput,\n  });\n  const baseSQL = applyFilterParamsToBaseSQL(\n    tableSchema.sql,\n    baseFilterParamsSQL\n  );\n  const baseSQLWithFilterProjection = getWrappedBaseQueryWithProjections({\n    baseQuery: baseSQL,\n    tableSchema,\n    query: query,\n  });\n  return baseSQLWithFilterProjection;\n};\n  \n"],"names":["getFinalBaseSQL","query","getQueryOutput","tableSchema","baseFilterParamsSQL","getFilterParamsSQL","filterType","baseSQL","applyFilterParamsToBaseSQL","sql","baseSQLWithFilterProjection","getWrappedBaseQueryWithProjections","baseQuery"],"mappings":";+BAMaA;;;eAAAA;;;iCAN8B;oCACR;oDACgB;AAI5C,MAAMA,kBAAkB,OAAO,EACpCC,KAAK,EACLC,cAAc,EACdC,WAAW,EACiF;IAC5F;;;GAGC,GACD,MAAMC,sBAAsB,MAAMC,IAAAA,sCAAkB,EAAC;QACnDJ,OAAOA;QACPE;QACAG,YAAY;QACZJ;IACF;IACA,MAAMK,UAAUC,IAAAA,2CAA0B,EACxCL,YAAYM,GAAG,EACfL;IAEF,MAAMM,8BAA8BC,IAAAA,sEAAkC,EAAC;QACrEC,WAAWL;QACXJ;QACAF,OAAOA;IACT;IACA,OAAOS;AACT"}

package/src/get-wrapped-base-query-with-projections/get-aliased-columns-from-filters.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/get-wrapped-base-query-with-projections/get-aliased-columns-from-filters.ts"],"sourcesContent":["import { MeerkatQueryFilter, Query, TableSchema } from \"../types/cube-types\";\nimport { findInDimensionSchema, findInMeasureSchema } from \"../utils/find-in-table-schema\";\nimport { memberKeyToSafeKey } from \"../utils/member-key-to-safe-key\";\nimport { getModifiedSqlExpression, Modifier } from \"./sql-expression-modifiers\";\n\n\nexport const getDimensionProjection = ({\n  key,\n  tableSchema,\n  modifiers,\n  query\n}: {\n  key: string;\n  tableSchema: TableSchema;\n  modifiers: Modifier[],\n  query: Query\n}) => {\n  // Find the table access key\n  const [tableName, measureWithoutTable] = key.split('.');\n\n  const foundMember = findInDimensionSchema(measureWithoutTable, tableSchema);\n  if (!foundMember || tableName !== tableSchema.name) {\n    // If the selected member is not found in the table schema or if it is already selected, continue.\n    // If the selected member is not from the current table, don't create an alias.\n    return {\n      sql: undefined,\n      foundMember: undefined,\n      aliasKey: undefined,\n    };\n  }\n\n  const modifiedSql = getModifiedSqlExpression({\n    dimension: foundMember,\n    key: key,\n    modifiers: modifiers,\n    sqlExpression: foundMember.sql,\n    query\n  })\n\n  const aliasKey = memberKeyToSafeKey(key);\n  // Add the alias key to the set. So we have a reference to all the previously selected members.\n  return { sql: `${modifiedSql} AS ${aliasKey}`, foundMember, aliasKey };\n};\n\n\nexport const getFilterMeasureProjection = ({\n  key,\n  tableSchema,\n  measures,\n}: {\n  key: string;\n  tableSchema: TableSchema;\n  measures: string[];\n}) => {\n  const [tableName, measureWithoutTable] = key.split('.');\n  const foundMember = findInMeasureSchema(measureWithoutTable, tableSchema);\n  const isMeasure = measures.includes(key);\n  if (!foundMember || isMeasure || tableName !== tableSchema.name) {\n    // If the selected member is not found in the table schema or if it is already selected, continue.\n    // If the selected member is a measure, don't create an alias. Since measure computation is done in the outermost level of the query\n    // If the selected member is not from the current table, don't create an alias.\n    return {\n      sql: undefined,\n      foundMember: undefined,\n      aliasKey: undefined,\n    };\n  }\n  const aliasKey = memberKeyToSafeKey(key);\n  return { sql: `${key} AS ${aliasKey}`, foundMember, aliasKey };\n};\n\n\nconst getFilterProjections = ({\n  member,\n  tableSchema,\n  measures,\n  query\n}: {\n  member: string;\n  tableSchema: TableSchema;\n  measures: string[];\n  query: Query\n}) => {\n  const memberWithoutTable = member.split('.')[1];\n  const isDimension = findInDimensionSchema(memberWithoutTable, tableSchema);\n  if (isDimension) {\n    return getDimensionProjection({ key: member, tableSchema, modifiers: [], query });\n  }\n  const isMeasure = findInMeasureSchema(memberWithoutTable, tableSchema);\n  if (isMeasure) {\n    return getFilterMeasureProjection({ key: member, tableSchema, measures });\n  }\n  return {\n    sql: undefined,\n    foundMember: undefined,\n    aliasKey: undefined,\n  };\n};\n\n\nexport const getAliasedColumnsFromFilters = ({\n  baseSql,\n  meerkatFilters,\n  tableSchema,\n  aliasedColumnSet,\n  query\n}: {\n  meerkatFilters?: MeerkatQueryFilter[];\n  tableSchema: TableSchema;\n  baseSql: string;\n  aliasedColumnSet: Set<string>;\n  query: Query;\n}) => {\n  let sql = baseSql;\n  const { measures } = query;\n  meerkatFilters?.forEach((filter) => {\n    if ('and' in filter) {\n      // Traverse through the passed 'and' filters\n      sql += getAliasedColumnsFromFilters({\n        baseSql: '',\n        meerkatFilters: filter.and,\n        tableSchema,\n        aliasedColumnSet,\n        query,\n      });\n    }\n    if ('or' in filter) {\n      // Traverse through the passed 'or' filters\n      sql += getAliasedColumnsFromFilters({\n        baseSql: '',\n        tableSchema,\n        meerkatFilters: filter.or,\n        aliasedColumnSet,\n        query,\n      });\n    }\n    if ('member' in filter) {\n      const {\n        aliasKey,\n        foundMember,\n        sql: memberSql,\n      } = getFilterProjections({\n        member: filter.member,\n        tableSchema,\n        measures,\n        query\n      });\n      if (!foundMember || aliasedColumnSet.has(aliasKey)) {\n        // If the selected member is not found in the table schema or if it is already selected, continue.\n        return;\n      }\n      if (aliasKey) {\n        aliasedColumnSet.add(aliasKey);\n      }\n      // Add the alias key to the set. So we have a reference to all the previously selected members.\n      sql += `, ${memberSql}`;\n    }\n  });\n  return sql;\n};\n  "],"names":["getDimensionProjection","getFilterMeasureProjection","getAliasedColumnsFromFilters","key","tableSchema","modifiers","query","tableName","measureWithoutTable","split","foundMember","findInDimensionSchema","name","sql","undefined","aliasKey","modifiedSql","getModifiedSqlExpression","dimension","sqlExpression","memberKeyToSafeKey","measures","findInMeasureSchema","isMeasure","includes","getFilterProjections","member","memberWithoutTable","isDimension","baseSql","meerkatFilters","aliasedColumnSet","forEach","filter","and","or","memberSql","has","add"],"mappings":"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"}

package/src/get-wrapped-base-query-with-projections/get-projection-clause.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/get-wrapped-base-query-with-projections/get-projection-clause.ts"],"sourcesContent":["import { getAllColumnUsedInMeasures } from '../cube-measure-transformer/cube-measure-transformer';\nimport { Query, TableSchema } from '../types/cube-types';\nimport { memberKeyToSafeKey } from '../utils/member-key-to-safe-key';\nimport { getDimensionProjection, getFilterMeasureProjection } from './get-aliased-columns-from-filters';\nimport { MODIFIERS } from './sql-expression-modifiers';\n\nconst memberClauseAggregator = ({\n  member,\n  aliasedColumnSet,\n  acc,\n  sql,\n}: {\n  member: string;\n  aliasedColumnSet: Set<string>;\n  acc: string[];\n  sql?: string;\n  currentIndex: number;\n  members: string[];\n}) => {\n  if (aliasedColumnSet.has(member) || !sql) {\n    return acc;\n  }\n  aliasedColumnSet.add(member);\n  acc.push(sql);\n  return acc;\n};\n\nexport const getProjectionClause = (\n  query: Query,\n  tableSchema: TableSchema,\n  aliasedColumnSet: Set<string>\n) => {\n  const { measures, dimensions = [] } = query;\n  const filteredDimensions = dimensions.filter((dimension) => {\n    return dimension.split('.')[0] === tableSchema.name;\n  });\n  const filteredMeasures = measures.filter((measure) => {\n    return measure.split('.')[0] === tableSchema.name;\n  });\n  const dimensionsProjectionsArr = filteredDimensions.reduce(\n    (acc, member, currentIndex, members) => {\n      const { sql: memberSql } = getDimensionProjection({\n        key: member,\n        tableSchema,\n        modifiers: MODIFIERS,\n        query\n      });\n      return memberClauseAggregator({\n        member: memberKeyToSafeKey(member),\n        aliasedColumnSet,\n        acc,\n        currentIndex,\n        members,\n        sql: memberSql,\n      });\n    },\n    [] as string[]\n  );\n  const dimensionsProjections = dimensionsProjectionsArr.join(', ');\n\n  const measureProjectionsArr = filteredMeasures.reduce(\n    (acc, member, currentIndex, members) => {\n      const { sql: memberSql } = getFilterMeasureProjection({\n        key: member,\n        tableSchema,\n        measures,\n      });\n      return memberClauseAggregator({\n        member,\n        aliasedColumnSet,\n        acc,\n        currentIndex,\n        members,\n        sql: memberSql,\n      });\n    },\n    [] as string[]\n  );\n\n  const measureProjections = measureProjectionsArr.join(', ');\n\n  const usedMeasureObjects = tableSchema.measures.filter((measure) => {\n    return (\n      measures.findIndex((key) => {\n        const keyWithoutTable = key.split('.')[1];\n        return keyWithoutTable === measure.name;\n      }) !== -1\n    );\n  });\n  const columnsUsedInMeasures = getAllColumnUsedInMeasures(\n    usedMeasureObjects,\n    tableSchema\n  );\n\n  let columnsUsedInMeasuresInProjection = '';\n  columnsUsedInMeasures.forEach((column, index) => {\n    const safeKey = memberKeyToSafeKey(column);\n    columnsUsedInMeasuresInProjection += `${column} AS ${safeKey}`;\n    if (index !== columnsUsedInMeasures.length - 1) {\n      columnsUsedInMeasuresInProjection += ', ';\n    }\n  });\n\n  const combinedStr = [\n    dimensionsProjections,\n    measureProjections,\n    columnsUsedInMeasuresInProjection,\n  ];\n\n  return combinedStr.filter((str) => str.length > 0).join(', ');\n};\n"],"names":["getProjectionClause","memberClauseAggregator","member","aliasedColumnSet","acc","sql","has","add","push","query","tableSchema","measures","dimensions","filteredDimensions","filter","dimension","split","name","filteredMeasures","measure","dimensionsProjectionsArr","reduce","currentIndex","members","memberSql","getDimensionProjection","key","modifiers","MODIFIERS","memberKeyToSafeKey","dimensionsProjections","join","measureProjectionsArr","getFilterMeasureProjection","measureProjections","usedMeasureObjects","findIndex","keyWithoutTable","columnsUsedInMeasures","getAllColumnUsedInMeasures","columnsUsedInMeasuresInProjection","forEach","column","index","safeKey","length","combinedStr","str"],"mappings":";+BA2BaA;;;eAAAA;;;wCA3B8B;oCAER;8CACgC;wCACzC;AAE1B,MAAMC,yBAAyB,CAAC,EAC9BC,MAAM,EACNC,gBAAgB,EAChBC,GAAG,EACHC,GAAG,EAQJ;IACC,IAAIF,iBAAiBG,GAAG,CAACJ,WAAW,CAACG,KAAK;QACxC,OAAOD;IACT;IACAD,iBAAiBI,GAAG,CAACL;IACrBE,IAAII,IAAI,CAACH;IACT,OAAOD;AACT;AAEO,MAAMJ,sBAAsB,CACjCS,OACAC,aACAP;IAEA,MAAM,EAAEQ,QAAQ,EAAEC,aAAa,EAAE,EAAE,GAAGH;IACtC,MAAMI,qBAAqBD,WAAWE,MAAM,CAAC,CAACC;QAC5C,OAAOA,UAAUC,KAAK,CAAC,IAAI,CAAC,EAAE,KAAKN,YAAYO,IAAI;IACrD;IACA,MAAMC,mBAAmBP,SAASG,MAAM,CAAC,CAACK;QACxC,OAAOA,QAAQH,KAAK,CAAC,IAAI,CAAC,EAAE,KAAKN,YAAYO,IAAI;IACnD;IACA,MAAMG,2BAA2BP,mBAAmBQ,MAAM,CACxD,CAACjB,KAAKF,QAAQoB,cAAcC;QAC1B,MAAM,EAAElB,KAAKmB,SAAS,EAAE,GAAGC,IAAAA,oDAAsB,EAAC;YAChDC,KAAKxB;YACLQ;YACAiB,WAAWC,iCAAS;YACpBnB;QACF;QACA,OAAOR,uBAAuB;YAC5BC,QAAQ2B,IAAAA,sCAAkB,EAAC3B;YAC3BC;YACAC;YACAkB;YACAC;YACAlB,KAAKmB;QACP;IACF,GACA,EAAE;IAEJ,MAAMM,wBAAwBV,yBAAyBW,IAAI,CAAC;IAE5D,MAAMC,wBAAwBd,iBAAiBG,MAAM,CACnD,CAACjB,KAAKF,QAAQoB,cAAcC;QAC1B,MAAM,EAAElB,KAAKmB,SAAS,EAAE,GAAGS,IAAAA,wDAA0B,EAAC;YACpDP,KAAKxB;YACLQ;YACAC;QACF;QACA,OAAOV,uBAAuB;YAC5BC;YACAC;YACAC;YACAkB;YACAC;YACAlB,KAAKmB;QACP;IACF,GACA,EAAE;IAGJ,MAAMU,qBAAqBF,sBAAsBD,IAAI,CAAC;IAEtD,MAAMI,qBAAqBzB,YAAYC,QAAQ,CAACG,MAAM,CAAC,CAACK;QACtD,OACER,SAASyB,SAAS,CAAC,CAACV;YAClB,MAAMW,kBAAkBX,IAAIV,KAAK,CAAC,IAAI,CAAC,EAAE;YACzC,OAAOqB,oBAAoBlB,QAAQF,IAAI;QACzC,OAAO,CAAC;IAEZ;IACA,MAAMqB,wBAAwBC,IAAAA,kDAA0B,EACtDJ,oBACAzB;IAGF,IAAI8B,oCAAoC;IACxCF,sBAAsBG,OAAO,CAAC,CAACC,QAAQC;QACrC,MAAMC,UAAUf,IAAAA,sCAAkB,EAACa;QACnCF,qCAAqC,CAAC,EAAEE,OAAO,IAAI,EAAEE,QAAQ,CAAC;QAC9D,IAAID,UAAUL,sBAAsBO,MAAM,GAAG,GAAG;YAC9CL,qCAAqC;QACvC;IACF;IAEA,MAAMM,cAAc;QAClBhB;QACAI;QACAM;KACD;IAED,OAAOM,YAAYhC,MAAM,CAAC,CAACiC,MAAQA,IAAIF,MAAM,GAAG,GAAGd,IAAI,CAAC;AAC1D"}

package/src/get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections.ts"],"sourcesContent":["import { getSelectReplacedSql } from '../cube-measure-transformer/cube-measure-transformer';\nimport { Query, TableSchema } from '../types/cube-types';\nimport { getAliasedColumnsFromFilters } from './get-aliased-columns-from-filters';\nimport {\n  getProjectionClause\n} from './get-projection-clause';\n\ninterface GetWrappedBaseQueryWithProjectionsParams {\n  baseQuery: string;\n  tableSchema: TableSchema;\n  query: Query;\n}\n\nexport const getWrappedBaseQueryWithProjections = ({\n  baseQuery,\n  tableSchema,\n  query,\n}: GetWrappedBaseQueryWithProjectionsParams) => {\n  /*\n   * Im order to be able to filter on computed metric from a query, we need to project the computed metric in the base query.\n   * If theres filters supplied, we can safely return the original base query. Since nothing need to be projected and filtered in this case\n   */\n  // Wrap the query into another 'SELECT * FROM (baseQuery) AS baseTable'' in order to project everything in the base query, and other computed metrics to be able to filter on them\n  const newBaseSql = `SELECT * FROM (${baseQuery}) AS ${tableSchema.name}`;\n  const aliasedColumnSet = new Set<string>();\n\n  const memberProjections = getProjectionClause(\n    query,\n    tableSchema,\n    aliasedColumnSet\n  );\n\n  const aliasFromFilters = getAliasedColumnsFromFilters({\n    aliasedColumnSet,\n    baseSql: 'SELECT *',\n    // setting measures to empty array, since we don't want to project measures present in the filters in the base query\n    tableSchema: tableSchema,\n    query,\n    meerkatFilters: query.filters,\n  });\n\n  const formattedMemberProjection = memberProjections\n    ? `, ${memberProjections}`\n    : '';\n\n  const finalAliasedColumnsClause =\n    aliasFromFilters + formattedMemberProjection;\n\n  const sqlWithFilterProjects = getSelectReplacedSql(\n    newBaseSql,\n    finalAliasedColumnsClause\n  );\n  return sqlWithFilterProjects;\n};\n"],"names":["getWrappedBaseQueryWithProjections","baseQuery","tableSchema","query","newBaseSql","name","aliasedColumnSet","Set","memberProjections","getProjectionClause","aliasFromFilters","getAliasedColumnsFromFilters","baseSql","meerkatFilters","filters","formattedMemberProjection","finalAliasedColumnsClause","sqlWithFilterProjects","getSelectReplacedSql"],"mappings":";+BAaaA;;;eAAAA;;;wCAbwB;8CAEQ;qCAGtC;AAQA,MAAMA,qCAAqC,CAAC,EACjDC,SAAS,EACTC,WAAW,EACXC,KAAK,EACoC;IACzC;;;GAGC,GACD,kLAAkL;IAClL,MAAMC,aAAa,CAAC,eAAe,EAAEH,UAAU,KAAK,EAAEC,YAAYG,IAAI,CAAC,CAAC;IACxE,MAAMC,mBAAmB,IAAIC;IAE7B,MAAMC,oBAAoBC,IAAAA,wCAAmB,EAC3CN,OACAD,aACAI;IAGF,MAAMI,mBAAmBC,IAAAA,0DAA4B,EAAC;QACpDL;QACAM,SAAS;QACT,oHAAoH;QACpHV,aAAaA;QACbC;QACAU,gBAAgBV,MAAMW,OAAO;IAC/B;IAEA,MAAMC,4BAA4BP,oBAC9B,CAAC,EAAE,EAAEA,kBAAkB,CAAC,GACxB;IAEJ,MAAMQ,4BACJN,mBAAmBK;IAErB,MAAME,wBAAwBC,IAAAA,4CAAoB,EAChDd,YACAY;IAEF,OAAOC;AACT"}

package/src/get-wrapped-base-query-with-projections/sql-expression-modifiers.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/get-wrapped-base-query-with-projections/sql-expression-modifiers.ts"],"sourcesContent":["import { Dimension, Query } from \"../types/cube-types\";\nimport { isArrayTypeMember } from \"../utils/is-array-member-type\";\n\nexport interface DimensionModifier {\n  sqlExpression: string,\n  dimension: Dimension,\n  key: string,\n  query: Query\n}\n\nexport const arrayFieldUnNestModifier = ({ sqlExpression }: DimensionModifier): string => {\n return `array[unnest(${sqlExpression})]`;\n}\n\nexport const shouldUnnest = ({ dimension, query }: DimensionModifier): boolean => {\n  const isArrayType =  isArrayTypeMember(dimension.type);\n  const hasUnNestedGroupBy = dimension.modifier?.shouldUnnestGroupBy;\n  return !!(isArrayType && hasUnNestedGroupBy && query.measures.length > 0);\n}\n\n\nexport type Modifier = {\n  name: string,\n  matcher: (modifier: DimensionModifier) => boolean,\n  modifier: (modifier: DimensionModifier) => string\n}\n\nexport const MODIFIERS: Modifier[] = [{\n  name: 'shouldUnnestGroupBy',\n  matcher: shouldUnnest,\n  modifier: arrayFieldUnNestModifier\n}]\n\n\nexport const getModifiedSqlExpression = ({ sqlExpression, dimension, key, modifiers, query }: DimensionModifier & {\n  modifiers: Modifier[]\n}) => {\n  let finalDimension: string = sqlExpression;\n  modifiers.forEach(({ modifier, matcher }) => {\n    const shouldModify = matcher({ sqlExpression: finalDimension, dimension, key, query });\n    if (shouldModify) {\n      finalDimension = modifier({ sqlExpression: finalDimension, dimension, key, query });\n    }\n  })\n  return finalDimension;\n} "],"names":["arrayFieldUnNestModifier","shouldUnnest","MODIFIERS","getModifiedSqlExpression","sqlExpression","dimension","query","isArrayType","isArrayTypeMember","type","hasUnNestedGroupBy","modifier","shouldUnnestGroupBy","measures","length","name","matcher","key","modifiers","finalDimension","forEach","shouldModify"],"mappings":";;;;;;;;IAUaA,wBAAwB;eAAxBA;;IAIAC,YAAY;eAAZA;;IAaAC,SAAS;eAATA;;IAOAC,wBAAwB;eAAxBA;;;mCAjCqB;AAS3B,MAAMH,2BAA2B,CAAC,EAAEI,aAAa,EAAqB;IAC5E,OAAO,CAAC,aAAa,EAAEA,cAAc,EAAE,CAAC;AACzC;AAEO,MAAMH,eAAe,CAAC,EAAEI,SAAS,EAAEC,KAAK,EAAqB;QAEvCD;IAD3B,MAAME,cAAeC,IAAAA,oCAAiB,EAACH,UAAUI,IAAI;IACrD,MAAMC,sBAAqBL,sBAAAA,UAAUM,QAAQ,qBAAlBN,oBAAoBO,mBAAmB;IAClE,OAAO,CAAC,CAAEL,CAAAA,eAAeG,sBAAsBJ,MAAMO,QAAQ,CAACC,MAAM,GAAG,CAAA;AACzE;AASO,MAAMZ,YAAwB;IAAC;QACpCa,MAAM;QACNC,SAASf;QACTU,UAAUX;IACZ;CAAE;AAGK,MAAMG,2BAA2B,CAAC,EAAEC,aAAa,EAAEC,SAAS,EAAEY,GAAG,EAAEC,SAAS,EAAEZ,KAAK,EAEzF;IACC,IAAIa,iBAAyBf;IAC7Bc,UAAUE,OAAO,CAAC,CAAC,EAAET,QAAQ,EAAEK,OAAO,EAAE;QACtC,MAAMK,eAAeL,QAAQ;YAAEZ,eAAee;YAAgBd;YAAWY;YAAKX;QAAM;QACpF,IAAIe,cAAc;YAChBF,iBAAiBR,SAAS;gBAAEP,eAAee;gBAAgBd;gBAAWY;gBAAKX;YAAM;QACnF;IACF;IACA,OAAOa;AACT"}

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../meerkat-core/src/index.ts"],"sourcesContent":["export * from './ast-builder/ast-builder';\nexport * from './ast-deserializer/ast-deserializer';\nexport * from './ast-serializer/ast-serializer';\nexport * from './ast-validator';\nexport { detectApplyContextParamsToBaseSQL } from './context-params/context-params-ast';\nexport * from './cube-measure-transformer/cube-measure-transformer';\nexport * from './cube-to-duckdb/cube-filter-to-duckdb';\nexport {\n  applyFilterParamsToBaseSQL,\n  detectAllFilterParamsFromSQL,\n  getFilterParamsAST,\n} from './filter-params/filter-params-ast';\nexport { getFilterParamsSQL } from './get-filter-params-sql/get-filter-params-sql';\nexport { getFinalBaseSQL } from './get-final-base-sql/get-final-base-sql';\nexport { getWrappedBaseQueryWithProjections } from './get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections';\nexport * from './joins/joins';\nexport { FilterType } from './types/cube-types';\nexport * from './types/cube-types/index';\nexport * from './types/duckdb-serialization-types/index';\nexport * from './types/utils';\nexport { BASE_TABLE_NAME } from './utils/base-ast';\nexport * from './utils/cube-to-table-schema';\nexport * from './utils/get-column-names-from-ast';\nexport * from './utils/get-possible-nodes';\nexport { meerkatPlaceholderReplacer } from './utils/meerkat-placeholder-replacer';\nexport { memberKeyToSafeKey } from './utils/member-key-to-safe-key';\n"],"names":["detectApplyContextParamsToBaseSQL","applyFilterParamsToBaseSQL","detectAllFilterParamsFromSQL","getFilterParamsAST","getFilterParamsSQL","getFinalBaseSQL","getWrappedBaseQueryWithProjections","FilterType","BASE_TABLE_NAME","meerkatPlaceholderReplacer","memberKeyToSafeKey"],"mappings":";;;;;;;;IAISA,iCAAiC;eAAjCA,mDAAiC;;IAIxCC,0BAA0B;eAA1BA,2CAA0B;;IAC1BC,4BAA4B;eAA5BA,6CAA4B;;IAC5BC,kBAAkB;eAAlBA,mCAAkB;;IAEXC,kBAAkB;eAAlBA,sCAAkB;;IAClBC,eAAe;eAAfA,gCAAe;;IACfC,kCAAkC;eAAlCA,sEAAkC;;IAElCC,UAAU;eAAVA,qBAAU;;IAIVC,eAAe;eAAfA,wBAAe;;IAIfC,0BAA0B;eAA1BA,sDAA0B;;IAC1BC,kBAAkB;eAAlBA,sCAAkB;;;;uBAzBb;uBACA;uBACA;uBACA;kCACoC;uBACpC;uBACA;iCAKP;oCAC4B;iCACH;oDACmB;uBACrC;2BACa;uBACb;uBACA;uBACA;yBACkB;uBAClB;uBACA;uBACA;4CAC6B;oCACR"}

package/src/joins/joins.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/joins/joins.ts"],"sourcesContent":["import { JoinPath, Query, TableSchema, isJoinNode } from '../types/cube-types';\n\nexport type Graph = {\n  [key: string]: { [key: string]: { [key: string]: string } };\n};\n\nexport function generateSqlQuery(\n  path: JoinPath[],\n  tableSchemaSqlMap: { [key: string]: string },\n  directedGraph: Graph\n): string {\n  if (path.length === 0) {\n    throw new Error(\n      'Invalid path, multiple data sources are present without a join path.'\n    );\n  }\n\n  const startingNode = path[0][0].left;\n  let query = `${tableSchemaSqlMap[startingNode]}`;\n\n  /**\n   * If the starting node is not a join node, then return the query as is.\n   * It means that the query is a single node query.\n   */\n  if (!isJoinNode(path[0][0])) {\n    return query;\n  }\n\n  const visitedNodes = new Map();\n\n  for (let i = 0; i < path.length; i++) {\n    if (path[i][0].left !== startingNode) {\n      throw new Error(\n        'Invalid path, starting node is not the same for all paths.'\n      );\n    }\n    for (let j = 0; j < path[i].length; j++) {\n      const currentEdge = path[i][j];\n\n      if (!isJoinNode(currentEdge)) {\n        continue;\n      }\n\n      const visitedFrom = visitedNodes.get(currentEdge.right);\n\n      // If node is already visited from the same edge, continue to next iteration\n      if (visitedFrom && visitedFrom.left === currentEdge.left) {\n        continue;\n      }\n      // If node is already visited from a different edge, throw ambiguity error\n      if (visitedFrom) {\n        throw new Error(\n          `Path ambiguity, node ${currentEdge.right} visited from different sources`\n        );\n      }\n\n      // If visitedFrom is undefined, this is the first visit to the node\n      visitedNodes.set(currentEdge.right, currentEdge);\n\n      query += ` LEFT JOIN (${tableSchemaSqlMap[currentEdge.right]}) AS ${currentEdge.right\n        }  ON ${directedGraph[currentEdge.left][currentEdge.right][currentEdge.on]\n        }`;\n    }\n  }\n\n  return query;\n}\n\nexport const createDirectedGraph = (\n  tableSchema: TableSchema[],\n  tableSchemaSqlMap: { [key: string]: string }\n) => {\n  const directedGraph: {\n    [key: string]: { [key: string]: { [key: string]: string } };\n  } = {};\n\n  function addEdge(\n    table1: string,\n    table2: string,\n    joinOn: string,\n    joinCondition: string\n  ) {\n    if (\n      table1 === table2 ||\n      (directedGraph[table1] &&\n        directedGraph[table1][table2] &&\n        directedGraph[table1][table2][joinOn])\n    ) {\n      throw new Error('An invalid path was detected.');\n    }\n    if (!directedGraph[table1]) directedGraph[table1] = {};\n    if (!directedGraph[table1][table2]) directedGraph[table1][table2] = {};\n    directedGraph[table1][table2][joinOn] = joinCondition;\n  }\n  /**\n   * Iterate through the table schema and add the edges to the directed graph.\n   * The edges are added based on the join conditions provided in the table schema.\n   * The SQL is split by the '=' sign and the tables columns involved in the joins are extracted.\n   * The tables are then added as edges to the directed graph.\n   */\n  tableSchema.forEach((schema) => {\n    schema?.joins?.forEach((join) => {\n      const tables = join.sql.split('=').map((str) => str.split('.')[0].trim());\n      const conditions = join.sql\n        .split('=')\n        .map((str) => str.split('.')[1].trim());\n\n      /**\n       * If the join SQL does not contain exactly 2 tables, then the join is invalid.\n       */\n      if (tables.length !== 2) {\n        throw new Error(`Invalid join SQL: ${join.sql}`);\n      }\n\n      /**\n       * If the tables are the same, then the join is invalid.\n       */\n      if (tables[0] === tables[1]) {\n        throw new Error(`Invalid join SQL: ${join.sql}`);\n      }\n\n      /**\n       * If the tables are not found in the table schema, then the join is invalid.\n       */\n\n      if (tables[0] !== schema.name && tables[1] !== schema.name) {\n        throw new Error(\n          `Table \"${schema.name}\" not found in provided join SQL: ${join.sql}`\n        );\n      }\n\n      /**\n       * Check if the tables are found in the table schema SQL map.\n       */\n      if (!tableSchemaSqlMap[tables[0]] || !tableSchemaSqlMap[tables[1]]) {\n        return;\n      }\n      /**\n       * If the table is the source table, then add the edge from the source to the target.\n       * Thus find which table is the source and which is the target and add the edge accordingly.\n       */\n      if (tables[0] === schema.name) {\n        addEdge(tables[0], tables[1], conditions[0], join.sql);\n      } else {\n        addEdge(tables[1], tables[0], conditions[1], join.sql);\n      }\n    });\n  });\n\n  return directedGraph;\n};\n\n\nexport const checkLoopInJoinPath = (joinPath: JoinPath[]) => {\n  for (let i = 0; i < joinPath.length; i++) {\n    const visitedNodes = new Set<string>();\n    const currentJoinPath = joinPath[i];\n    visitedNodes.add(currentJoinPath[0].left);\n    for (let j = 0; j < currentJoinPath.length; j++) {\n      const currentEdge = currentJoinPath[j];\n      if (isJoinNode(currentEdge) && visitedNodes.has(currentEdge.right)) {\n        if (visitedNodes.has(currentEdge.right)) {\n          return true;\n        }\n        visitedNodes.add(currentEdge.right);\n      }\n    }\n  }\n  return false\n}\n\nexport const getCombinedTableSchema = async (\n  tableSchema: TableSchema[],\n  cubeQuery: Query\n) => {\n  if (tableSchema.length === 1) {\n    return tableSchema[0];\n  }\n\n  const tableSchemaSqlMap = tableSchema.reduce(\n    (acc: { [key: string]: string }, schema: TableSchema) => {\n      return { ...acc, [schema.name]: schema.sql };\n    },\n    {}\n  );\n\n  const directedGraph = createDirectedGraph(tableSchema, tableSchemaSqlMap);\n  const hasLoop = checkLoopInJoinPath(cubeQuery.joinPaths || []);\n  if (hasLoop) {\n    throw new Error(`A loop was detected in the joins. ${JSON.stringify(cubeQuery.joinPaths || [])}`);\n  }\n\n  const baseSql = generateSqlQuery(\n    cubeQuery.joinPaths || [],\n    tableSchemaSqlMap,\n    directedGraph\n  );\n\n  const combinedTableSchema = tableSchema.reduce(\n    (acc: TableSchema, schema: TableSchema) => {\n      return {\n        name: 'MEERKAT_GENERATED_TABLE',\n        sql: baseSql,\n        measures: [...acc.measures, ...schema.measures],\n        dimensions: [...acc.dimensions, ...schema.dimensions],\n        joins: [],\n      };\n    },\n    {\n      name: '',\n      sql: '',\n      measures: [],\n      dimensions: [],\n      joins: [],\n    }\n  );\n  return combinedTableSchema;\n};\n"],"names":["generateSqlQuery","createDirectedGraph","checkLoopInJoinPath","getCombinedTableSchema","path","tableSchemaSqlMap","directedGraph","length","Error","startingNode","left","query","isJoinNode","visitedNodes","Map","i","j","currentEdge","visitedFrom","get","right","set","on","tableSchema","addEdge","table1","table2","joinOn","joinCondition","forEach","schema","joins","join","tables","sql","split","map","str","trim","conditions","name","joinPath","Set","currentJoinPath","add","has","cubeQuery","reduce","acc","hasLoop","joinPaths","JSON","stringify","baseSql","combinedTableSchema","measures","dimensions"],"mappings":"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"}

package/src/types/cube-types/index.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/types/cube-types/index.d.ts"],"sourcesContent":["export * from './query';\nexport * from './table';\n"],"names":[],"mappings":";;uBAAc;uBACA"}

package/src/types/cube-types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/types/cube-types/index.ts"],"sourcesContent":["export * from './query';\nexport * from './table';\n"],"names":[],"mappings":";;uBAAc;uBACA"}

package/src/types/cube-types/query.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/types/cube-types/query.d.ts"],"sourcesContent":["/**\n * Request type data type.\n */\ntype RequestType = 'multi';\n/**\n * Result type data type.\n */\ntype ResultType = 'default' | 'compact';\n/**\n * API type data type.\n */\ntype ApiType = 'sql' | 'graphql' | 'rest' | 'ws' | 'stream';\n/**\n * Parsed query type data type.\n */\ntype QueryType = 'regularQuery' | 'compareDateRangeQuery' | 'blendingQuery';\n/**\n * String that represent query member type.\n */\ntype MemberType = 'measures' | 'dimensions' | 'segments';\n/**\n * Member identifier. Should satisfy to the following regexp: /^[a-zA-Z0-9_]+\\.[a-zA-Z0-9_]+$/\n */\ntype Member = string;\n/**\n * Datetime member identifier. Should satisfy to the following\n * regexp: /^[a-zA-Z0-9_]+\\.[a-zA-Z0-9_]+(\\.(second|minute|hour|day|week|month|year))?$/\n */\ntype TimeMember = string;\n/**\n * Filter operator string.\n */\ntype FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'in' | 'notIn' | 'gt' | 'gte' | 'lt' | 'lte' | 'set' | 'notSet' | 'inDateRange' | 'notInDateRange' | 'onTheDate' | 'beforeDate' | 'afterDate' | 'measureFilter';\n/**\n * Time dimension granularity data type.\n */\ntype QueryTimeDimensionGranularity = 'quarter' | 'day' | 'month' | 'year' | 'week' | 'hour' | 'minute' | 'second';\n/**\n * Query order data type.\n */\ntype QueryOrderType = 'asc' | 'desc';\n/**\n * ApiScopes data type.\n */\ntype ApiScopes = 'graphql' | 'meta' | 'data' | 'jobs';\ninterface QueryFilter {\n    member: Member;\n    operator: FilterOperator;\n    values?: string[];\n}\n/**\n * Query 'and'-filters type definition.\n */\ntype LogicalAndFilter = {\n    and: (QueryFilter | {\n        or: (QueryFilter | LogicalAndFilter)[];\n    })[];\n};\n/**\n * Query 'or'-filters type definition.\n */\ntype LogicalOrFilter = {\n    or: (QueryFilter | LogicalAndFilter)[];\n};\n/**\n * Query datetime dimention interface.\n */\ninterface QueryTimeDimension {\n    dimension: Member;\n    dateRange?: string[] | string;\n    granularity?: QueryTimeDimensionGranularity;\n}\n/**\n * Incoming network query data type.\n */\ninterface Query {\n    measures: Member[];\n    dimensions?: (Member | TimeMember)[];\n    filters?: (QueryFilter | LogicalAndFilter | LogicalOrFilter)[];\n    timeDimensions?: QueryTimeDimension[];\n    segments?: Member[];\n    limit?: null | number;\n    offset?: number;\n    total?: boolean;\n    totalQuery?: boolean;\n    order?: any;\n    timezone?: string;\n    renewQuery?: boolean;\n    ungrouped?: boolean;\n    responseFormat?: ResultType;\n}\n/**\n * Normalized filter interface.\n */\ninterface NormalizedQueryFilter extends QueryFilter {\n    dimension?: Member;\n}\n/**\n * Normalized query interface.\n */\ninterface NormalizedQuery extends Query {\n    filters?: NormalizedQueryFilter[];\n    rowLimit?: null | number;\n    order?: [{\n        id: string;\n        desc: boolean;\n    }];\n}\nexport { ApiScopes, ApiType, FilterOperator, LogicalAndFilter, LogicalOrFilter, Member, MemberType, NormalizedQuery, NormalizedQueryFilter, Query, QueryFilter, QueryOrderType, QueryTimeDimension, QueryTimeDimensionGranularity, QueryType, RequestType, ResultType, TimeMember, };\n"],"names":[],"mappings":"AAAA;;CAEC"}

package/src/types/cube-types/query.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/types/cube-types/query.ts"],"sourcesContent":["/**\n * Request type data type.\n */\ntype RequestType = 'multi';\n\n/**\n * Result type data type.\n */\ntype ResultType = 'default' | 'compact';\n\n/**\n * API type data type.\n */\ntype ApiType = 'sql' | 'graphql' | 'rest' | 'ws' | 'stream';\n\n/**\n * Parsed query type data type.\n */\ntype QueryType = 'regularQuery' | 'compareDateRangeQuery' | 'blendingQuery';\n\n/**\n * String that represent query member type.\n */\ntype MemberType = 'measures' | 'dimensions' | 'segments';\n\n/**\n * Member identifier. Should satisfy to the following regexp: /^[a-zA-Z0-9_]+\\.[a-zA-Z0-9_]+$/\n */\ntype Member = string;\n\n\n/**\n * Filter operator string.\n */\ntype FilterOperator =\n  | 'equals'\n  | 'notEquals'\n  | 'contains'\n  | 'notContains'\n  | 'in'\n  | 'notIn'\n  | 'gt'\n  | 'gte'\n  | 'lt'\n  | 'lte'\n  | 'set'\n  | 'notSet'\n  | 'inDateRange'\n  | 'notInDateRange'\n  | 'onTheDate'\n  | 'beforeDate'\n  | 'afterDate'\n  | 'measureFilter';\n\n/**\n * Query order data type.\n */\ntype QueryOrderType = 'asc' | 'desc';\n\n/**\n * ApiScopes data type.\n */\ntype ApiScopes = 'graphql' | 'meta' | 'data' | 'jobs';\n\nexport type FilterType = 'BASE_FILTER' | 'PROJECTION_FILTER';\n\ninterface QueryFilter {\n  member: Member;\n  operator: FilterOperator;\n  values?: string[];\n}\n\n/**\n * Query 'and'-filters type definition.\n */\ntype LogicalAndFilter = {\n  and: (QueryFilter | { or: (QueryFilter | LogicalAndFilter)[] })[];\n};\n\n/**\n * Query 'or'-filters type definition.\n */\ntype LogicalOrFilter = {\n  or: (QueryFilter | LogicalAndFilter)[];\n};\n\n\n/**\n * Join Edge data type.\n */\n\ninterface JoinNode {\n  /**\n   * Left node.\n   */\n  left: Member;\n\n  /**\n   * Right node.\n   */\n  right: Member;\n\n  /**\n   * On condition.\n   */\n  on: string;\n\n  /**\n   * Example\n   * [\n   *  [\n   *    {\n   *      left:  dim_ticket,\n   *      right: dim_user\n   *      on: 'created_by_id'\n   *    },\n   *   {\n   *     left : dim_user,\n   *     right: dim_user_role,\n   *     on: 'role_id'\n   *   }\n   *  ]\n   * ]\n   *\n   *\n   */\n}\n\n/**\n * Single node data type.\n * This is the case when there is no join. Just a single node.\n */\ninterface SingleNode {\n  /**\n   * Left node.\n   */\n  left: Member;\n}\n\ntype JoinPath = [JoinNode | SingleNode, ...JoinNode[]];\n\nexport const isJoinNode = (node: JoinNode | SingleNode): node is JoinNode => {\n  return 'right' in node;\n};\n\n/**\n * Incoming network query data type.\n */\n\ntype MeerkatQueryFilter = QueryFilter | LogicalAndFilter | LogicalOrFilter;\n\ninterface Query {\n  measures: Member[];\n  dimensions?: Member[];\n  filters?: MeerkatQueryFilter[];\n  joinPaths?: JoinPath[];\n  limit?: null | number;\n  offset?: number;\n  order?: Record<string, QueryOrderType>;\n}\n\n\nexport {\n  ApiScopes,\n  ApiType,\n  FilterOperator,\n  JoinPath,\n  LogicalAndFilter,\n  LogicalOrFilter,\n  MeerkatQueryFilter,\n  Member,\n  MemberType,\n  Query,\n  QueryFilter,\n  QueryOrderType,\n  QueryType,\n  RequestType,\n  ResultType\n};\n"],"names":["isJoinNode","node"],"mappings":"AAAA;;CAEC;+BA2IYA;;;eAAAA;;;AAAN,MAAMA,aAAa,CAACC;IACzB,OAAO,WAAWA;AACpB"}

package/src/types/cube-types/table.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/types/cube-types/table.d.ts"],"names":[],"mappings":""}

package/src/types/cube-types/table.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/types/cube-types/table.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/index.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/types/duckdb-serialization-types/index.d.ts"],"sourcesContent":["export * from './serialization/Expression';\nexport * from './serialization/Nodes';\nexport * from './serialization/ParsedExpression';\nexport * from './serialization/QueryNode';\nexport * from './serialization/ResultModifier';\nexport * from './serialization/Statement';\nexport * from './serialization/TableRef';\n"],"names":[],"mappings":";;uBAAc;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA"}

package/src/types/duckdb-serialization-types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../meerkat-core/src/types/duckdb-serialization-types/index.ts"],"sourcesContent":["export * from './serialization/Expression';\nexport * from './serialization/Nodes';\nexport * from './serialization/ParsedExpression';\nexport * from './serialization/QueryNode';\nexport * from './serialization/ResultModifier';\nexport * from './serialization/Statement';\nexport * from './serialization/TableRef';\n"],"names":[],"mappings":";;uBAAc;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA"}

package/src/types/duckdb-serialization-types/serialization/Constraint.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Constraint.ts"],"sourcesContent":["import { ParsedExpression } from './ParsedExpression';\n\nexport enum ConstraintType {\n  INVALID = 'INVALID',\n  NOT_NULL = 'NOT_NULL',\n  CHECK = 'CHECK',\n  UNIQUE = 'UNIQUE',\n  FOREIGN_KEY = 'FOREIGN_KEY',\n}\n\nexport enum ForeignKeyType {\n  FK_TYPE_PRIMARY_KEY_TABLE = 'FK_TYPE_PRIMARY_KEY_TABLE',\n  FK_TYPE_FOREIGN_KEY_TABLE = 'FK_TYPE_FOREIGN_KEY_TABLE',\n  FK_TYPE_SELF_REFERENCE_TABLE = 'FK_TYPE_SELF_REFERENCE_TABLE',\n}\n\nexport interface BaseConstraint {\n  type: ConstraintType;\n}\n\nexport type Constraint = NotNullConstraint | CheckConstraint | ForeignKeyConstraint | UniqueConstraint;\n\nexport interface LogicalIndex {\n  index: number;\n}\n\nexport interface PhysicalIndex {\n  index: number;\n}\n\nexport interface NotNullConstraint extends BaseConstraint {\n  enum: 'NOT_NULL';\n  index: LogicalIndex;\n}\n\nexport interface CheckConstraint extends BaseConstraint {\n  enum: 'CHECK';\n  expression: ParsedExpression;\n}\n\nexport interface ForeignKeyConstraint extends BaseConstraint {\n  enum: 'FOREIGN_KEY';\n  pk_columns: string[];\n  fk_columns: string[];\n  fk_type: ForeignKeyType;\n  schema: string;\n  table: string;\n  pk_keys: PhysicalIndex[];\n  fk_keys: PhysicalIndex[];\n}\n\nexport interface UniqueConstraint extends BaseConstraint {\n  enum: 'UNIQUE';\n  is_primary_key: boolean;\n  index: LogicalIndex;\n  columns: string[];\n}\n"],"names":["ConstraintType","INVALID","NOT_NULL","CHECK","UNIQUE","FOREIGN_KEY","ForeignKeyType","FK_TYPE_PRIMARY_KEY_TABLE","FK_TYPE_FOREIGN_KEY_TABLE","FK_TYPE_SELF_REFERENCE_TABLE"],"mappings":";;;;;;;;;;;;;;;IAEO;UAAKA,cAAc;IAAdA,eACVC,aAAAA;IADUD,eAEVE,cAAAA;IAFUF,eAGVG,WAAAA;IAHUH,eAIVI,YAAAA;IAJUJ,eAKVK,iBAAAA;GALUL,mBAAAA;IAQL;UAAKM,cAAc;IAAdA,eACVC,+BAAAA;IADUD,eAEVE,+BAAAA;IAFUF,eAGVG,kCAAAA;GAHUH,mBAAAA"}

package/src/types/duckdb-serialization-types/serialization/CreateInfo.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/CreateInfo.ts"],"sourcesContent":["import { Constraint } from './Constraint';\nimport { MacroFunction } from './MacroFunction';\nimport { Value } from './Misc';\nimport { ColumnList, LogicalType } from './Nodes';\nimport { ParsedExpression } from './ParsedExpression';\nimport { SelectStatement } from './Statement';\n\nexport enum OnCreateConflict {\n  ERROR_ON_CONFLICT = 'ERROR_ON_CONFLICT',\n  IGNORE_ON_CONFLICT = 'IGNORE_ON_CONFLICT',\n  REPLACE_ON_CONFLICT = 'REPLACE_ON_CONFLICT',\n  ALTER_ON_CONFLICT = 'ALTER_ON_CONFLICT',\n}\n\nexport enum CatalogType {\n  INVALID = 'INVALID',\n  TABLE_ENTRY = 'TABLE_ENTRY',\n  SCHEMA_ENTRY = 'SCHEMA_ENTRY',\n  VIEW_ENTRY = 'VIEW_ENTRY',\n  INDEX_ENTRY = 'INDEX_ENTRY',\n  PREPARED_STATEMENT = 'PREPARED_STATEMENT',\n  SEQUENCE_ENTRY = 'SEQUENCE_ENTRY',\n  COLLATION_ENTRY = 'COLLATION_ENTRY',\n  TYPE_ENTRY = 'TYPE_ENTRY',\n  DATABASE_ENTRY = 'DATABASE_ENTRY',\n\n  // functions\n  TABLE_FUNCTION_ENTRY = 'TABLE_FUNCTION_ENTRY',\n  SCALAR_FUNCTION_ENTRY = 'SCALAR_FUNCTION_ENTRY',\n  AGGREGATE_FUNCTION_ENTRY = 'AGGREGATE_FUNCTION_ENTRY',\n  PRAGMA_FUNCTION_ENTRY = 'PRAGMA_FUNCTION_ENTRY',\n  COPY_FUNCTION_ENTRY = 'COPY_FUNCTION_ENTRY',\n  MACRO_ENTRY = 'MACRO_ENTRY',\n  TABLE_MACRO_ENTRY = 'TABLE_MACRO_ENTRY',\n\n  // version info\n  UPDATED_ENTRY = 'UPDATED_ENTRY',\n  DELETED_ENTRY = 'DELETED_ENTRY',\n}\n\nexport interface BaseCreateInfo {\n  type: CatalogType;\n  catalog: string;\n  schema: string;\n  temporary: boolean;\n  internal: boolean;\n  on_conflict: OnCreateConflict;\n  sql: string;\n}\n\nexport type CreateInfo =\n  | CreateIndexInfo\n  | CreateTableInfo\n  | CreateSchemaInfo\n  | CreateViewInfo\n  | CreateTypeInfo\n  | CreateMacroInfo\n  | CreateSequenceInfo;\n\nexport enum IndexType {\n  INVALID = 'INVALID',\n  ART = 'ART',\n  EXTENSION = 'EXTENSION',\n}\n\nexport enum IndexConstraintType {\n  NONE = 'NONE',\n  UNIQUE = 'UNIQUE',\n  PRIMARY = 'PRIMARY',\n  FOREIGN = 'FOREIGN',\n}\n\nexport interface CreateIndexInfo extends BaseCreateInfo {\n  name: string;\n  table: string;\n  index_type: IndexType;\n  constraint_type: IndexConstraintType;\n  parsed_expressions: ParsedExpression[];\n  names: string[];\n  column_ids: number[];\n  options: Record<string, Value>;\n  index_type_name: string;\n}\n\nexport interface CreateTableInfo extends BaseCreateInfo {\n  table: string;\n  columns: ColumnList;\n  constraints: Constraint[];\n  query?: SelectStatement;\n}\n\nexport type CreateSchemaInfo = BaseCreateInfo\n\nexport interface CreateViewInfo extends BaseCreateInfo {\n  view_name: string;\n  aliases: string[];\n  types: LogicalType[];\n  query?: SelectStatement;\n}\n\nexport interface CreateTypeInfo extends BaseCreateInfo {\n  name: string;\n  logical_type: LogicalType;\n}\n\nexport interface CreateMacroInfo extends BaseCreateInfo {\n  name: string;\n  function: MacroFunction;\n}\n\nexport interface CreateSequenceInfo extends BaseCreateInfo {\n  name: string;\n  usage_count: number;\n  increment: number;\n  min_value: number;\n  max_value: number;\n  start_value: number;\n  cycle: boolean;\n}\n"],"names":["OnCreateConflict","ERROR_ON_CONFLICT","IGNORE_ON_CONFLICT","REPLACE_ON_CONFLICT","ALTER_ON_CONFLICT","CatalogType","INVALID","TABLE_ENTRY","SCHEMA_ENTRY","VIEW_ENTRY","INDEX_ENTRY","PREPARED_STATEMENT","SEQUENCE_ENTRY","COLLATION_ENTRY","TYPE_ENTRY","DATABASE_ENTRY","TABLE_FUNCTION_ENTRY","SCALAR_FUNCTION_ENTRY","AGGREGATE_FUNCTION_ENTRY","PRAGMA_FUNCTION_ENTRY","COPY_FUNCTION_ENTRY","MACRO_ENTRY","TABLE_MACRO_ENTRY","UPDATED_ENTRY","DELETED_ENTRY","IndexType","ART","EXTENSION","IndexConstraintType","NONE","UNIQUE","PRIMARY","FOREIGN"],"mappings":";;;;;;;;;;;;;;;;;;;;;IAOO;UAAKA,gBAAgB;IAAhBA,iBACVC,uBAAAA;IADUD,iBAEVE,wBAAAA;IAFUF,iBAGVG,yBAAAA;IAHUH,iBAIVI,uBAAAA;GAJUJ,qBAAAA;IAOL;UAAKK,WAAW;IAAXA,YACVC,aAAAA;IADUD,YAEVE,iBAAAA;IAFUF,YAGVG,kBAAAA;IAHUH,YAIVI,gBAAAA;IAJUJ,YAKVK,iBAAAA;IALUL,YAMVM,wBAAAA;IANUN,YAOVO,oBAAAA;IAPUP,YAQVQ,qBAAAA;IARUR,YASVS,gBAAAA;IATUT,YAUVU,oBAAAA;IAVUV,YAYV,YAAY;IACZW,0BAAAA;IAbUX,YAcVY,2BAAAA;IAdUZ,YAeVa,8BAAAA;IAfUb,YAgBVc,2BAAAA;IAhBUd,YAiBVe,yBAAAA;IAjBUf,YAkBVgB,iBAAAA;IAlBUhB,YAmBViB,uBAAAA;IAnBUjB,YAqBV,eAAe;IACfkB,mBAAAA;IAtBUlB,YAuBVmB,mBAAAA;GAvBUnB,gBAAAA;IA6CL;UAAKoB,SAAS;IAATA,UACVnB,aAAAA;IADUmB,UAEVC,SAAAA;IAFUD,UAGVE,eAAAA;GAHUF,cAAAA;IAML;UAAKG,mBAAmB;IAAnBA,oBACVC,UAAAA;IADUD,oBAEVE,YAAAA;IAFUF,oBAGVG,aAAAA;IAHUH,oBAIVI,aAAAA;GAJUJ,wBAAAA"}

package/src/types/duckdb-serialization-types/serialization/Expression.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Expression.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/Expression.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Expression.ts"],"sourcesContent":["import { Value } from './Misc';\nimport {\n  BoundCaseCheck,\n  BoundParameterData,\n  ColumnBinding,\n  LogicalType,\n} from './Nodes';\n\nexport enum ExpressionType {\n  INVALID = 'INVALID',\n  OPERATOR_CAST = 'OPERATOR_CAST',\n  OPERATOR_NOT = 'OPERATOR_NOT',\n  OPERATOR_IS_NULL = 'OPERATOR_IS_NULL',\n  OPERATOR_IS_NOT_NULL = 'OPERATOR_IS_NOT_NULL',\n  COMPARE_EQUAL = 'COMPARE_EQUAL',\n  COMPARE_BOUNDARY_START = 'COMPARE_BOUNDARY_START',\n  COMPARE_NOTEQUAL = 'COMPARE_NOTEQUAL',\n  COMPARE_LESSTHAN = 'COMPARE_LESSTHAN',\n  COMPARE_GREATERTHAN = 'COMPARE_GREATERTHAN',\n  COMPARE_LESSTHANOREQUALTO = 'COMPARE_LESSTHANOREQUALTO',\n  COMPARE_GREATERTHANOREQUALTO = 'COMPARE_GREATERTHANOREQUALTO',\n  COMPARE_IN = 'COMPARE_IN',\n  COMPARE_NOT_IN = 'COMPARE_NOT_IN',\n  COMPARE_DISTINCT_FROM = 'COMPARE_DISTINCT_FROM',\n  COMPARE_BETWEEN = 'COMPARE_BETWEEN',\n  COMPARE_NOT_BETWEEN = 'COMPARE_NOT_BETWEEN',\n  COMPARE_NOT_DISTINCT_FROM = 'COMPARE_NOT_DISTINCT_FROM',\n  COMPARE_BOUNDARY_END = 'COMPARE_BOUNDARY_END',\n  CONJUNCTION_AND = 'CONJUNCTION_AND',\n  CONJUNCTION_OR = 'CONJUNCTION_OR',\n  VALUE_CONSTANT = 'VALUE_CONSTANT',\n  VALUE_PARAMETER = 'VALUE_PARAMETER',\n  VALUE_TUPLE = 'VALUE_TUPLE',\n  VALUE_TUPLE_ADDRESS = 'VALUE_TUPLE_ADDRESS',\n  VALUE_NULL = 'VALUE_NULL',\n  VALUE_VECTOR = 'VALUE_VECTOR',\n  VALUE_SCALAR = 'VALUE_SCALAR',\n  VALUE_DEFAULT = 'VALUE_DEFAULT',\n  AGGREGATE = 'AGGREGATE',\n  BOUND_AGGREGATE = 'BOUND_AGGREGATE',\n  GROUPING_FUNCTION = 'GROUPING_FUNCTION',\n  WINDOW_AGGREGATE = 'WINDOW_AGGREGATE',\n  WINDOW_RANK = 'WINDOW_RANK',\n  WINDOW_RANK_DENSE = 'WINDOW_RANK_DENSE',\n  WINDOW_NTILE = 'WINDOW_NTILE',\n  WINDOW_PERCENT_RANK = 'WINDOW_PERCENT_RANK',\n  WINDOW_CUME_DIST = 'WINDOW_CUME_DIST',\n  WINDOW_ROW_NUMBER = 'WINDOW_ROW_NUMBER',\n  WINDOW_FIRST_VALUE = 'WINDOW_FIRST_VALUE',\n  WINDOW_LAST_VALUE = 'WINDOW_LAST_VALUE',\n  WINDOW_LEAD = 'WINDOW_LEAD',\n  WINDOW_LAG = 'WINDOW_LAG',\n  WINDOW_NTH_VALUE = 'WINDOW_NTH_VALUE',\n  FUNCTION = 'FUNCTION',\n  BOUND_FUNCTION = 'BOUND_FUNCTION',\n  CASE_EXPR = 'CASE_EXPR',\n  OPERATOR_NULLIF = 'OPERATOR_NULLIF',\n  OPERATOR_COALESCE = 'OPERATOR_COALESCE',\n  ARRAY_EXTRACT = 'ARRAY_EXTRACT',\n  ARRAY_SLICE = 'ARRAY_SLICE',\n  STRUCT_EXTRACT = 'STRUCT_EXTRACT',\n  ARRAY_CONSTRUCTOR = 'ARRAY_CONSTRUCTOR',\n  ARROW = 'ARROW',\n  SUBQUERY = 'SUBQUERY',\n  STAR = 'STAR',\n  TABLE_STAR = 'TABLE_STAR',\n  PLACEHOLDER = 'PLACEHOLDER',\n  COLUMN_REF = 'COLUMN_REF',\n  FUNCTION_REF = 'FUNCTION_REF',\n  TABLE_REF = 'TABLE_REF',\n  CAST = 'CAST',\n  BOUND_REF = 'BOUND_REF',\n  BOUND_COLUMN_REF = 'BOUND_COLUMN_REF',\n  BOUND_UNNEST = 'BOUND_UNNEST',\n  COLLATE = 'COLLATE',\n  LAMBDA = 'LAMBDA',\n  POSITIONAL_REFERENCE = 'POSITIONAL_REFERENCE',\n  BOUND_LAMBDA_REF = 'BOUND_LAMBDA_REF',\n}\n\nexport enum ExpressionClass {\n  INVALID = 'INVALID',\n  AGGREGATE = 'AGGREGATE',\n  CASE = 'CASE',\n  CAST = 'CAST',\n  COLUMN_REF = 'COLUMN_REF',\n  COMPARISON = 'COMPARISON',\n  CONJUNCTION = 'CONJUNCTION',\n  CONSTANT = 'CONSTANT',\n  DEFAULT = 'DEFAULT',\n  FUNCTION = 'FUNCTION',\n  OPERATOR = 'OPERATOR',\n  STAR = 'STAR',\n  SUBQUERY = 'SUBQUERY',\n  WINDOW = 'WINDOW',\n  PARAMETER = 'PARAMETER',\n  COLLATE = 'COLLATE',\n  LAMBDA = 'LAMBDA',\n  POSITIONAL_REFERENCE = 'POSITIONAL_REFERENCE',\n  BETWEEN = 'BETWEEN',\n  BOUND_AGGREGATE = 'BOUND_AGGREGATE',\n  BOUND_CASE = 'BOUND_CASE',\n  BOUND_CAST = 'BOUND_CAST',\n  BOUND_COLUMN_REF = 'BOUND_COLUMN_REF',\n  BOUND_COMPARISON = 'BOUND_COMPARISON',\n  BOUND_CONJUNCTION = 'BOUND_CONJUNCTION',\n  BOUND_CONSTANT = 'BOUND_CONSTANT',\n  BOUND_DEFAULT = 'BOUND_DEFAULT',\n  BOUND_FUNCTION = 'BOUND_FUNCTION',\n  BOUND_OPERATOR = 'BOUND_OPERATOR',\n  BOUND_PARAMETER = 'BOUND_PARAMETER',\n  BOUND_REF = 'BOUND_REF',\n  BOUND_SUBQUERY = 'BOUND_SUBQUERY',\n  BOUND_WINDOW = 'BOUND_WINDOW',\n  BOUND_BETWEEN = 'BOUND_BETWEEN',\n  BOUND_UNNEST = 'BOUND_UNNEST',\n  BOUND_LAMBDA = 'BOUND_LAMBDA',\n  BOUND_LAMBDA_REF = 'BOUND_LAMBDA_REF',\n  BOUND_EXPRESSION = 'BOUND_EXPRESSION',\n}\n\nexport interface BaseExpression {\n  expression_class: ExpressionClass;\n  type: ExpressionType;\n  alias: string;\n}\n\nexport type Expression =\n  | BoundBetweenExpression\n  | BoundCaseExpression\n  | BoundCastExpression\n  | BoundColumnRefExpression\n  | BoundComparisonExpression\n  | BoundConjunctionExpression\n  | BoundConstantExpression\n  | BoundDefaultExpression\n  | BoundLambdaExpression\n  | BoundLambdaRefExpression\n  | BoundOperatorExpression\n  | BoundParameterExpression\n  | BoundReferenceExpression\n  | BoundUnnestExpression\n  | BoundFunctionExpression\n  | BoundAggregateExpression\n  | BoundWindowExpression;\n\nexport interface BoundBetweenExpression extends BaseExpression {\n  input: Expression;\n  lower: Expression;\n  upper: Expression;\n  lower_inclusive: boolean;\n  upper_inclusive: boolean;\n}\n\nexport interface BoundCaseExpression extends BaseExpression {\n  return_type: LogicalType;\n  case_checks: BoundCaseCheck[];\n  else_expr: Expression;\n}\n\nexport interface BoundCastExpression extends BaseExpression {\n  child: Expression;\n  return_type: LogicalType;\n  try_cast: boolean;\n}\n\nexport interface BoundColumnRefExpression extends BaseExpression {\n  return_type: LogicalType;\n  binding: ColumnBinding;\n  depth: number;\n}\n\nexport interface BoundComparisonExpression extends BaseExpression {\n  left: Expression;\n  right: Expression;\n}\n\nexport interface BoundConjunctionExpression extends BaseExpression {\n  children: Expression[];\n}\n\nexport interface BoundConstantExpression extends BaseExpression {\n  value: Value;\n}\n\nexport interface BoundDefaultExpression extends BaseExpression {\n  return_type: LogicalType;\n}\n\nexport interface BoundLambdaExpression extends BaseExpression {\n  return_type: LogicalType;\n  lambda_expr: Expression;\n  captures: Expression[];\n  parameter_count: number;\n}\n\nexport interface BoundLambdaRefExpression extends BaseExpression {\n  return_type: LogicalType;\n  binding: ColumnBinding;\n  lambda_index: number;\n  depth: number;\n}\n\nexport interface BoundOperatorExpression extends BaseExpression {\n  return_type: LogicalType;\n  children: Expression[];\n}\n\nexport interface BoundParameterExpression extends BaseExpression {\n  identifier: string;\n  return_type: LogicalType;\n  parameter_data: BoundParameterData;\n}\n\nexport interface BoundReferenceExpression extends BaseExpression {\n  return_type: LogicalType;\n  index: number;\n}\n\nexport interface BoundUnnestExpression extends BaseExpression {\n  return_type: LogicalType;\n  child: Expression;\n}\n\nexport type BoundFunctionExpression = BaseExpression;\n\nexport type BoundAggregateExpression = BaseExpression;\n\nexport type BoundWindowExpression = BaseExpression;\n"],"names":["ExpressionType","INVALID","OPERATOR_CAST","OPERATOR_NOT","OPERATOR_IS_NULL","OPERATOR_IS_NOT_NULL","COMPARE_EQUAL","COMPARE_BOUNDARY_START","COMPARE_NOTEQUAL","COMPARE_LESSTHAN","COMPARE_GREATERTHAN","COMPARE_LESSTHANOREQUALTO","COMPARE_GREATERTHANOREQUALTO","COMPARE_IN","COMPARE_NOT_IN","COMPARE_DISTINCT_FROM","COMPARE_BETWEEN","COMPARE_NOT_BETWEEN","COMPARE_NOT_DISTINCT_FROM","COMPARE_BOUNDARY_END","CONJUNCTION_AND","CONJUNCTION_OR","VALUE_CONSTANT","VALUE_PARAMETER","VALUE_TUPLE","VALUE_TUPLE_ADDRESS","VALUE_NULL","VALUE_VECTOR","VALUE_SCALAR","VALUE_DEFAULT","AGGREGATE","BOUND_AGGREGATE","GROUPING_FUNCTION","WINDOW_AGGREGATE","WINDOW_RANK","WINDOW_RANK_DENSE","WINDOW_NTILE","WINDOW_PERCENT_RANK","WINDOW_CUME_DIST","WINDOW_ROW_NUMBER","WINDOW_FIRST_VALUE","WINDOW_LAST_VALUE","WINDOW_LEAD","WINDOW_LAG","WINDOW_NTH_VALUE","FUNCTION","BOUND_FUNCTION","CASE_EXPR","OPERATOR_NULLIF","OPERATOR_COALESCE","ARRAY_EXTRACT","ARRAY_SLICE","STRUCT_EXTRACT","ARRAY_CONSTRUCTOR","ARROW","SUBQUERY","STAR","TABLE_STAR","PLACEHOLDER","COLUMN_REF","FUNCTION_REF","TABLE_REF","CAST","BOUND_REF","BOUND_COLUMN_REF","BOUND_UNNEST","COLLATE","LAMBDA","POSITIONAL_REFERENCE","BOUND_LAMBDA_REF","ExpressionClass","CASE","COMPARISON","CONJUNCTION","CONSTANT","DEFAULT","OPERATOR","WINDOW","PARAMETER","BETWEEN","BOUND_CASE","BOUND_CAST","BOUND_COMPARISON","BOUND_CONJUNCTION","BOUND_CONSTANT","BOUND_DEFAULT","BOUND_OPERATOR","BOUND_PARAMETER","BOUND_SUBQUERY","BOUND_WINDOW","BOUND_BETWEEN","BOUND_LAMBDA","BOUND_EXPRESSION"],"mappings":"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"}

package/src/types/duckdb-serialization-types/serialization/LogicalOperator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/LogicalOperator.ts"],"sourcesContent":["import { PhysicalIndex } from './Constraint';\nimport { CreateInfo } from './CreateInfo';\nimport { Expression } from './Expression';\nimport { ColumnDataCollection, Value } from './Misc';\nimport {\n  BoundOrderByNode,\n  BoundPivotInfo,\n  CTEMaterialize,\n  ColumnBinding,\n  JoinCondition,\n  LogicalType,\n  SampleOptions,\n} from './Nodes';\nimport { ParseInfo } from './ParseInfo';\nimport { BoundOrderModifier } from './ResultModifier';\nimport { JoinType } from './TableRef';\n\nexport interface BaseLogicalOperator {\n  id?: number;\n  name?: string;\n  type: string;\n  children?: LogicalOperator[];\n}\n\nexport type LogicalOperator =\n  | LogicalProjection\n  | LogicalFilter\n  | LogicalAggregate\n  | LogicalWindow\n  | LogicalUnnest\n  | LogicalLimit\n  | LogicalOrder\n  | LogicalTopN\n  | LogicalDistinct\n  | LogicalSample\n  | LogicalLimitPercent\n  | LogicalColumnDataGet\n  | LogicalDelimGet\n  | LogicalExpressionGet\n  | LogicalDummyScan\n  | LogicalEmptyResult\n  | LogicalCTERef\n  | LogicalComparisonJoin\n  | LogicalAnyJoin\n  | LogicalCrossProduct\n  | LogicalPositionalJoin\n  | LogicalSetOperation\n  | LogicalRecursiveCTE\n  | LogicalMaterializedCTE\n  | LogicalInsert\n  | LogicalDelete\n  | LogicalUpdate\n  | LogicalCreateTable\n  | LogicalCreate\n  | LogicalExplain\n  | LogicalShow\n  | LogicalSet\n  | LogicalReset\n  | LogicalSimple\n  | LogicalPivot\n  | LogicalGet\n  | LogicalCopyToFile\n  | LogicalCreateIndex\n  | LogicalExtensionOperator;\n\nexport interface LogicalProjection extends BaseLogicalOperator {\n  table_index: number;\n  expressions: Expression[];\n}\n\nexport interface LogicalFilter extends BaseLogicalOperator {\n  expressions: Expression[];\n  projection_map: number[];\n}\n\nexport interface LogicalAggregate extends BaseLogicalOperator {\n  expressions: Expression[];\n  group_index: number;\n  aggregate_index: number;\n  groupings_index: number;\n  groups: Expression[];\n  grouping_sets: Set<number>[];\n  grouping_functions: number[][];\n}\n\nexport interface LogicalWindow extends BaseLogicalOperator {\n  window_index: number;\n  expressions: Expression[];\n}\n\nexport interface LogicalUnnest extends BaseLogicalOperator {\n  unnest_index: number;\n  expressions: Expression[];\n}\n\nexport interface LogicalLimit extends BaseLogicalOperator {\n  limit_val: number;\n  offset_val: number;\n  limit?: Expression;\n  offset?: Expression;\n}\n\nexport interface LogicalOrder extends BaseLogicalOperator {\n  orders: BoundOrderByNode[];\n  projections: number[];\n}\n\nexport interface LogicalTopN extends BaseLogicalOperator {\n  orders: BoundOrderByNode[];\n  limit: number;\n  offset: number;\n}\n\nexport enum DistinctType {\n  DISTINCT = 'DISTINCT',\n  DISTINCT_ON = 'DISTINCT_ON',\n}\n\nexport interface LogicalDistinct extends BaseLogicalOperator {\n  distinct_type: DistinctType;\n  distinct_targets: Expression[];\n  order_by?: BoundOrderModifier;\n}\n\nexport interface LogicalSample extends BaseLogicalOperator {\n  sample_options: SampleOptions;\n}\n\nexport interface LogicalLimitPercent extends BaseLogicalOperator {\n  limit_percent: number;\n  offset_val: number;\n  limit?: Expression;\n  offset?: Expression;\n}\n\nexport interface LogicalColumnDataGet extends BaseLogicalOperator {\n  table_index: number;\n  chunk_types: LogicalType[];\n  collection: ColumnDataCollection;\n}\n\nexport interface LogicalDelimGet extends BaseLogicalOperator {\n  table_index: number;\n  chunk_types: LogicalType[];\n}\n\nexport interface LogicalExpressionGet extends BaseLogicalOperator {\n  table_index: number;\n  expr_types: LogicalType[];\n  expressions: Expression[][];\n}\n\nexport interface LogicalDummyScan extends BaseLogicalOperator {\n  table_index: number;\n}\n\nexport interface LogicalEmptyResult extends BaseLogicalOperator {\n  return_types: LogicalType[];\n  bindings: ColumnBinding[];\n}\n\nexport interface LogicalCTERef extends BaseLogicalOperator {\n  table_index: number;\n  cte_index: number;\n  chunk_types: LogicalType[];\n  bound_columns: string[];\n  materialized_cte: CTEMaterialize;\n}\n\nexport interface LogicalComparisonJoin extends BaseLogicalOperator {\n  join_type: JoinType;\n  mark_index: number;\n  left_projection_map: number[];\n  right_projection_map: number[];\n  conditions: JoinCondition[];\n  mark_types: LogicalType[];\n  duplicate_eliminated_columns: Expression[];\n}\n\nexport interface LogicalAnyJoin extends BaseLogicalOperator {\n  join_type: JoinType;\n  mark_index: number;\n  left_projection_map: number[];\n  right_projection_map: number[];\n  condition: Expression;\n}\n\nexport type LogicalCrossProduct = BaseLogicalOperator;\n\nexport type LogicalPositionalJoin = BaseLogicalOperator;\n\nexport interface LogicalSetOperation extends BaseLogicalOperator {\n  table_index: number;\n  column_count: number;\n}\n\nexport interface LogicalRecursiveCTE extends BaseLogicalOperator {\n  union_all: boolean;\n  ctename: string;\n  table_index: number;\n  column_count: number;\n}\n\nexport interface LogicalMaterializedCTE extends BaseLogicalOperator {\n  table_index: number;\n  column_count: number;\n  ctename: string;\n}\n\nexport enum OnConflictAction {\n  THROW = 'THROW',\n  NOTHING = 'NOTHING',\n  UPDATE = 'UPDATE',\n  REPLACE = 'REPLACE',\n}\n\nexport interface LogicalInsert extends BaseLogicalOperator {\n  catalog: string;\n  schema: string;\n  table: string;\n  insert_values: Expression[][];\n  column_index_map: number[];\n  expected_types: LogicalType[];\n  table_index: number;\n  return_chunk: boolean;\n  bound_defaults: Expression[];\n  action_type: OnConflictAction;\n  expected_set_types: LogicalType[];\n  on_conflict_filter: Set<number>;\n  on_conflict_condition?: Expression;\n  do_update_condition?: Expression;\n  set_columns: number[];\n  set_types: LogicalType[];\n  excluded_table_index: number;\n  columns_to_fetch: number[];\n  source_columns: number[];\n}\n\nexport interface LogicalDelete extends BaseLogicalOperator {\n  catalog: string;\n  schema: string;\n  table: string;\n  table_index: number;\n  return_chunk: boolean;\n  expressions: Expression[];\n}\n\nexport interface LogicalUpdate extends BaseLogicalOperator {\n  catalog: string;\n  schema: string;\n  table: string;\n  table_index: number;\n  return_chunk: boolean;\n  expressions: Expression[];\n  columns: PhysicalIndex[];\n  bound_defaults: Expression[];\n  update_is_del_and_insert: boolean;\n}\n\nexport interface LogicalCreateTable extends BaseLogicalOperator {\n  catalog: string;\n  schema: string;\n  info: CreateInfo;\n}\n\nexport interface LogicalCreate extends BaseLogicalOperator {\n  info: CreateInfo;\n}\n\nexport enum ExplainType {\n  EXPLAIN_STANDARD = 'EXPLAIN_STANDARD',\n  EXPLAIN_ANALYZE = 'EXPLAIN_ANALYZE',\n}\n\nexport interface LogicalExplain extends BaseLogicalOperator {\n  explain_type: ExplainType;\n  physical_plan: string;\n  logical_plan_unopt: string;\n  logical_plan_opt: string;\n}\n\nexport interface LogicalShow extends BaseLogicalOperator {\n  types_select: LogicalType[];\n  aliases: string[];\n}\n\nexport enum SetScope {\n  AUTOMATIC = 'AUTOMATIC',\n  LOCAL = 'LOCAL',\n  SESSION = 'SESSION',\n  GLOBAL = 'GLOBAL',\n}\n\nexport interface LogicalSet extends BaseLogicalOperator {\n  name: string;\n  value: Value;\n  scope: SetScope;\n}\n\nexport interface LogicalReset extends BaseLogicalOperator {\n  name: string;\n  scope: SetScope;\n}\n\nexport interface LogicalSimple extends BaseLogicalOperator {\n  info: ParseInfo;\n}\n\nexport interface LogicalPivot extends BaseLogicalOperator {\n  pivot_index: number;\n  bound_pivot: BoundPivotInfo;\n}\n\nexport type LogicalGet = BaseLogicalOperator;\n\nexport type LogicalCopyToFile = BaseLogicalOperator;\n\nexport interface LogicalCreateIndex extends BaseLogicalOperator {\n  info: CreateInfo;\n  unbound_expressions: Expression[];\n}\n\nexport type LogicalExtensionOperator = BaseLogicalOperator;\n"],"names":["DistinctType","DISTINCT","DISTINCT_ON","OnConflictAction","THROW","NOTHING","UPDATE","REPLACE","ExplainType","EXPLAIN_STANDARD","EXPLAIN_ANALYZE","SetScope","AUTOMATIC","LOCAL","SESSION","GLOBAL"],"mappings":";;;;;;;;;;;;;;;;;;;;;IAiHO;UAAKA,YAAY;IAAZA,aACVC,cAAAA;IADUD,aAEVE,iBAAAA;GAFUF,iBAAAA;IAgGL;UAAKG,gBAAgB;IAAhBA,iBACVC,WAAAA;IADUD,iBAEVE,aAAAA;IAFUF,iBAGVG,YAAAA;IAHUH,iBAIVI,aAAAA;GAJUJ,qBAAAA;IA4DL;UAAKK,WAAW;IAAXA,YACVC,sBAAAA;IADUD,YAEVE,qBAAAA;GAFUF,gBAAAA;IAiBL;UAAKG,QAAQ;IAARA,SACVC,eAAAA;IADUD,SAEVE,WAAAA;IAFUF,SAGVG,aAAAA;IAHUH,SAIVI,YAAAA;GAJUJ,aAAAA"}

package/src/types/duckdb-serialization-types/serialization/MacroFunction.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/MacroFunction.ts"],"sourcesContent":["import { ParsedExpression } from './ParsedExpression';\nimport { BaseQueryNode } from './QueryNode';\n\nexport enum MacroType {\n  VOID_MACRO = 'VOID_MACRO',\n  TABLE_MACRO = 'TABLE_MACRO',\n  SCALAR_MACRO = 'SCALAR_MACRO',\n}\n\nexport interface MacroFunction {\n  type: MacroType;\n  parameters: ParsedExpression[];\n  default_parameters: { [key: string]: ParsedExpression };\n}\n\nexport interface ScalarMacroFunction extends MacroFunction {\n  expression: ParsedExpression;\n}\n\nexport interface TableMacroFunction extends MacroFunction {\n  query_node: BaseQueryNode;\n}\n"],"names":["MacroType","VOID_MACRO","TABLE_MACRO","SCALAR_MACRO"],"mappings":";;;;;;;IAGO;UAAKA,SAAS;IAATA,UACVC,gBAAAA;IADUD,UAEVE,iBAAAA;IAFUF,UAGVG,kBAAAA;GAHUH,cAAAA"}

package/src/types/duckdb-serialization-types/serialization/Misc.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Misc.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/Misc.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Misc.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/Nodes.d.js

@@ -1,10 +0,0 @@
-"use strict";
-var FileCompressionType;
-(function(FileCompressionType) {
-    FileCompressionType["AUTO_DETECT"] = "AUTO_DETECT";
-    FileCompressionType["UNCOMPRESSED"] = "UNCOMPRESSED";
-    FileCompressionType["GZIP"] = "GZIP";
-    FileCompressionType["ZSTD"] = "ZSTD";
-})(FileCompressionType || (FileCompressionType = {}));
-
-//# sourceMappingURL=Nodes.d.js.map

package/src/types/duckdb-serialization-types/serialization/Nodes.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Nodes.d.ts"],"sourcesContent":["import { Expression, ExpressionType } from './Expression';\nimport { Value } from './Misc';\nimport { ParsedExpression } from './ParsedExpression';\nimport { SelectStatement } from './Statement';\nimport { TableFilter } from './TableFilter';\nimport { ExtraTypeInfo } from './Types';\nexport interface LogicalType {\n    id?: number;\n    type_info?: ExtraTypeInfo;\n}\nexport declare enum CTEMaterialize {\n    CTE_MATERIALIZE_DEFAULT = \"CTE_MATERIALIZE_DEFAULT\",\n    CTE_MATERIALIZE_ALWAYS = \"CTE_MATERIALIZE_ALWAYS\",\n    CTE_MATERIALIZE_NEVER = \"CTE_MATERIALIZE_NEVER\"\n}\nexport interface CommonTableExpressionInfo {\n    aliases: string[];\n    query: SelectStatement;\n    materialized: CTEMaterialize;\n}\nexport interface CommonTableExpressionMap {\n    map: Record<string, CommonTableExpressionInfo> | Array<CommonTableExpressionInfo>;\n}\nexport declare enum OrderType {\n    INVALID = \"INVALID\",\n    ORDER_DEFAULT = \"ORDER_DEFAULT\",\n    ASCENDING = \"ASCENDING\",\n    DESCENDING = \"DESCENDING\"\n}\nexport declare enum OrderByNullType {\n    INVALID = \"INVALID\",\n    ORDER_DEFAULT = \"ORDER_DEFAULT\",\n    NULLS_FIRST = \"NULLS_FIRST\",\n    NULLS_LAST = \"NULLS_LAST\"\n}\nexport declare enum DefaultOrderByNullType {\n    INVALID = \"INVALID\",\n    NULLS_FIRST = \"NULLS_FIRST\",\n    NULLS_LAST = \"NULLS_LAST\",\n    NULLS_FIRST_ON_ASC_LAST_ON_DESC = \"NULLS_FIRST_ON_ASC_LAST_ON_DESC\",\n    NULLS_LAST_ON_ASC_FIRST_ON_DESC = \"NULLS_LAST_ON_ASC_FIRST_ON_DESC\"\n}\nexport interface OrderByNode {\n    type: OrderType;\n    null_order: OrderByNullType;\n    expression: ParsedExpression;\n}\nexport interface BoundOrderByNode {\n    type: OrderType;\n    null_order: OrderByNullType;\n    expression: Expression;\n}\nexport interface CaseCheck {\n    when_expr: ParsedExpression;\n    then_expr: ParsedExpression;\n}\nexport interface BoundCaseCheck {\n    when_expr: Expression;\n    then_expr: Expression;\n}\nexport declare enum SampleMethod {\n    SYSTEM_SAMPLE = \"SYSTEM_SAMPLE\",\n    BERNOULLI_SAMPLE = \"BERNOULLI_SAMPLE\",\n    RESERVOIR_SAMPLE = \"RESERVOIR_SAMPLE\"\n}\nexport interface SampleOptions {\n    sample_size: Value;\n    is_percentage: boolean;\n    method: SampleMethod;\n    seed: number;\n}\nexport interface PivotColumn {\n    pivot_expressions: ParsedExpression[];\n    unpivot_names: string[];\n    entries: PivotColumnEntry[];\n    pivot_enum: string;\n}\nexport interface PivotColumnEntry {\n    values: Value[];\n    star_expr?: ParsedExpression;\n    alias: string;\n}\nexport interface BoundPivotInfo {\n    group_count: number;\n    types: LogicalType[];\n    pivot_values: string[];\n    aggregates: Expression[];\n}\nexport declare enum TableColumnType {\n    STANDARD = \"STANDARD\",\n    GENERATED = \"GENERATED\"\n}\nexport declare enum CompressionType {\n    COMPRESSION_AUTO = \"COMPRESSION_AUTO\",\n    COMPRESSION_UNCOMPRESSED = \"COMPRESSION_UNCOMPRESSED\",\n    COMPRESSION_CONSTANT = \"COMPRESSION_CONSTANT\",\n    COMPRESSION_RLE = \"COMPRESSION_RLE\",\n    COMPRESSION_DICTIONARY = \"COMPRESSION_DICTIONARY\",\n    COMPRESSION_PFOR_DELTA = \"COMPRESSION_PFOR_DELTA\",\n    COMPRESSION_BITPACKING = \"COMPRESSION_BITPACKING\",\n    COMPRESSION_FSST = \"COMPRESSION_FSST\",\n    COMPRESSION_CHIMP = \"COMPRESSION_CHIMP\",\n    COMPRESSION_PATAS = \"COMPRESSION_PATAS\",\n    COMPRESSION_COUNT = \"COMPRESSION_COUNT\"\n}\nexport interface ColumnDefinition {\n    name: string;\n    type: LogicalType;\n    expression?: ParsedExpression;\n    category: TableColumnType;\n    compression_type: CompressionType;\n}\nexport interface ColumnList {\n    columns: ColumnDefinition[];\n}\nexport interface ColumnBinding {\n    table_index: number;\n    column_index: number;\n}\nexport interface BoundParameterData {\n    value: Value;\n    return_type: LogicalType;\n}\nexport interface JoinCondition {\n    left: Expression;\n    right: Expression;\n    comparison: ExpressionType;\n}\nexport interface VacuumOptions {\n    vacuum: boolean;\n    analyze: boolean;\n}\nexport interface TableFilterSet {\n    filters: Record<number, TableFilter>;\n}\nexport interface MultiFileReaderOptions {\n    filename: boolean;\n    hive_partitioning: boolean;\n    auto_detect_hive_partitioning: boolean;\n    union_by_name: boolean;\n    hive_types_autocast: boolean;\n    hive_types_schema: Record<string, LogicalType>;\n}\nexport interface MultiFileReaderBindData {\n    filename_idx: number;\n    hive_partitioning_indexes: HivePartitioningIndex[];\n}\nexport interface HivePartitioningIndex {\n    value: string;\n    index: number;\n}\ndeclare enum FileCompressionType {\n    AUTO_DETECT = \"AUTO_DETECT\",\n    UNCOMPRESSED = \"UNCOMPRESSED\",\n    GZIP = \"GZIP\",\n    ZSTD = \"ZSTD\"\n}\nexport interface CSVReaderOptions {\n    has_delimiter: boolean;\n    has_quote: boolean;\n    has_escape: boolean;\n    has_header: boolean;\n    ignore_errors: boolean;\n    buffer_sample_size: number;\n    null_str: string;\n    compression: FileCompressionType;\n    allow_quoted_nulls: boolean;\n    skip_rows_set: boolean;\n    maximum_line_size: number;\n    normalize_names: boolean;\n    force_not_null: boolean[];\n    all_varchar: boolean;\n    sample_chunk_size: number;\n    sample_chunks: number;\n    auto_detect: boolean;\n    file_path: string;\n    decimal_separator: string;\n    null_padding: boolean;\n    buffer_size: number;\n    file_options: MultiFileReaderOptions;\n    force_quote: boolean[];\n    rejects_table_name: string;\n    rejects_limit: number;\n    rejects_recovery_columns: string[];\n    rejects_recovery_column_ids: number[];\n    dialect_options: any;\n}\nexport interface StrpTimeFormat {\n    format_specifier: string;\n}\nexport interface ReadCSVData {\n    files: string[];\n    csv_types: LogicalType[];\n    csv_names: string[];\n    return_types: LogicalType[];\n    return_names: string[];\n    filename_col_idx: number;\n    options: any;\n    single_threaded: boolean;\n    reader_bind: MultiFileReaderBindData;\n    column_info: ColumnInfo[];\n}\nexport interface ColumnInfo {\n    names: string[];\n    types: LogicalType[];\n}\nexport interface IntervalT {\n    months: number;\n    days: number;\n    micros: number;\n}\nexport {};\n"],"names":["FileCompressionType","AUTO_DETECT","UNCOMPRESSED","GZIP","ZSTD"],"mappings":";IAuJA;UAAaA,mBAAmB;IAAnBA,oBACTC,iBAAAA;IADSD,oBAETE,kBAAAA;IAFSF,oBAGTG,UAAAA;IAHSH,oBAITI,UAAAA;GAJSJ,wBAAAA"}

package/src/types/duckdb-serialization-types/serialization/Nodes.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Nodes.ts"],"sourcesContent":["import { Expression, ExpressionType } from './Expression';\nimport { Value } from './Misc';\nimport { ParsedExpression } from './ParsedExpression';\nimport { SelectStatement } from './Statement';\nimport { TableFilter } from './TableFilter';\nimport { ExtraTypeInfo } from './Types';\n\nexport interface LogicalType {\n  id?: number;\n  type_info?: ExtraTypeInfo;\n}\n\nexport enum CTEMaterialize {\n  CTE_MATERIALIZE_DEFAULT = 'CTE_MATERIALIZE_DEFAULT',\n  CTE_MATERIALIZE_ALWAYS = 'CTE_MATERIALIZE_ALWAYS',\n  CTE_MATERIALIZE_NEVER = 'CTE_MATERIALIZE_NEVER',\n}\n\nexport interface CommonTableExpressionInfo {\n  aliases: string[];\n  query: SelectStatement;\n  materialized: CTEMaterialize;\n}\n\nexport interface CommonTableExpressionMap {\n  map:\n    | Record<string, CommonTableExpressionInfo>\n    | Array<CommonTableExpressionInfo>;\n}\n\nexport enum OrderType {\n  INVALID = 'INVALID',\n  ORDER_DEFAULT = 'ORDER_DEFAULT',\n  ASCENDING = 'ASCENDING',\n  DESCENDING = 'DESCENDING',\n}\n\nexport enum OrderByNullType {\n  INVALID = 'INVALID',\n  ORDER_DEFAULT = 'ORDER_DEFAULT',\n  NULLS_FIRST = 'NULLS_FIRST',\n  NULLS_LAST = 'NULLS_LAST',\n}\n\nexport enum DefaultOrderByNullType {\n  INVALID = 'INVALID',\n  NULLS_FIRST = 'NULLS_FIRST',\n  NULLS_LAST = 'NULLS_LAST',\n  NULLS_FIRST_ON_ASC_LAST_ON_DESC = 'NULLS_FIRST_ON_ASC_LAST_ON_DESC',\n  NULLS_LAST_ON_ASC_FIRST_ON_DESC = 'NULLS_LAST_ON_ASC_FIRST_ON_DESC',\n}\n\nexport interface OrderByNode {\n  type: OrderType;\n  null_order: OrderByNullType;\n  expression: ParsedExpression;\n}\n\nexport interface BoundOrderByNode {\n  type: OrderType;\n  null_order: OrderByNullType;\n  expression: Expression;\n}\n\nexport interface CaseCheck {\n  when_expr: ParsedExpression;\n  then_expr: ParsedExpression;\n}\n\nexport interface BoundCaseCheck {\n  when_expr: Expression;\n  then_expr: Expression;\n}\n\nexport enum SampleMethod {\n  SYSTEM_SAMPLE = 'SYSTEM_SAMPLE',\n  BERNOULLI_SAMPLE = 'BERNOULLI_SAMPLE',\n  RESERVOIR_SAMPLE = 'RESERVOIR_SAMPLE',\n}\n\nexport interface SampleOptions {\n  sample_size: Value;\n  is_percentage: boolean;\n  method: SampleMethod;\n  seed: number;\n}\n\nexport interface PivotColumn {\n  pivot_expressions: ParsedExpression[];\n  unpivot_names: string[];\n  entries: PivotColumnEntry[];\n  pivot_enum: string;\n}\n\nexport interface PivotColumnEntry {\n  values: Value[];\n  star_expr?: ParsedExpression;\n  alias: string;\n}\n\nexport interface BoundPivotInfo {\n  group_count: number;\n  types: LogicalType[];\n  pivot_values: string[];\n  aggregates: Expression[];\n}\n\nexport enum TableColumnType {\n  STANDARD = 'STANDARD',\n  GENERATED = 'GENERATED',\n}\n\nexport enum CompressionType {\n  COMPRESSION_AUTO = 'COMPRESSION_AUTO',\n  COMPRESSION_UNCOMPRESSED = 'COMPRESSION_UNCOMPRESSED',\n  COMPRESSION_CONSTANT = 'COMPRESSION_CONSTANT',\n  COMPRESSION_RLE = 'COMPRESSION_RLE',\n  COMPRESSION_DICTIONARY = 'COMPRESSION_DICTIONARY',\n  COMPRESSION_PFOR_DELTA = 'COMPRESSION_PFOR_DELTA',\n  COMPRESSION_BITPACKING = 'COMPRESSION_BITPACKING',\n  COMPRESSION_FSST = 'COMPRESSION_FSST',\n  COMPRESSION_CHIMP = 'COMPRESSION_CHIMP',\n  COMPRESSION_PATAS = 'COMPRESSION_PATAS',\n  COMPRESSION_COUNT = 'COMPRESSION_COUNT',\n}\n\nexport interface ColumnDefinition {\n  name: string;\n  type: LogicalType;\n  expression?: ParsedExpression;\n  category: TableColumnType;\n  compression_type: CompressionType;\n}\n\nexport interface ColumnList {\n  columns: ColumnDefinition[];\n}\n\nexport interface ColumnBinding {\n  table_index: number;\n  column_index: number;\n}\n\nexport interface BoundParameterData {\n  value: Value;\n  return_type: LogicalType;\n}\n\nexport interface JoinCondition {\n  left: Expression;\n  right: Expression;\n  comparison: ExpressionType;\n}\n\nexport interface VacuumOptions {\n  vacuum: boolean;\n  analyze: boolean;\n}\n\nexport interface TableFilterSet {\n  filters: Record<number, TableFilter>;\n}\n\nexport interface MultiFileReaderOptions {\n  filename: boolean;\n  hive_partitioning: boolean;\n  auto_detect_hive_partitioning: boolean;\n  union_by_name: boolean;\n  hive_types_autocast: boolean;\n  hive_types_schema: Record<string, LogicalType>;\n}\n\nexport interface MultiFileReaderBindData {\n  filename_idx: number;\n  hive_partitioning_indexes: HivePartitioningIndex[];\n}\n\nexport interface HivePartitioningIndex {\n  value: string;\n  index: number;\n}\n\nenum FileCompressionType {\n  AUTO_DETECT = 'AUTO_DETECT',\n  UNCOMPRESSED = 'UNCOMPRESSED',\n  GZIP = 'GZIP',\n  ZSTD = 'ZSTD',\n}\n\nexport interface CSVReaderOptions {\n  has_delimiter: boolean;\n  has_quote: boolean;\n  has_escape: boolean;\n  has_header: boolean;\n  ignore_errors: boolean;\n  buffer_sample_size: number;\n  null_str: string;\n  compression: FileCompressionType;\n  allow_quoted_nulls: boolean;\n  skip_rows_set: boolean;\n  maximum_line_size: number;\n  normalize_names: boolean;\n  force_not_null: boolean[];\n  all_varchar: boolean;\n  sample_chunk_size: number;\n  sample_chunks: number;\n  auto_detect: boolean;\n  file_path: string;\n  decimal_separator: string;\n  null_padding: boolean;\n  buffer_size: number;\n  file_options: MultiFileReaderOptions;\n  force_quote: boolean[];\n  rejects_table_name: string;\n  rejects_limit: number;\n  rejects_recovery_columns: string[];\n  rejects_recovery_column_ids: number[];\n  dialect_options: any;\n}\n\nexport interface StrpTimeFormat {\n  format_specifier: string;\n}\n\nexport interface ReadCSVData {\n  files: string[];\n  csv_types: LogicalType[];\n  csv_names: string[];\n  return_types: LogicalType[];\n  return_names: string[];\n  filename_col_idx: number;\n  options: any;\n  single_threaded: boolean;\n  reader_bind: MultiFileReaderBindData;\n  column_info: ColumnInfo[];\n}\n\nexport interface ColumnInfo {\n  names: string[];\n  types: LogicalType[];\n}\n\nexport interface IntervalT {\n  months: number;\n  days: number;\n  micros: number;\n}\n"],"names":["CTEMaterialize","CTE_MATERIALIZE_DEFAULT","CTE_MATERIALIZE_ALWAYS","CTE_MATERIALIZE_NEVER","OrderType","INVALID","ORDER_DEFAULT","ASCENDING","DESCENDING","OrderByNullType","NULLS_FIRST","NULLS_LAST","DefaultOrderByNullType","NULLS_FIRST_ON_ASC_LAST_ON_DESC","NULLS_LAST_ON_ASC_FIRST_ON_DESC","SampleMethod","SYSTEM_SAMPLE","BERNOULLI_SAMPLE","RESERVOIR_SAMPLE","TableColumnType","STANDARD","GENERATED","CompressionType","COMPRESSION_AUTO","COMPRESSION_UNCOMPRESSED","COMPRESSION_CONSTANT","COMPRESSION_RLE","COMPRESSION_DICTIONARY","COMPRESSION_PFOR_DELTA","COMPRESSION_BITPACKING","COMPRESSION_FSST","COMPRESSION_CHIMP","COMPRESSION_PATAS","COMPRESSION_COUNT","FileCompressionType","AUTO_DETECT","UNCOMPRESSED","GZIP","ZSTD"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYO;UAAKA,cAAc;IAAdA,eACVC,6BAAAA;IADUD,eAEVE,4BAAAA;IAFUF,eAGVG,2BAAAA;GAHUH,mBAAAA;IAkBL;UAAKI,SAAS;IAATA,UACVC,aAAAA;IADUD,UAEVE,mBAAAA;IAFUF,UAGVG,eAAAA;IAHUH,UAIVI,gBAAAA;GAJUJ,cAAAA;IAOL;UAAKK,eAAe;IAAfA,gBACVJ,aAAAA;IADUI,gBAEVH,mBAAAA;IAFUG,gBAGVC,iBAAAA;IAHUD,gBAIVE,gBAAAA;GAJUF,oBAAAA;IAOL;UAAKG,sBAAsB;IAAtBA,uBACVP,aAAAA;IADUO,uBAEVF,iBAAAA;IAFUE,uBAGVD,gBAAAA;IAHUC,uBAIVC,qCAAAA;IAJUD,uBAKVE,qCAAAA;GALUF,2BAAAA;IA8BL;UAAKG,YAAY;IAAZA,aACVC,mBAAAA;IADUD,aAEVE,sBAAAA;IAFUF,aAGVG,sBAAAA;GAHUH,iBAAAA;IAiCL;UAAKI,eAAe;IAAfA,gBACVC,cAAAA;IADUD,gBAEVE,eAAAA;GAFUF,oBAAAA;IAKL;UAAKG,eAAe;IAAfA,gBACVC,sBAAAA;IADUD,gBAEVE,8BAAAA;IAFUF,gBAGVG,0BAAAA;IAHUH,gBAIVI,qBAAAA;IAJUJ,gBAKVK,4BAAAA;IALUL,gBAMVM,4BAAAA;IANUN,gBAOVO,4BAAAA;IAPUP,gBAQVQ,sBAAAA;IARUR,gBASVS,uBAAAA;IATUT,gBAUVU,uBAAAA;IAVUV,gBAWVW,uBAAAA;GAXUX,oBAAAA;IAsEZ;UAAKY,mBAAmB;IAAnBA,oBACHC,iBAAAA;IADGD,oBAEHE,kBAAAA;IAFGF,oBAGHG,UAAAA;IAHGH,oBAIHI,UAAAA;GAJGJ,wBAAAA"}

package/src/types/duckdb-serialization-types/serialization/ParseInfo.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ParseInfo.ts"],"sourcesContent":["import { PhysicalIndex } from './Constraint';\nimport { Value } from './Misc';\nimport { ColumnDefinition, LogicalType } from './Nodes';\nimport { ParsedExpression } from './ParsedExpression';\n\nexport enum ParseInfoType {\n  ALTER_INFO = 'ALTER_INFO',\n  ATTACH_INFO = 'ATTACH_INFO',\n  COPY_INFO = 'COPY_INFO',\n  CREATE_INFO = 'CREATE_INFO',\n  DETACH_INFO = 'DETACH_INFO',\n  DROP_INFO = 'DROP_INFO',\n  BOUND_EXPORT_DATA = 'BOUND_EXPORT_DATA',\n  LOAD_INFO = 'LOAD_INFO',\n  PRAGMA_INFO = 'PRAGMA_INFO',\n  SHOW_SELECT_INFO = 'SHOW_SELECT_INFO',\n  TRANSACTION_INFO = 'TRANSACTION_INFO',\n  VACUUM_INFO = 'VACUUM_INFO',\n}\n\nexport interface ParseInfo {\n  info_type: ParseInfoType;\n}\n\nexport enum AlterType {\n  INVALID = 'INVALID',\n  ALTER_TABLE = 'ALTER_TABLE',\n  ALTER_VIEW = 'ALTER_VIEW',\n  ALTER_SEQUENCE = 'ALTER_SEQUENCE',\n  CHANGE_OWNERSHIP = 'CHANGE_OWNERSHIP',\n  ALTER_SCALAR_FUNCTION = 'ALTER_SCALAR_FUNCTION',\n  ALTER_TABLE_FUNCTION = 'ALTER_TABLE_FUNCTION',\n}\n\nexport enum OnEntryNotFound {\n  THROW_EXCEPTION = 'THROW_EXCEPTION',\n  RETURN_NULL = 'RETURN_NULL',\n}\n\nexport interface AlterInfo extends ParseInfo {\n  type: AlterType;\n  catalog: string;\n  schema: string;\n  name: string;\n  if_not_found: OnEntryNotFound;\n  allow_internal: boolean;\n}\n\nexport enum AlterTableType {\n  INVALID = 'INVALID',\n  RENAME_COLUMN = 'RENAME_COLUMN',\n  RENAME_TABLE = 'RENAME_TABLE',\n  ADD_COLUMN = 'ADD_COLUMN',\n  REMOVE_COLUMN = 'REMOVE_COLUMN',\n  ALTER_COLUMN_TYPE = 'ALTER_COLUMN_TYPE',\n  SET_DEFAULT = 'SET_DEFAULT',\n  FOREIGN_KEY_CONSTRAINT = 'FOREIGN_KEY_CONSTRAINT',\n  SET_NOT_NULL = 'SET_NOT_NULL',\n  DROP_NOT_NULL = 'DROP_NOT_NULL',\n}\n\nexport interface AlterTableInfo extends AlterInfo {\n  alter_table_type: AlterTableType;\n}\n\nexport interface RenameColumnInfo extends AlterTableInfo {\n  old_name: string;\n  new_name: string;\n}\n\nexport interface RenameTableInfo extends AlterTableInfo {\n  new_table_name: string;\n}\n\nexport interface AddColumnInfo extends AlterTableInfo {\n  new_column: ColumnDefinition;\n  if_column_not_exists: boolean;\n}\n\nexport interface RemoveColumnInfo extends AlterTableInfo {\n  removed_column: string;\n  if_column_exists: boolean;\n  cascade: boolean;\n}\n\nexport interface ChangeColumnTypeInfo extends AlterTableInfo {\n  column_name: string;\n  target_type: LogicalType;\n  expression: ParsedExpression;\n}\n\nexport interface SetDefaultInfo extends AlterTableInfo {\n  column_name: string;\n  expression?: ParsedExpression;\n}\n\nexport enum AlterForeignKeyType {\n  AFT_ADD = 'AFT_ADD',\n  AFT_DELETE = 'AFT_DELETE',\n}\n\nexport interface AlterForeignKeyInfo extends AlterTableInfo {\n  fk_table: string;\n  pk_columns: string[];\n  fk_columns: string[];\n  pk_keys: PhysicalIndex[];\n  fk_keys: PhysicalIndex[];\n  alter_fk_type: AlterForeignKeyType;\n}\n\nexport interface SetNotNullInfo extends AlterTableInfo {\n  column_name: string;\n}\n\nexport interface DropNotNullInfo extends AlterTableInfo {\n  column_name: string;\n}\n\nexport enum AlterViewType {\n  INVALID = 'INVALID',\n  RENAME_VIEW = 'RENAME_VIEW',\n}\n\nexport interface AlterViewInfo extends AlterInfo {\n  alter_view_type: AlterViewType;\n}\n\nexport interface RenameViewInfo extends AlterViewInfo {\n  new_view_name: string;\n}\n\nexport interface AttachInfo extends ParseInfo {\n  name: string;\n  path: string;\n  options: { [key: string]: Value };\n}\n\nexport interface CopyInfo extends ParseInfo {\n  catalog: string;\n  schema: string;\n  table: string;\n  select_list: string[];\n  is_from: boolean;\n  format: string;\n  file_path: string;\n  options: { [key: string]: Value[] };\n}\n\nexport interface DetachInfo extends ParseInfo {\n  name: string;\n  if_not_found: OnEntryNotFound;\n}\n\nexport enum CatalogType {\n  INVALID = 'INVALID',\n  TABLE_ENTRY = 'TABLE_ENTRY',\n  SCHEMA_ENTRY = 'SCHEMA_ENTRY',\n  VIEW_ENTRY = 'VIEW_ENTRY',\n  INDEX_ENTRY = 'INDEX_ENTRY',\n  PREPARED_STATEMENT = 'PREPARED_STATEMENT',\n  SEQUENCE_ENTRY = 'SEQUENCE_ENTRY',\n  COLLATION_ENTRY = 'COLLATION_ENTRY',\n  TYPE_ENTRY = 'TYPE_ENTRY',\n  DATABASE_ENTRY = 'DATABASE_ENTRY',\n\n  // functions\n  TABLE_FUNCTION_ENTRY = 'TABLE_FUNCTION_ENTRY',\n  SCALAR_FUNCTION_ENTRY = 'SCALAR_FUNCTION_ENTRY',\n  AGGREGATE_FUNCTION_ENTRY = 'AGGREGATE_FUNCTION_ENTRY',\n  PRAGMA_FUNCTION_ENTRY = 'PRAGMA_FUNCTION_ENTRY',\n  COPY_FUNCTION_ENTRY = 'COPY_FUNCTION_ENTRY',\n  MACRO_ENTRY = 'MACRO_ENTRY',\n  TABLE_MACRO_ENTRY = 'TABLE_MACRO_ENTRY',\n\n  // version info\n  UPDATED_ENTRY = 'UPDATED_ENTRY',\n  DELETED_ENTRY = 'DELETED_ENTRY',\n}\n\nexport interface DropInfo extends ParseInfo {\n  type: CatalogType;\n  catalog: string;\n  schema: string;\n  name: string;\n  if_not_found: OnEntryNotFound;\n  cascade: boolean;\n  allow_drop_internal: boolean;\n}\n\nexport enum LoadType {\n  LOAD = 'LOAD',\n  INSTALL = 'INSTALL',\n  FORCE_INSTALL = 'FORCE_INSTALL',\n}\n\nexport interface LoadInfo extends ParseInfo {\n  filename: string;\n  load_type: LoadType;\n  repository: string;\n}\n\nexport interface PragmaInfo extends ParseInfo {\n  name: string;\n  parameters: Value[];\n  named_parameters: { [key: string]: Value };\n}\n\nexport enum TransactionType {\n  INVALID = 'INVALID',\n  BEGIN_TRANSACTION = 'BEGIN_TRANSACTION',\n  COMMIT = 'COMMIT',\n  ROLLBACK = 'ROLLBACK',\n}\n\nexport interface TransactionInfo extends ParseInfo {\n  type: TransactionType;\n}\n\nexport interface VacuumInfo extends ParseInfo {\n  options: any;\n}\n"],"names":["ParseInfoType","ALTER_INFO","ATTACH_INFO","COPY_INFO","CREATE_INFO","DETACH_INFO","DROP_INFO","BOUND_EXPORT_DATA","LOAD_INFO","PRAGMA_INFO","SHOW_SELECT_INFO","TRANSACTION_INFO","VACUUM_INFO","AlterType","INVALID","ALTER_TABLE","ALTER_VIEW","ALTER_SEQUENCE","CHANGE_OWNERSHIP","ALTER_SCALAR_FUNCTION","ALTER_TABLE_FUNCTION","OnEntryNotFound","THROW_EXCEPTION","RETURN_NULL","AlterTableType","RENAME_COLUMN","RENAME_TABLE","ADD_COLUMN","REMOVE_COLUMN","ALTER_COLUMN_TYPE","SET_DEFAULT","FOREIGN_KEY_CONSTRAINT","SET_NOT_NULL","DROP_NOT_NULL","AlterForeignKeyType","AFT_ADD","AFT_DELETE","AlterViewType","RENAME_VIEW","CatalogType","TABLE_ENTRY","SCHEMA_ENTRY","VIEW_ENTRY","INDEX_ENTRY","PREPARED_STATEMENT","SEQUENCE_ENTRY","COLLATION_ENTRY","TYPE_ENTRY","DATABASE_ENTRY","TABLE_FUNCTION_ENTRY","SCALAR_FUNCTION_ENTRY","AGGREGATE_FUNCTION_ENTRY","PRAGMA_FUNCTION_ENTRY","COPY_FUNCTION_ENTRY","MACRO_ENTRY","TABLE_MACRO_ENTRY","UPDATED_ENTRY","DELETED_ENTRY","LoadType","LOAD","INSTALL","FORCE_INSTALL","TransactionType","BEGIN_TRANSACTION","COMMIT","ROLLBACK"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKO;UAAKA,aAAa;IAAbA,cACVC,gBAAAA;IADUD,cAEVE,iBAAAA;IAFUF,cAGVG,eAAAA;IAHUH,cAIVI,iBAAAA;IAJUJ,cAKVK,iBAAAA;IALUL,cAMVM,eAAAA;IANUN,cAOVO,uBAAAA;IAPUP,cAQVQ,eAAAA;IARUR,cASVS,iBAAAA;IATUT,cAUVU,sBAAAA;IAVUV,cAWVW,sBAAAA;IAXUX,cAYVY,iBAAAA;GAZUZ,kBAAAA;IAmBL;UAAKa,SAAS;IAATA,UACVC,aAAAA;IADUD,UAEVE,iBAAAA;IAFUF,UAGVG,gBAAAA;IAHUH,UAIVI,oBAAAA;IAJUJ,UAKVK,sBAAAA;IALUL,UAMVM,2BAAAA;IANUN,UAOVO,0BAAAA;GAPUP,cAAAA;IAUL;UAAKQ,eAAe;IAAfA,gBACVC,qBAAAA;IADUD,gBAEVE,iBAAAA;GAFUF,oBAAAA;IAcL;UAAKG,cAAc;IAAdA,eACVV,aAAAA;IADUU,eAEVC,mBAAAA;IAFUD,eAGVE,kBAAAA;IAHUF,eAIVG,gBAAAA;IAJUH,eAKVI,mBAAAA;IALUJ,eAMVK,uBAAAA;IANUL,eAOVM,iBAAAA;IAPUN,eAQVO,4BAAAA;IARUP,eASVQ,kBAAAA;IATUR,eAUVS,mBAAAA;GAVUT,mBAAAA;IAgDL;UAAKU,mBAAmB;IAAnBA,oBACVC,aAAAA;IADUD,oBAEVE,gBAAAA;GAFUF,wBAAAA;IAsBL;UAAKG,aAAa;IAAbA,cACVvB,aAAAA;IADUuB,cAEVC,iBAAAA;GAFUD,kBAAAA;IAmCL;UAAKE,WAAW;IAAXA,YACVzB,aAAAA;IADUyB,YAEVC,iBAAAA;IAFUD,YAGVE,kBAAAA;IAHUF,YAIVG,gBAAAA;IAJUH,YAKVI,iBAAAA;IALUJ,YAMVK,wBAAAA;IANUL,YAOVM,oBAAAA;IAPUN,YAQVO,qBAAAA;IARUP,YASVQ,gBAAAA;IATUR,YAUVS,oBAAAA;IAVUT,YAYV,YAAY;IACZU,0BAAAA;IAbUV,YAcVW,2BAAAA;IAdUX,YAeVY,8BAAAA;IAfUZ,YAgBVa,2BAAAA;IAhBUb,YAiBVc,yBAAAA;IAjBUd,YAkBVe,iBAAAA;IAlBUf,YAmBVgB,uBAAAA;IAnBUhB,YAqBV,eAAe;IACfiB,mBAAAA;IAtBUjB,YAuBVkB,mBAAAA;GAvBUlB,gBAAAA;IAoCL;UAAKmB,QAAQ;IAARA,SACVC,UAAAA;IADUD,SAEVE,aAAAA;IAFUF,SAGVG,mBAAAA;GAHUH,aAAAA;IAkBL;UAAKI,eAAe;IAAfA,gBACVhD,aAAAA;IADUgD,gBAEVC,uBAAAA;IAFUD,gBAGVE,YAAAA;IAHUF,gBAIVG,cAAAA;GAJUH,oBAAAA"}

package/src/types/duckdb-serialization-types/serialization/ParsedExpression.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ParsedExpression.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/ParsedExpression.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ParsedExpression.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from './Expression';\nimport { CacheCheck, Value } from './Misc';\nimport { LogicalType, OrderByNode } from './Nodes';\nimport { OrderModifier } from './ResultModifier';\nimport { SelectStatement } from './Statement';\n\nexport interface BaseParsedExpression {\n  class: ExpressionClass;\n  type: ExpressionType;\n  alias: string;\n  query_location?: number;\n}\n\nexport type ParsedExpression =\n  | BetweenExpression\n  | CaseExpression\n  | CastExpression\n  | CollateExpression\n  | ColumnRefExpression\n  | ComparisonExpression\n  | ConjunctionExpression\n  | ConstantExpression\n  | DefaultExpression\n  | FunctionExpression\n  | LambdaExpression\n  | OperatorExpression\n  | ParameterExpression\n  | PositionalReferenceExpression\n  | StarExpression\n  | SubqueryExpression\n  | WindowExpression;\n\nexport interface BetweenExpression extends BaseParsedExpression {\n  class: ExpressionClass.BETWEEN;\n  input: ParsedExpression;\n  lower: ParsedExpression;\n  upper: ParsedExpression;\n}\n\nexport interface CaseExpression extends BaseParsedExpression {\n  class: ExpressionClass.CASE;\n  case_checks: CacheCheck[];\n  else_expr: BaseParsedExpression;\n}\n\nexport interface CastExpression extends BaseParsedExpression {\n  class: ExpressionClass.CAST;\n  child: ParsedExpression;\n  cast_type: LogicalType;\n  try_cast: boolean;\n}\n\nexport interface CollateExpression extends BaseParsedExpression {\n  class: ExpressionClass.COLLATE;\n  child: ParsedExpression;\n  collation: string;\n}\n\nexport interface ColumnRefExpression extends BaseParsedExpression {\n  class: ExpressionClass.COLUMN_REF;\n  column_names: string[];\n}\n\nexport interface ComparisonExpression extends BaseParsedExpression {\n  class: ExpressionClass.COMPARISON;\n  left: ParsedExpression;\n  right: ParsedExpression;\n}\n\nexport interface ConjunctionExpression extends BaseParsedExpression {\n  class: ExpressionClass.CONJUNCTION;\n  children: ParsedExpression[];\n}\n\nexport interface ConstantExpression extends BaseParsedExpression {\n  class: ExpressionClass.CONSTANT;\n  value: Value;\n}\n\nexport type DefaultExpression = BaseParsedExpression;\n\nexport interface FunctionExpression extends BaseParsedExpression {\n  class: ExpressionClass.FUNCTION;\n  function_name: string;\n  schema: string;\n  children: ParsedExpression[];\n  filter: ParsedExpression | null;\n  order_bys: OrderModifier;\n  distinct: boolean;\n  is_operator: boolean;\n  export_state: boolean;\n  catalog: string;\n}\n\nexport interface LambdaExpression extends BaseParsedExpression {\n  class: ExpressionClass.LAMBDA;\n  lhs: ParsedExpression;\n  expr: ParsedExpression | null;\n}\n\nexport interface OperatorExpression extends BaseParsedExpression {\n  class: ExpressionClass.OPERATOR;\n  children: ParsedExpression[];\n}\n\nexport interface ParameterExpression extends BaseParsedExpression {\n  class: ExpressionClass.PARAMETER;\n  identifier: string;\n}\n\nexport interface PositionalReferenceExpression extends BaseParsedExpression {\n  class: ExpressionClass.POSITIONAL_REFERENCE;\n  index: number;\n}\n\nexport interface StarExpression extends BaseParsedExpression {\n  class: ExpressionClass.STAR;\n  relation_name: string;\n  exclude_list: Set<string> | Array<string>;\n  replace_list: Set<ParsedExpression> | Array<ParsedExpression>;\n  columns: boolean;\n  expr?: ParsedExpression;\n}\n\nexport enum SubqueryType {\n  INVALID = 'INVALID',\n  SCALAR = 'SCALAR',\n  EXISTS = 'EXISTS',\n  NOT_EXISTS = 'NOT_EXISTS',\n  ANY = 'ANY',\n}\n\nexport interface SubqueryExpression extends BaseParsedExpression {\n  class: ExpressionClass.SUBQUERY;\n  subquery_type: SubqueryType;\n  subquery: SelectStatement;\n  child?: ParsedExpression;\n  comparison_type: ExpressionType;\n}\n\nexport enum WindowBoundary {\n  INVALID = 'INVALID',\n  UNBOUNDED_PRECEDING = 'UNBOUNDED_PRECEDING',\n  UNBOUNDED_FOLLOWING = 'UNBOUNDED_FOLLOWING',\n  CURRENT_ROW_RANGE = 'CURRENT_ROW_RANGE',\n  CURRENT_ROW_ROWS = 'CURRENT_ROW_ROWS',\n  EXPR_PRECEDING_ROWS = 'EXPR_PRECEDING_ROWS',\n  EXPR_FOLLOWING_ROWS = 'EXPR_FOLLOWING_ROWS',\n  EXPR_PRECEDING_RANGE = 'EXPR_PRECEDING_RANGE',\n  EXPR_FOLLOWING_RANGE = 'EXPR_FOLLOWING_RANGE',\n}\n\nexport interface WindowExpression extends BaseParsedExpression {\n  class: ExpressionClass.WINDOW;\n  function_name: string;\n  schema: string;\n  catalog: string;\n  children: ParsedExpression[];\n  partitions: ParsedExpression[];\n  orders: OrderByNode[];\n  start: WindowBoundary;\n  end: WindowBoundary;\n  start_expr?: ParsedExpression;\n  end_expr?: ParsedExpression;\n  offset_expr?: ParsedExpression;\n  default_expr?: ParsedExpression;\n  ignore_nulls: boolean;\n  filter_expr?: ParsedExpression;\n}\n"],"names":["SubqueryType","INVALID","SCALAR","EXISTS","NOT_EXISTS","ANY","WindowBoundary","UNBOUNDED_PRECEDING","UNBOUNDED_FOLLOWING","CURRENT_ROW_RANGE","CURRENT_ROW_ROWS","EXPR_PRECEDING_ROWS","EXPR_FOLLOWING_ROWS","EXPR_PRECEDING_RANGE","EXPR_FOLLOWING_RANGE"],"mappings":";;;;;;;;;;;;;;;IA4HO;UAAKA,YAAY;IAAZA,aACVC,aAAAA;IADUD,aAEVE,YAAAA;IAFUF,aAGVG,YAAAA;IAHUH,aAIVI,gBAAAA;IAJUJ,aAKVK,SAAAA;GALUL,iBAAAA;IAgBL;UAAKM,cAAc;IAAdA,eACVL,aAAAA;IADUK,eAEVC,yBAAAA;IAFUD,eAGVE,yBAAAA;IAHUF,eAIVG,uBAAAA;IAJUH,eAKVI,sBAAAA;IALUJ,eAMVK,yBAAAA;IANUL,eAOVM,yBAAAA;IAPUN,eAQVO,0BAAAA;IARUP,eASVQ,0BAAAA;GATUR,mBAAAA"}

package/src/types/duckdb-serialization-types/serialization/QueryNode.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/QueryNode.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/QueryNode.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/QueryNode.ts"],"sourcesContent":["import { CommonTableExpressionMap, SampleOptions } from './Nodes';\nimport { ParsedExpression } from './ParsedExpression';\nimport { ResultModifier } from './ResultModifier';\nimport { TableRef } from './TableRef';\n\nexport enum QueryNodeType {\n  SELECT_NODE = 'SELECT_NODE',\n  SET_OPERATION_NODE = 'SET_OPERATION_NODE',\n  BOUND_SUBQUERY_NODE = 'BOUND_SUBQUERY_NODE',\n  RECURSIVE_CTE_NODE = 'RECURSIVE_CTE_NODE',\n  CTE_NODE = 'CTE_NODE',\n}\n\nexport interface BaseQueryNode {\n  type: QueryNodeType;\n  modifiers: ResultModifier[];\n  cte_map: CommonTableExpressionMap;\n}\n\nexport type QueryNode =\n  | SelectNode\n  | SetOperationNode\n  | RecursiveCTENode\n  | CTENode;\n\nexport enum AggregateHandling {\n  STANDARD_HANDLING = 'STANDARD_HANDLING',\n  NO_AGGREGATES_ALLOWED = 'NO_AGGREGATES_ALLOWED',\n  FORCE_AGGREGATES = 'FORCE_AGGREGATES',\n}\n\nexport interface SelectNode extends BaseQueryNode {\n  type: QueryNodeType.SELECT_NODE;\n  select_list: ParsedExpression[];\n  from_table?: TableRef;\n  where_clause?: ParsedExpression;\n  group_expressions: ParsedExpression[];\n  group_sets: Set<number> | Array<Array<number>>;\n  aggregate_handling: AggregateHandling;\n  having: ParsedExpression | null;\n  sample: SampleOptions | null;\n  qualify: ParsedExpression | null;\n}\n\nexport enum SetOperationType {\n  NONE = 'NONE',\n  UNION = 'UNION',\n  EXCEPT = 'EXCEPT',\n  INTERSECT = 'INTERSECT',\n  UNION_BY_NAME = 'UNION_BY_NAME',\n}\n\nexport interface SetOperationNode extends BaseQueryNode {\n  type: QueryNodeType.SET_OPERATION_NODE;\n  setop_type: SetOperationType;\n  left: QueryNode;\n  right: QueryNode;\n}\n\nexport interface RecursiveCTENode extends BaseQueryNode {\n  type: QueryNodeType.RECURSIVE_CTE_NODE;\n  cte_name: string;\n  union_all: boolean;\n  left: QueryNode;\n  right: QueryNode;\n  aliases: string[];\n}\n\nexport interface CTENode extends BaseQueryNode {\n  type: QueryNodeType.CTE_NODE;\n  cte_name: string;\n  query: QueryNode;\n  child: QueryNode;\n  aliases: string[];\n}\n"],"names":["QueryNodeType","SELECT_NODE","SET_OPERATION_NODE","BOUND_SUBQUERY_NODE","RECURSIVE_CTE_NODE","CTE_NODE","AggregateHandling","STANDARD_HANDLING","NO_AGGREGATES_ALLOWED","FORCE_AGGREGATES","SetOperationType","NONE","UNION","EXCEPT","INTERSECT","UNION_BY_NAME"],"mappings":";;;;;;;;;;;;;;;;;;IAKO;UAAKA,aAAa;IAAbA,cACVC,iBAAAA;IADUD,cAEVE,wBAAAA;IAFUF,cAGVG,yBAAAA;IAHUH,cAIVI,wBAAAA;IAJUJ,cAKVK,cAAAA;GALUL,kBAAAA;IAoBL;UAAKM,iBAAiB;IAAjBA,kBACVC,uBAAAA;IADUD,kBAEVE,2BAAAA;IAFUF,kBAGVG,sBAAAA;GAHUH,sBAAAA;IAmBL;UAAKI,gBAAgB;IAAhBA,iBACVC,UAAAA;IADUD,iBAEVE,WAAAA;IAFUF,iBAGVG,YAAAA;IAHUH,iBAIVI,eAAAA;IAJUJ,iBAKVK,mBAAAA;GALUL,qBAAAA"}

package/src/types/duckdb-serialization-types/serialization/ResultModifier.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ResultModifier.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/ResultModifier.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/ResultModifier.ts"],"sourcesContent":["import { BoundOrderByNode, OrderByNode } from './Nodes';\nimport { ParsedExpression } from './ParsedExpression';\n\nexport enum ResultModifierType {\n  LIMIT_MODIFIER = 'LIMIT_MODIFIER',\n  ORDER_MODIFIER = 'ORDER_MODIFIER',\n  DISTINCT_MODIFIER = 'DISTINCT_MODIFIER',\n  LIMIT_PERCENT_MODIFIER = 'LIMIT_PERCENT_MODIFIER',\n}\n\nexport interface BaseResultModifier {\n  type: ResultModifierType;\n}\n\nexport type ResultModifier = LimitModifier | OrderModifier | DistinctModifier | LimitPercentModifier;\n\nexport interface LimitModifier extends BaseResultModifier {\n  limit?: ParsedExpression;\n  offset?: ParsedExpression;\n}\n\nexport interface DistinctModifier extends BaseResultModifier {\n  distinct_on_targets: ParsedExpression[];\n}\n\nexport interface OrderModifier extends BaseResultModifier {\n  orders: OrderByNode[];\n}\n\nexport interface LimitPercentModifier extends BaseResultModifier {\n  limit?: ParsedExpression;\n  offset?: ParsedExpression;\n}\n\nexport interface BoundOrderModifier {\n  orders: BoundOrderByNode[];\n}\n"],"names":["ResultModifierType","LIMIT_MODIFIER","ORDER_MODIFIER","DISTINCT_MODIFIER","LIMIT_PERCENT_MODIFIER"],"mappings":";;;;;;;IAGO;UAAKA,kBAAkB;IAAlBA,mBACVC,oBAAAA;IADUD,mBAEVE,oBAAAA;IAFUF,mBAGVG,uBAAAA;IAHUH,mBAIVI,4BAAAA;GAJUJ,uBAAAA"}

package/src/types/duckdb-serialization-types/serialization/Statement.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Statement.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/Statement.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Statement.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/TableFilter.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/TableFilter.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/TableFilter.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/TableFilter.ts"],"sourcesContent":["import { ExpressionType } from './Expression';\nimport { Value } from './Misc';\n\nexport enum TableFilterType {\n  CONSTANT_COMPARISON = 'CONSTANT_COMPARISON',\n  IS_NULL = 'IS_NULL',\n  IS_NOT_NULL = 'IS_NOT_NULL',\n  CONJUNCTION_OR = 'CONJUNCTION_OR',\n  CONJUNCTION_AND = 'CONJUNCTION_AND',\n}\n\nexport interface BaseTableFilter {\n  filter_type: TableFilterType;\n}\n\nexport type TableFilter = ConstantFilter | IsNullFilter | IsNotNullFilter | ConjunctionOrFilter | ConjunctionAndFilter;\n\nexport interface IsNullFilter extends BaseTableFilter {\n  filter_type: TableFilterType.IS_NULL;\n}\n\nexport interface IsNotNullFilter extends BaseTableFilter {\n  filter_type: TableFilterType.IS_NOT_NULL;\n}\n\nexport interface ConstantFilter extends BaseTableFilter {\n  filter_type: TableFilterType.CONSTANT_COMPARISON;\n  comparison_type: ExpressionType;\n  constant: Value;\n}\n\nexport interface ConjunctionOrFilter extends BaseTableFilter {\n  filter_type: TableFilterType.CONJUNCTION_OR;\n  child_filters: TableFilter[];\n}\n\nexport interface ConjunctionAndFilter extends BaseTableFilter {\n  filter_type: TableFilterType.CONJUNCTION_AND;\n  child_filters: TableFilter[];\n}\n"],"names":["TableFilterType","CONSTANT_COMPARISON","IS_NULL","IS_NOT_NULL","CONJUNCTION_OR","CONJUNCTION_AND"],"mappings":";;;;;;;IAGO;UAAKA,eAAe;IAAfA,gBACVC,yBAAAA;IADUD,gBAEVE,aAAAA;IAFUF,gBAGVG,iBAAAA;IAHUH,gBAIVI,oBAAAA;IAJUJ,gBAKVK,qBAAAA;GALUL,oBAAAA"}

package/src/types/duckdb-serialization-types/serialization/TableRef.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/TableRef.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/TableRef.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/TableRef.ts"],"sourcesContent":["import { LogicalType, PivotColumn, SampleOptions } from './Nodes';\nimport { ParsedExpression } from './ParsedExpression';\nimport { SelectStatement } from './Statement';\n\nexport enum TableReferenceType {\n  INVALID = 'INVALID',\n  BASE_TABLE = 'BASE_TABLE',\n  SUBQUERY = 'SUBQUERY',\n  JOIN = 'JOIN',\n  TABLE_FUNCTION = 'TABLE_FUNCTION',\n  EXPRESSION_LIST = 'EXPRESSION_LIST',\n  CTE = 'CTE',\n  EMPTY = 'EMPTY',\n  PIVOT = 'PIVOT',\n}\n\nexport interface BaseTableRef {\n  type: TableReferenceType;\n  alias: string;\n  sample: SampleOptions | null;\n}\n\nexport type TableRef =\n  | BaseTypeTableRef\n  | SubqueryRef\n  | JoinRef\n  | TableFunctionRef\n  | ExpressionListRef\n  | EmptyTableRef\n  | PivotRef;\n\nexport interface BaseTypeTableRef extends BaseTableRef {\n  type: TableReferenceType.BASE_TABLE;\n  schema_name: string;\n  table_name: string;\n  column_name_alias: string[];\n  catalog_name: string;\n}\n\nexport enum JoinType {\n  INVALID = 'INVALID',\n  LEFT = 'LEFT',\n  RIGHT = 'RIGHT',\n  INNER = 'INNER',\n  OUTER = 'OUTER',\n  SEMI = 'SEMI',\n  ANTI = 'ANTI',\n  MARK = 'MARK',\n  SINGLE = 'SINGLE',\n}\n\nexport enum JoinRefType {\n  REGULAR = 'REGULAR',\n  NATURAL = 'NATURAL',\n  CROSS = 'CROSS',\n  POSITIONAL = 'POSITIONAL',\n  ASOF = 'ASOF',\n  DEPENDENT = 'DEPENDENT',\n}\n\nexport interface JoinRef extends BaseTableRef {\n  type: TableReferenceType.JOIN;\n  left: TableRef;\n  right: TableRef;\n  condition?: ParsedExpression;\n  join_type: JoinType;\n  ref_type: JoinRefType;\n  using_columns: string[];\n}\n\nexport interface SubqueryRef extends BaseTableRef {\n  type: TableReferenceType.SUBQUERY;\n  subquery: SelectStatement;\n  column_name_alias: string[];\n}\n\nexport interface TableFunctionRef extends BaseTableRef {\n  type: TableReferenceType.TABLE_FUNCTION;\n  function: ParsedExpression;\n  column_name_alias: string[];\n}\n\nexport interface EmptyTableRef extends BaseTableRef {\n  type: TableReferenceType.EMPTY;\n}\n\nexport interface ExpressionListRef extends BaseTableRef {\n  type: TableReferenceType.EXPRESSION_LIST;\n  expected_names: string[];\n  expected_types: LogicalType[];\n  values: ParsedExpression[][];\n}\n\nexport interface PivotRef extends BaseTableRef {\n  type: TableReferenceType.PIVOT;\n  source: TableRef;\n  aggregates: ParsedExpression[];\n  unpivot_names: string[];\n  pivots: PivotColumn[];\n  groups: string[];\n  column_name_alias: string[];\n  include_nulls: boolean;\n}\n"],"names":["TableReferenceType","INVALID","BASE_TABLE","SUBQUERY","JOIN","TABLE_FUNCTION","EXPRESSION_LIST","CTE","EMPTY","PIVOT","JoinType","LEFT","RIGHT","INNER","OUTER","SEMI","ANTI","MARK","SINGLE","JoinRefType","REGULAR","NATURAL","CROSS","POSITIONAL","ASOF","DEPENDENT"],"mappings":";;;;;;;;;;;;;;;;;;IAIO;UAAKA,kBAAkB;IAAlBA,mBACVC,aAAAA;IADUD,mBAEVE,gBAAAA;IAFUF,mBAGVG,cAAAA;IAHUH,mBAIVI,UAAAA;IAJUJ,mBAKVK,oBAAAA;IALUL,mBAMVM,qBAAAA;IANUN,mBAOVO,SAAAA;IAPUP,mBAQVQ,WAAAA;IARUR,mBASVS,WAAAA;GATUT,uBAAAA;IAmCL;UAAKU,QAAQ;IAARA,SACVT,aAAAA;IADUS,SAEVC,UAAAA;IAFUD,SAGVE,WAAAA;IAHUF,SAIVG,WAAAA;IAJUH,SAKVI,WAAAA;IALUJ,SAMVK,UAAAA;IANUL,SAOVM,UAAAA;IAPUN,SAQVO,UAAAA;IARUP,SASVQ,YAAAA;GATUR,aAAAA;IAYL;UAAKS,WAAW;IAAXA,YACVC,aAAAA;IADUD,YAEVE,aAAAA;IAFUF,YAGVG,WAAAA;IAHUH,YAIVI,gBAAAA;IAJUJ,YAKVK,UAAAA;IALUL,YAMVM,eAAAA;GANUN,gBAAAA"}

package/src/types/duckdb-serialization-types/serialization/Types.d.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Types.d.ts"],"names":[],"mappings":""}

package/src/types/duckdb-serialization-types/serialization/Types.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/Types.ts"],"sourcesContent":["import { LogicalType } from './Nodes';\n\nexport enum ExtraTypeInfoType {\n  INVALID_TYPE_INFO = 'INVALID_TYPE_INFO',\n  GENERIC_TYPE_INFO = 'GENERIC_TYPE_INFO',\n  DECIMAL_TYPE_INFO = 'DECIMAL_TYPE_INFO',\n  STRING_TYPE_INFO = 'STRING_TYPE_INFO',\n  LIST_TYPE_INFO = 'LIST_TYPE_INFO',\n  STRUCT_TYPE_INFO = 'STRUCT_TYPE_INFO',\n  ENUM_TYPE_INFO = 'ENUM_TYPE_INFO',\n  USER_TYPE_INFO = 'USER_TYPE_INFO',\n  AGGREGATE_STATE_TYPE_INFO = 'AGGREGATE_STATE_TYPE_INFO',\n}\n\nexport interface BaseExtraTypeInfo {\n  type: ExtraTypeInfoType;\n  alias: string;\n}\n\nexport type ExtraTypeInfo =\n  | DecimalTypeInfo\n  | StringTypeInfo\n  | ListTypeInfo\n  | StructTypeInfo\n  | AggregateStateTypeInfo\n  | UserTypeInfo\n  | EnumTypeInfo\n  | InvalidTypeInfo\n  | GenericTypeInfo;\n\nexport interface DecimalTypeInfo extends BaseExtraTypeInfo {\n  enum: 'DECIMAL_TYPE_INFO';\n  width: number;\n  scale: number;\n}\n\nexport interface StringTypeInfo extends BaseExtraTypeInfo {\n  enum: 'STRING_TYPE_INFO';\n  collation: string;\n}\n\nexport interface ListTypeInfo extends BaseExtraTypeInfo {\n  enum: 'LIST_TYPE_INFO';\n  child_type: LogicalType;\n}\n\nexport interface StructTypeInfo extends BaseExtraTypeInfo {\n  enum: 'STRUCT_TYPE_INFO';\n  child_types: LogicalType[];\n}\n\nexport interface AggregateStateTypeInfo extends BaseExtraTypeInfo {\n  enum: 'AGGREGATE_STATE_TYPE_INFO';\n  function_name: string;\n  return_type: LogicalType;\n  bound_argument_types: LogicalType[];\n}\n\nexport interface UserTypeInfo extends BaseExtraTypeInfo {\n  enum: 'USER_TYPE_INFO';\n  user_type_name: string;\n}\n\nexport interface EnumTypeInfo extends BaseExtraTypeInfo {\n  enum: 'ENUM_TYPE_INFO';\n  // custom_implementation: true; // Not sure how this translates to TypeScript\n}\n\nexport interface InvalidTypeInfo extends BaseExtraTypeInfo {\n  enum: 'INVALID_TYPE_INFO';\n  // custom_switch_code: 'return nullptr;'; // Not sure how this translates to TypeScript\n}\n\nexport interface GenericTypeInfo extends BaseExtraTypeInfo {\n  enum: 'GENERIC_TYPE_INFO';\n  // custom_switch_code: 'result = make_shared<ExtraTypeInfo>(type);\\nbreak;'; // Not sure how this translates to TypeScript\n}\n"],"names":["ExtraTypeInfoType","INVALID_TYPE_INFO","GENERIC_TYPE_INFO","DECIMAL_TYPE_INFO","STRING_TYPE_INFO","LIST_TYPE_INFO","STRUCT_TYPE_INFO","ENUM_TYPE_INFO","USER_TYPE_INFO","AGGREGATE_STATE_TYPE_INFO"],"mappings":";;;;;;;IAEO;UAAKA,iBAAiB;IAAjBA,kBACVC,uBAAAA;IADUD,kBAEVE,uBAAAA;IAFUF,kBAGVG,uBAAAA;IAHUH,kBAIVI,sBAAAA;IAJUJ,kBAKVK,oBAAAA;IALUL,kBAMVM,sBAAAA;IANUN,kBAOVO,oBAAAA;IAPUP,kBAQVQ,oBAAAA;IARUR,kBASVS,+BAAAA;GATUT,sBAAAA"}

package/src/types/duckdb-serialization-types/serialization/example.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../meerkat-core/src/types/duckdb-serialization-types/serialization/example.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from './Expression';\nimport { AggregateHandling, QueryNodeType } from './QueryNode';\nimport { ResultModifierType } from './ResultModifier';\nimport { SelectStatement } from './Statement';\nimport { JoinRefType, JoinType, TableReferenceType } from './TableRef';\n\nconst dummy: SelectStatement = {\n  node: {\n    type: QueryNodeType.SELECT_NODE,\n    modifiers: [],\n    cte_map: { map: {} },\n    select_list: [\n      {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        column_names: ['rev_org', 'id'],\n      },\n      {\n        class: ExpressionClass.FUNCTION,\n        type: ExpressionType.FUNCTION,\n        alias: '',\n        function_name: 'count_star',\n        schema: '',\n        children: [],\n        filter: null,\n        order_bys: { type: ResultModifierType.ORDER_MODIFIER, orders: [] },\n        distinct: false,\n        is_operator: false,\n        export_state: false,\n        catalog: '',\n      },\n    ],\n    from_table: {\n      type: TableReferenceType.JOIN,\n      alias: '',\n      sample: null,\n      left: {\n        type: TableReferenceType.BASE_TABLE,\n        alias: '',\n        sample: null,\n        schema_name: '',\n        table_name: 'rev_org',\n        column_name_alias: [],\n        catalog_name: '',\n      },\n      right: {\n        type: TableReferenceType.BASE_TABLE,\n        alias: '',\n        sample: null,\n        schema_name: '',\n        table_name: 'tickets',\n        column_name_alias: [],\n        catalog_name: '',\n      },\n      condition: {\n        class: ExpressionClass.COMPARISON,\n        type: ExpressionType.COMPARE_EQUAL,\n        alias: '',\n        left: {\n          class: ExpressionClass.COLUMN_REF,\n          type: ExpressionType.COLUMN_REF,\n          alias: '',\n          column_names: ['rev_org', 'id'],\n        },\n        right: {\n          class: ExpressionClass.COLUMN_REF,\n          type: ExpressionType.COLUMN_REF,\n          alias: '',\n          column_names: ['tickets', 'rev_oid'],\n        },\n      },\n      join_type: JoinType.INNER,\n      ref_type: JoinRefType.REGULAR,\n      using_columns: [],\n    },\n    where_clause: {\n      class: ExpressionClass.COMPARISON,\n      type: ExpressionType.COMPARE_EQUAL,\n      alias: '',\n      left: {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        column_names: ['rev_org', 'tier'],\n      },\n      right: {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        column_names: ['tier_1'],\n      },\n    },\n    group_expressions: [\n      {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        column_names: ['rev_org', 'id'],\n      },\n    ],\n    group_sets: new Set(),\n    aggregate_handling: AggregateHandling.STANDARD_HANDLING,\n    having: null,\n    sample: null,\n    qualify: null,\n  },\n};\n"],"names":["dummy","node","type","QueryNodeType","SELECT_NODE","modifiers","cte_map","map","select_list","class","ExpressionClass","COLUMN_REF","ExpressionType","alias","column_names","FUNCTION","function_name","schema","children","filter","order_bys","ResultModifierType","ORDER_MODIFIER","orders","distinct","is_operator","export_state","catalog","from_table","TableReferenceType","JOIN","sample","left","BASE_TABLE","schema_name","table_name","column_name_alias","catalog_name","right","condition","COMPARISON","COMPARE_EQUAL","join_type","JoinType","INNER","ref_type","JoinRefType","REGULAR","using_columns","where_clause","group_expressions","group_sets","Set","aggregate_handling","AggregateHandling","STANDARD_HANDLING","having","qualify"],"mappings":";4BAAgD;2BACC;gCACd;0BAEuB;AAE1D,MAAMA,QAAyB;IAC7BC,MAAM;QACJC,MAAMC,wBAAa,CAACC,WAAW;QAC/BC,WAAW,EAAE;QACbC,SAAS;YAAEC,KAAK,CAAC;QAAE;QACnBC,aAAa;YACX;gBACEC,OAAOC,2BAAe,CAACC,UAAU;gBACjCT,MAAMU,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACPC,cAAc;oBAAC;oBAAW;iBAAK;YACjC;YACA;gBACEL,OAAOC,2BAAe,CAACK,QAAQ;gBAC/Bb,MAAMU,0BAAc,CAACG,QAAQ;gBAC7BF,OAAO;gBACPG,eAAe;gBACfC,QAAQ;gBACRC,UAAU,EAAE;gBACZC,QAAQ;gBACRC,WAAW;oBAAElB,MAAMmB,kCAAkB,CAACC,cAAc;oBAAEC,QAAQ,EAAE;gBAAC;gBACjEC,UAAU;gBACVC,aAAa;gBACbC,cAAc;gBACdC,SAAS;YACX;SACD;QACDC,YAAY;YACV1B,MAAM2B,4BAAkB,CAACC,IAAI;YAC7BjB,OAAO;YACPkB,QAAQ;YACRC,MAAM;gBACJ9B,MAAM2B,4BAAkB,CAACI,UAAU;gBACnCpB,OAAO;gBACPkB,QAAQ;gBACRG,aAAa;gBACbC,YAAY;gBACZC,mBAAmB,EAAE;gBACrBC,cAAc;YAChB;YACAC,OAAO;gBACLpC,MAAM2B,4BAAkB,CAACI,UAAU;gBACnCpB,OAAO;gBACPkB,QAAQ;gBACRG,aAAa;gBACbC,YAAY;gBACZC,mBAAmB,EAAE;gBACrBC,cAAc;YAChB;YACAE,WAAW;gBACT9B,OAAOC,2BAAe,CAAC8B,UAAU;gBACjCtC,MAAMU,0BAAc,CAAC6B,aAAa;gBAClC5B,OAAO;gBACPmB,MAAM;oBACJvB,OAAOC,2BAAe,CAACC,UAAU;oBACjCT,MAAMU,0BAAc,CAACD,UAAU;oBAC/BE,OAAO;oBACPC,cAAc;wBAAC;wBAAW;qBAAK;gBACjC;gBACAwB,OAAO;oBACL7B,OAAOC,2BAAe,CAACC,UAAU;oBACjCT,MAAMU,0BAAc,CAACD,UAAU;oBAC/BE,OAAO;oBACPC,cAAc;wBAAC;wBAAW;qBAAU;gBACtC;YACF;YACA4B,WAAWC,kBAAQ,CAACC,KAAK;YACzBC,UAAUC,qBAAW,CAACC,OAAO;YAC7BC,eAAe,EAAE;QACnB;QACAC,cAAc;YACZxC,OAAOC,2BAAe,CAAC8B,UAAU;YACjCtC,MAAMU,0BAAc,CAAC6B,aAAa;YAClC5B,OAAO;YACPmB,MAAM;gBACJvB,OAAOC,2BAAe,CAACC,UAAU;gBACjCT,MAAMU,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACPC,cAAc;oBAAC;oBAAW;iBAAO;YACnC;YACAwB,OAAO;gBACL7B,OAAOC,2BAAe,CAACC,UAAU;gBACjCT,MAAMU,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACPC,cAAc;oBAAC;iBAAS;YAC1B;QACF;QACAoC,mBAAmB;YACjB;gBACEzC,OAAOC,2BAAe,CAACC,UAAU;gBACjCT,MAAMU,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACPC,cAAc;oBAAC;oBAAW;iBAAK;YACjC;SACD;QACDqC,YAAY,IAAIC;QAChBC,oBAAoBC,4BAAiB,CAACC,iBAAiB;QACvDC,QAAQ;QACRzB,QAAQ;QACR0B,SAAS;IACX;AACF"}

package/src/types/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/types/utils.ts"],"sourcesContent":["import {\n  BetweenExpression,\n  CaseExpression,\n  CastExpression,\n  CollateExpression,\n  ColumnRefExpression,\n  ComparisonExpression,\n  ConjunctionExpression,\n  ConstantExpression,\n  FunctionExpression,\n  LambdaExpression,\n  OperatorExpression,\n  ParameterExpression,\n  PositionalReferenceExpression,\n  SubqueryExpression,\n  WindowExpression,\n} from './duckdb-serialization-types/serialization/ParsedExpression';\n\nimport {\n  ExpressionClass,\n  QueryNode,\n  QueryNodeType,\n  SelectNode,\n} from './duckdb-serialization-types';\nimport { ParsedExpression } from './duckdb-serialization-types/serialization/ParsedExpression';\n\nexport const isSelectNode = (node: QueryNode): node is SelectNode => {\n  return node.type === QueryNodeType.SELECT_NODE;\n};\n\nexport const isBetweenExpression = (\n  node: ParsedExpression\n): node is BetweenExpression => {\n  return node.class === ExpressionClass.BETWEEN;\n};\n\nexport const isCaseExpression = (\n  node: ParsedExpression\n): node is CaseExpression => {\n  return node.class === ExpressionClass.CASE;\n};\n\nexport const isCastExpression = (\n  node: ParsedExpression\n): node is CastExpression => {\n  return node.class === ExpressionClass.CAST;\n};\n\nexport const isComparisonExpression = (\n  node: ParsedExpression\n): node is ComparisonExpression => {\n  return node.class === ExpressionClass.COMPARISON;\n};\n\nexport const isConjunctionExpression = (\n  node: ParsedExpression\n): node is ConjunctionExpression => {\n  return node.class === ExpressionClass.CONJUNCTION;\n};\n\nexport const isConstantExpression = (\n  node: ParsedExpression\n): node is ConstantExpression => {\n  return node.class === ExpressionClass.CONSTANT;\n};\n\nexport const isColumnRefExpression = (\n  node: ParsedExpression\n): node is ColumnRefExpression => {\n  return node.class === ExpressionClass.COLUMN_REF;\n};\n\nexport const isCollateExpression = (\n  node: ParsedExpression\n): node is CollateExpression => {\n  return node.class === ExpressionClass.COLLATE;\n};\n\nexport const isFunctionExpression = (\n  node: ParsedExpression\n): node is FunctionExpression => {\n  return node.class === ExpressionClass.FUNCTION;\n};\n\nexport const isLambdaExpression = (\n  node: ParsedExpression\n): node is LambdaExpression => {\n  return node.class === ExpressionClass.LAMBDA;\n};\n\nexport const isOperatorExpression = (\n  node: ParsedExpression\n): node is OperatorExpression => {\n  return node.class === ExpressionClass.OPERATOR;\n};\n\nexport const isParameterExpression = (\n  node: ParsedExpression\n): node is ParameterExpression => {\n  return node.class === ExpressionClass.PARAMETER;\n};\n\nexport const isPositionalReferenceExpression = (\n  node: ParsedExpression\n): node is PositionalReferenceExpression => {\n  return node.class === ExpressionClass.POSITIONAL_REFERENCE;\n};\n\nexport const isSubqueryExpression = (\n  node: ParsedExpression\n): node is SubqueryExpression => {\n  return node.class === ExpressionClass.SUBQUERY;\n};\n\nexport const isWindowExpression = (\n  node: ParsedExpression\n): node is WindowExpression => {\n  return node.class === ExpressionClass.WINDOW;\n};\n"],"names":["isSelectNode","isBetweenExpression","isCaseExpression","isCastExpression","isComparisonExpression","isConjunctionExpression","isConstantExpression","isColumnRefExpression","isCollateExpression","isFunctionExpression","isLambdaExpression","isOperatorExpression","isParameterExpression","isPositionalReferenceExpression","isSubqueryExpression","isWindowExpression","node","type","QueryNodeType","SELECT_NODE","class","ExpressionClass","BETWEEN","CASE","CAST","COMPARISON","CONJUNCTION","CONSTANT","COLUMN_REF","COLLATE","FUNCTION","LAMBDA","OPERATOR","PARAMETER","POSITIONAL_REFERENCE","SUBQUERY","WINDOW"],"mappings":";;;;;;;;IA0BaA,YAAY;eAAZA;;IAIAC,mBAAmB;eAAnBA;;IAMAC,gBAAgB;eAAhBA;;IAMAC,gBAAgB;eAAhBA;;IAMAC,sBAAsB;eAAtBA;;IAMAC,uBAAuB;eAAvBA;;IAMAC,oBAAoB;eAApBA;;IAMAC,qBAAqB;eAArBA;;IAMAC,mBAAmB;eAAnBA;;IAMAC,oBAAoB;eAApBA;;IAMAC,kBAAkB;eAAlBA;;IAMAC,oBAAoB;eAApBA;;IAMAC,qBAAqB;eAArBA;;IAMAC,+BAA+B;eAA/BA;;IAMAC,oBAAoB;eAApBA;;IAMAC,kBAAkB;eAAlBA;;;0CA3FN;AAGA,MAAMf,eAAe,CAACgB;IAC3B,OAAOA,KAAKC,IAAI,KAAKC,uCAAa,CAACC,WAAW;AAChD;AAEO,MAAMlB,sBAAsB,CACjCe;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACC,OAAO;AAC/C;AAEO,MAAMpB,mBAAmB,CAC9Bc;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACE,IAAI;AAC5C;AAEO,MAAMpB,mBAAmB,CAC9Ba;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACG,IAAI;AAC5C;AAEO,MAAMpB,yBAAyB,CACpCY;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACI,UAAU;AAClD;AAEO,MAAMpB,0BAA0B,CACrCW;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACK,WAAW;AACnD;AAEO,MAAMpB,uBAAuB,CAClCU;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACM,QAAQ;AAChD;AAEO,MAAMpB,wBAAwB,CACnCS;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACO,UAAU;AAClD;AAEO,MAAMpB,sBAAsB,CACjCQ;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACQ,OAAO;AAC/C;AAEO,MAAMpB,uBAAuB,CAClCO;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACS,QAAQ;AAChD;AAEO,MAAMpB,qBAAqB,CAChCM;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACU,MAAM;AAC9C;AAEO,MAAMpB,uBAAuB,CAClCK;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACW,QAAQ;AAChD;AAEO,MAAMpB,wBAAwB,CACnCI;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACY,SAAS;AACjD;AAEO,MAAMpB,kCAAkC,CAC7CG;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACa,oBAAoB;AAC5D;AAEO,MAAMpB,uBAAuB,CAClCE;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACc,QAAQ;AAChD;AAEO,MAAMpB,qBAAqB,CAChCC;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACe,MAAM;AAC9C"}