@devrev/meerkat-core 0.0.92 → 0.0.94

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

@@ -0,0 +1 @@
+{"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/types/cube-types/query.js.map

@@ -0,0 +1 @@
+{"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/types/cube-types/table.d.js.map

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

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

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

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

@@ -0,0 +1 @@
+{"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/types/duckdb-serialization-types/index.js.map

@@ -0,0 +1 @@
+{"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/types/duckdb-serialization-types/serialization/Constraint.js.map

@@ -0,0 +1 @@
+{"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","ForeignKeyType"],"mappings":";;;;;;;;;;;;;;;;UAEYA;;;;;;GAAAA,mBAAAA;;UAQAC;;;;GAAAA,mBAAAA"}

package/{src/types → types}/duckdb-serialization-types/serialization/CreateInfo.js

@@ -6,17 +6,17 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    OnCreateConflict: function() {
-        return OnCreateConflict;
-    },
     CatalogType: function() {
         return CatalogType;
     },
+    IndexConstraintType: function() {
+        return IndexConstraintType;
+    },
     IndexType: function() {
         return IndexType;
     },
-    IndexConstraintType: function() {
-        return IndexConstraintType;
+    OnCreateConflict: function() {
+        return OnCreateConflict;
     }
 });
 var OnCreateConflict;
@@ -38,16 +38,16 @@ var CatalogType;
     CatalogType["COLLATION_ENTRY"] = "COLLATION_ENTRY";
     CatalogType["TYPE_ENTRY"] = "TYPE_ENTRY";
     CatalogType["DATABASE_ENTRY"] = "DATABASE_ENTRY";
-    CatalogType[// functions
-    "TABLE_FUNCTION_ENTRY"] = "TABLE_FUNCTION_ENTRY";
+    // functions
+    CatalogType["TABLE_FUNCTION_ENTRY"] = "TABLE_FUNCTION_ENTRY";
     CatalogType["SCALAR_FUNCTION_ENTRY"] = "SCALAR_FUNCTION_ENTRY";
     CatalogType["AGGREGATE_FUNCTION_ENTRY"] = "AGGREGATE_FUNCTION_ENTRY";
     CatalogType["PRAGMA_FUNCTION_ENTRY"] = "PRAGMA_FUNCTION_ENTRY";
     CatalogType["COPY_FUNCTION_ENTRY"] = "COPY_FUNCTION_ENTRY";
     CatalogType["MACRO_ENTRY"] = "MACRO_ENTRY";
     CatalogType["TABLE_MACRO_ENTRY"] = "TABLE_MACRO_ENTRY";
-    CatalogType[// version info
-    "UPDATED_ENTRY"] = "UPDATED_ENTRY";
+    // version info
+    CatalogType["UPDATED_ENTRY"] = "UPDATED_ENTRY";
     CatalogType["DELETED_ENTRY"] = "DELETED_ENTRY";
 })(CatalogType || (CatalogType = {}));
 var IndexType;

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

@@ -0,0 +1 @@
+{"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","CatalogType","IndexType","IndexConstraintType"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAOYA;;;;;GAAAA,qBAAAA;;UAOAC;;;;;;;;;;;IAYV,YAAY;;;;;;;;IASZ,eAAe;;;GArBLA,gBAAAA;;UA6CAC;;;;GAAAA,cAAAA;;UAMAC;;;;;GAAAA,wBAAAA"}

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

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

package/{src/types → types}/duckdb-serialization-types/serialization/Expression.js

@@ -6,11 +6,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    ExpressionType: function() {
-        return ExpressionType;
-    },
     ExpressionClass: function() {
         return ExpressionClass;
+    },
+    ExpressionType: function() {
+        return ExpressionType;
     }
 });
 var ExpressionType;

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

@@ -0,0 +1 @@
+{"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","ExpressionClass"],"mappings":";;;;;;;;;;;;;;;;UAQYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAAA,mBAAAA;;UAwEAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAAA,oBAAAA"}

package/{src/types → types}/duckdb-serialization-types/serialization/LogicalOperator.js

@@ -9,12 +9,12 @@ _export(exports, {
     DistinctType: function() {
         return DistinctType;
     },
-    OnConflictAction: function() {
-        return OnConflictAction;
-    },
     ExplainType: function() {
         return ExplainType;
     },
+    OnConflictAction: function() {
+        return OnConflictAction;
+    },
     SetScope: function() {
         return SetScope;
     }

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

@@ -0,0 +1 @@
+{"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","OnConflictAction","ExplainType","SetScope"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAiHYA;;;GAAAA,iBAAAA;;UAgGAC;;;;;GAAAA,qBAAAA;;UA4DAC;;;GAAAA,gBAAAA;;UAiBAC;;;;;GAAAA,aAAAA"}

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

@@ -0,0 +1 @@
+{"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"],"mappings":";;;;;;;;UAGYA;;;;GAAAA,cAAAA"}

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

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

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

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

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

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=Nodes.d.js.map

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

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

package/{src/types → types}/duckdb-serialization-types/serialization/Nodes.js

@@ -9,23 +9,23 @@ _export(exports, {
     CTEMaterialize: function() {
         return CTEMaterialize;
     },
-    OrderType: function() {
-        return OrderType;
+    CompressionType: function() {
+        return CompressionType;
+    },
+    DefaultOrderByNullType: function() {
+        return DefaultOrderByNullType;
     },
     OrderByNullType: function() {
         return OrderByNullType;
     },
-    DefaultOrderByNullType: function() {
-        return DefaultOrderByNullType;
+    OrderType: function() {
+        return OrderType;
     },
     SampleMethod: function() {
         return SampleMethod;
     },
     TableColumnType: function() {
         return TableColumnType;
-    },
-    CompressionType: function() {
-        return CompressionType;
     }
 });
 var CTEMaterialize;

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

@@ -0,0 +1 @@
+{"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","OrderType","OrderByNullType","DefaultOrderByNullType","SampleMethod","TableColumnType","CompressionType","FileCompressionType"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAYYA;;;;GAAAA,mBAAAA;;UAkBAC;;;;;GAAAA,cAAAA;;UAOAC;;;;;GAAAA,oBAAAA;;UAOAC;;;;;;GAAAA,2BAAAA;;UA8BAC;;;;GAAAA,iBAAAA;;UAiCAC;;;GAAAA,oBAAAA;;UAKAC;;;;;;;;;;;;GAAAA,oBAAAA;;UAsEPC;;;;;GAAAA,wBAAAA"}

package/{src/types → types}/duckdb-serialization-types/serialization/ParseInfo.js

@@ -6,20 +6,14 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    ParseInfoType: function() {
-        return ParseInfoType;
-    },
-    AlterType: function() {
-        return AlterType;
-    },
-    OnEntryNotFound: function() {
-        return OnEntryNotFound;
+    AlterForeignKeyType: function() {
+        return AlterForeignKeyType;
     },
     AlterTableType: function() {
         return AlterTableType;
     },
-    AlterForeignKeyType: function() {
-        return AlterForeignKeyType;
+    AlterType: function() {
+        return AlterType;
     },
     AlterViewType: function() {
         return AlterViewType;
@@ -30,6 +24,12 @@ _export(exports, {
     LoadType: function() {
         return LoadType;
     },
+    OnEntryNotFound: function() {
+        return OnEntryNotFound;
+    },
+    ParseInfoType: function() {
+        return ParseInfoType;
+    },
     TransactionType: function() {
         return TransactionType;
     }
@@ -99,16 +99,16 @@ var CatalogType;
     CatalogType["COLLATION_ENTRY"] = "COLLATION_ENTRY";
     CatalogType["TYPE_ENTRY"] = "TYPE_ENTRY";
     CatalogType["DATABASE_ENTRY"] = "DATABASE_ENTRY";
-    CatalogType[// functions
-    "TABLE_FUNCTION_ENTRY"] = "TABLE_FUNCTION_ENTRY";
+    // functions
+    CatalogType["TABLE_FUNCTION_ENTRY"] = "TABLE_FUNCTION_ENTRY";
     CatalogType["SCALAR_FUNCTION_ENTRY"] = "SCALAR_FUNCTION_ENTRY";
     CatalogType["AGGREGATE_FUNCTION_ENTRY"] = "AGGREGATE_FUNCTION_ENTRY";
     CatalogType["PRAGMA_FUNCTION_ENTRY"] = "PRAGMA_FUNCTION_ENTRY";
     CatalogType["COPY_FUNCTION_ENTRY"] = "COPY_FUNCTION_ENTRY";
     CatalogType["MACRO_ENTRY"] = "MACRO_ENTRY";
     CatalogType["TABLE_MACRO_ENTRY"] = "TABLE_MACRO_ENTRY";
-    CatalogType[// version info
-    "UPDATED_ENTRY"] = "UPDATED_ENTRY";
+    // version info
+    CatalogType["UPDATED_ENTRY"] = "UPDATED_ENTRY";
     CatalogType["DELETED_ENTRY"] = "DELETED_ENTRY";
 })(CatalogType || (CatalogType = {}));
 var LoadType;

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

@@ -0,0 +1 @@
+{"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","AlterType","OnEntryNotFound","AlterTableType","AlterForeignKeyType","AlterViewType","CatalogType","LoadType","TransactionType"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAKYA;;;;;;;;;;;;;GAAAA,kBAAAA;;UAmBAC;;;;;;;;GAAAA,cAAAA;;UAUAC;;;GAAAA,oBAAAA;;UAcAC;;;;;;;;;;;GAAAA,mBAAAA;;UAgDAC;;;GAAAA,wBAAAA;;UAsBAC;;;GAAAA,kBAAAA;;UAmCAC;;;;;;;;;;;IAYV,YAAY;;;;;;;;IASZ,eAAe;;;GArBLA,gBAAAA;;UAoCAC;;;;GAAAA,aAAAA;;UAkBAC;;;;;GAAAA,oBAAAA"}

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

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

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

@@ -0,0 +1 @@
+{"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","WindowBoundary"],"mappings":";;;;;;;;;;;;;;;;UA4HYA;;;;;;GAAAA,iBAAAA;;UAgBAC;;;;;;;;;;GAAAA,mBAAAA"}

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

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

package/{src/types → types}/duckdb-serialization-types/serialization/QueryNode.js

@@ -6,12 +6,12 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    QueryNodeType: function() {
-        return QueryNodeType;
-    },
     AggregateHandling: function() {
         return AggregateHandling;
     },
+    QueryNodeType: function() {
+        return QueryNodeType;
+    },
     SetOperationType: function() {
         return SetOperationType;
     }

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

@@ -0,0 +1 @@
+{"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","AggregateHandling","SetOperationType"],"mappings":";;;;;;;;;;;;;;;;;;;UAKYA;;;;;;GAAAA,kBAAAA;;UAoBAC;;;;GAAAA,sBAAAA;;UAmBAC;;;;;;GAAAA,qBAAAA"}

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

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

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

@@ -0,0 +1 @@
+{"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"],"mappings":";;;;;;;;UAGYA;;;;;GAAAA,uBAAAA"}

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"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"],"mappings":";;;;;;;;UAGYA;;;;;;GAAAA,oBAAAA"}

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

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

package/{src/types → types}/duckdb-serialization-types/serialization/TableRef.js

@@ -6,14 +6,14 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    TableReferenceType: function() {
-        return TableReferenceType;
+    JoinRefType: function() {
+        return JoinRefType;
     },
     JoinType: function() {
         return JoinType;
     },
-    JoinRefType: function() {
-        return JoinRefType;
+    TableReferenceType: function() {
+        return TableReferenceType;
     }
 });
 var TableReferenceType;

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

@@ -0,0 +1 @@
+{"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","JoinType","JoinRefType"],"mappings":";;;;;;;;;;;;;;;;;;;UAIYA;;;;;;;;;;GAAAA,uBAAAA;;UAmCAC;;;;;;;;;;GAAAA,aAAAA;;UAYAC;;;;;;;GAAAA,gBAAAA"}

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

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

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

@@ -0,0 +1 @@
+{"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"],"mappings":";;;;;;;;UAEYA;;;;;;;;;;GAAAA,sBAAAA"}

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

@@ -0,0 +1 @@
+{"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 → types}/utils.js

@@ -6,9 +6,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    isSelectNode: function() {
-        return isSelectNode;
-    },
     isBetweenExpression: function() {
         return isBetweenExpression;
     },
@@ -18,6 +15,12 @@ _export(exports, {
     isCastExpression: function() {
         return isCastExpression;
     },
+    isCollateExpression: function() {
+        return isCollateExpression;
+    },
+    isColumnRefExpression: function() {
+        return isColumnRefExpression;
+    },
     isComparisonExpression: function() {
         return isComparisonExpression;
     },
@@ -27,12 +30,6 @@ _export(exports, {
     isConstantExpression: function() {
         return isConstantExpression;
     },
-    isColumnRefExpression: function() {
-        return isColumnRefExpression;
-    },
-    isCollateExpression: function() {
-        return isCollateExpression;
-    },
     isFunctionExpression: function() {
         return isFunctionExpression;
     },
@@ -48,6 +45,9 @@ _export(exports, {
     isPositionalReferenceExpression: function() {
         return isPositionalReferenceExpression;
     },
+    isSelectNode: function() {
+        return isSelectNode;
+    },
     isSubqueryExpression: function() {
         return isSubqueryExpression;
     },

package/types/utils.js.map

@@ -0,0 +1 @@
+{"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":["isBetweenExpression","isCaseExpression","isCastExpression","isCollateExpression","isColumnRefExpression","isComparisonExpression","isConjunctionExpression","isConstantExpression","isFunctionExpression","isLambdaExpression","isOperatorExpression","isParameterExpression","isPositionalReferenceExpression","isSelectNode","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":";;;;;;;;IA8BaA,mBAAmB;eAAnBA;;IAMAC,gBAAgB;eAAhBA;;IAMAC,gBAAgB;eAAhBA;;IA8BAC,mBAAmB;eAAnBA;;IANAC,qBAAqB;eAArBA;;IAlBAC,sBAAsB;eAAtBA;;IAMAC,uBAAuB;eAAvBA;;IAMAC,oBAAoB;eAApBA;;IAkBAC,oBAAoB;eAApBA;;IAMAC,kBAAkB;eAAlBA;;IAMAC,oBAAoB;eAApBA;;IAMAC,qBAAqB;eAArBA;;IAMAC,+BAA+B;eAA/BA;;IA5EAC,YAAY;eAAZA;;IAkFAC,oBAAoB;eAApBA;;IAMAC,kBAAkB;eAAlBA;;;0CA3FN;AAGA,MAAMF,eAAe,CAACG;IAC3B,OAAOA,KAAKC,IAAI,KAAKC,uCAAa,CAACC,WAAW;AAChD;AAEO,MAAMnB,sBAAsB,CACjCgB;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACC,OAAO;AAC/C;AAEO,MAAMrB,mBAAmB,CAC9Be;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACE,IAAI;AAC5C;AAEO,MAAMrB,mBAAmB,CAC9Bc;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACG,IAAI;AAC5C;AAEO,MAAMnB,yBAAyB,CACpCW;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACI,UAAU;AAClD;AAEO,MAAMnB,0BAA0B,CACrCU;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACK,WAAW;AACnD;AAEO,MAAMnB,uBAAuB,CAClCS;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACM,QAAQ;AAChD;AAEO,MAAMvB,wBAAwB,CACnCY;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACO,UAAU;AAClD;AAEO,MAAMzB,sBAAsB,CACjCa;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACQ,OAAO;AAC/C;AAEO,MAAMrB,uBAAuB,CAClCQ;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACS,QAAQ;AAChD;AAEO,MAAMrB,qBAAqB,CAChCO;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACU,MAAM;AAC9C;AAEO,MAAMrB,uBAAuB,CAClCM;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACW,QAAQ;AAChD;AAEO,MAAMrB,wBAAwB,CACnCK;IAEA,OAAOA,KAAKI,KAAK,KAAKC,yCAAe,CAACY,SAAS;AACjD;AAEO,MAAMrB,kCAAkC,CAC7CI;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"}

package/{src/utils → utils}/__fixtures__/joins.fixtures.js

@@ -6,38 +6,38 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    CIRCULAR_TABLE_SCHEMA: function() {
-        return CIRCULAR_TABLE_SCHEMA;
-    },
-    LINEAR_TABLE_SCHEMA: function() {
-        return LINEAR_TABLE_SCHEMA;
-    },
     BASIC_JOIN_PATH: function() {
         return BASIC_JOIN_PATH;
     },
-    SINGLE_NODE_JOIN_PATH: function() {
-        return SINGLE_NODE_JOIN_PATH;
-    },
-    INTERMEDIATE_JOIN_PATH: function() {
-        return INTERMEDIATE_JOIN_PATH;
-    },
     CIRCULAR_JOIN_PATH: function() {
         return CIRCULAR_JOIN_PATH;
     },
+    CIRCULAR_TABLE_SCHEMA: function() {
+        return CIRCULAR_TABLE_SCHEMA;
+    },
+    CIRCULAR_TABLE_SCHEMA_SINGLE_JOIN_PATH: function() {
+        return CIRCULAR_TABLE_SCHEMA_SINGLE_JOIN_PATH;
+    },
     COMPLEX_JOIN_PATH: function() {
         return COMPLEX_JOIN_PATH;
     },
+    EXPECTED_CIRCULAR_TABLE_SCHEMA_INTERMEDIATE_JOIN_PATH: function() {
+        return EXPECTED_CIRCULAR_TABLE_SCHEMA_INTERMEDIATE_JOIN_PATH;
+    },
     EXPECTED_OUTPUT_WITH_ONE_DEPTH: function() {
         return EXPECTED_OUTPUT_WITH_ONE_DEPTH;
     },
     EXPECTED_OUTPUT_WITH_TWO_DEPTH: function() {
         return EXPECTED_OUTPUT_WITH_TWO_DEPTH;
     },
-    CIRCULAR_TABLE_SCHEMA_SINGLE_JOIN_PATH: function() {
-        return CIRCULAR_TABLE_SCHEMA_SINGLE_JOIN_PATH;
+    INTERMEDIATE_JOIN_PATH: function() {
+        return INTERMEDIATE_JOIN_PATH;
     },
-    EXPECTED_CIRCULAR_TABLE_SCHEMA_INTERMEDIATE_JOIN_PATH: function() {
-        return EXPECTED_CIRCULAR_TABLE_SCHEMA_INTERMEDIATE_JOIN_PATH;
+    LINEAR_TABLE_SCHEMA: function() {
+        return LINEAR_TABLE_SCHEMA;
+    },
+    SINGLE_NODE_JOIN_PATH: function() {
+        return SINGLE_NODE_JOIN_PATH;
     }
 });
 const CIRCULAR_TABLE_SCHEMA = [