@devrev/meerkat-core 0.0.97 → 0.0.99

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

@@ -1,47 +0,0 @@
-"use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    DistinctType: function() {
-        return DistinctType;
-    },
-    ExplainType: function() {
-        return ExplainType;
-    },
-    OnConflictAction: function() {
-        return OnConflictAction;
-    },
-    SetScope: function() {
-        return SetScope;
-    }
-});
-var DistinctType;
-(function(DistinctType) {
-    DistinctType["DISTINCT"] = "DISTINCT";
-    DistinctType["DISTINCT_ON"] = "DISTINCT_ON";
-})(DistinctType || (DistinctType = {}));
-var OnConflictAction;
-(function(OnConflictAction) {
-    OnConflictAction["THROW"] = "THROW";
-    OnConflictAction["NOTHING"] = "NOTHING";
-    OnConflictAction["UPDATE"] = "UPDATE";
-    OnConflictAction["REPLACE"] = "REPLACE";
-})(OnConflictAction || (OnConflictAction = {}));
-var ExplainType;
-(function(ExplainType) {
-    ExplainType["EXPLAIN_STANDARD"] = "EXPLAIN_STANDARD";
-    ExplainType["EXPLAIN_ANALYZE"] = "EXPLAIN_ANALYZE";
-})(ExplainType || (ExplainType = {}));
-var SetScope;
-(function(SetScope) {
-    SetScope["AUTOMATIC"] = "AUTOMATIC";
-    SetScope["LOCAL"] = "LOCAL";
-    SetScope["SESSION"] = "SESSION";
-    SetScope["GLOBAL"] = "GLOBAL";
-})(SetScope || (SetScope = {}));
-
-//# sourceMappingURL=LogicalOperator.js.map

package/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","OnConflictAction","ExplainType","SetScope"],"mappings":";;;;;;;;;;;;;;;;;;;;;;UAiHYA;;;GAAAA,iBAAAA;;UAgGAC;;;;;GAAAA,qBAAAA;;UA4DAC;;;GAAAA,gBAAAA;;UAiBAC;;;;;GAAAA,aAAAA"}

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

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "MacroType", {
-    enumerable: true,
-    get: function() {
-        return MacroType;
-    }
-});
-var MacroType;
-(function(MacroType) {
-    MacroType["VOID_MACRO"] = "VOID_MACRO";
-    MacroType["TABLE_MACRO"] = "TABLE_MACRO";
-    MacroType["SCALAR_MACRO"] = "SCALAR_MACRO";
-})(MacroType || (MacroType = {}));
-
-//# sourceMappingURL=MacroFunction.js.map

package/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"],"mappings":";;;;;;;;UAGYA;;;;GAAAA,cAAAA"}

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

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

package/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/types/duckdb-serialization-types/serialization/Misc.js

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

package/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/types/duckdb-serialization-types/serialization/Nodes.d.js

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

package/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"],"names":[],"mappings":""}

package/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","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/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","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

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

package/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/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","WindowBoundary"],"mappings":";;;;;;;;;;;;;;;;UA4HYA;;;;;;GAAAA,iBAAAA;;UAgBAC;;;;;;;;;;GAAAA,mBAAAA"}

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

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

package/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/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","AggregateHandling","SetOperationType"],"mappings":";;;;;;;;;;;;;;;;;;;UAKYA;;;;;;GAAAA,kBAAAA;;UAoBAC;;;;GAAAA,sBAAAA;;UAmBAC;;;;;;GAAAA,qBAAAA"}

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

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

package/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/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"],"mappings":";;;;;;;;UAGYA;;;;;GAAAA,uBAAAA"}

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

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

package/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/types/duckdb-serialization-types/serialization/Statement.js

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

package/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/types/duckdb-serialization-types/serialization/TableFilter.d.js

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

package/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/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"],"mappings":";;;;;;;;UAGYA;;;;;;GAAAA,oBAAAA"}

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

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

package/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/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","JoinType","JoinRefType"],"mappings":";;;;;;;;;;;;;;;;;;;UAIYA;;;;;;;;;;GAAAA,uBAAAA;;UAmCAC;;;;;;;;;;GAAAA,aAAAA;;UAYAC;;;;;;;GAAAA,gBAAAA"}

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

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

package/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/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"],"mappings":";;;;;;;;UAEYA;;;;;;;;;;GAAAA,sBAAAA"}

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

@@ -1,131 +0,0 @@
-"use strict";
-const _Expression = require("./Expression");
-const _QueryNode = require("./QueryNode");
-const _ResultModifier = require("./ResultModifier");
-const _TableRef = require("./TableRef");
-const dummy = {
-    node: {
-        type: _QueryNode.QueryNodeType.SELECT_NODE,
-        modifiers: [],
-        cte_map: {
-            map: {}
-        },
-        select_list: [
-            {
-                class: _Expression.ExpressionClass.COLUMN_REF,
-                type: _Expression.ExpressionType.COLUMN_REF,
-                alias: '',
-                column_names: [
-                    'rev_org',
-                    'id'
-                ]
-            },
-            {
-                class: _Expression.ExpressionClass.FUNCTION,
-                type: _Expression.ExpressionType.FUNCTION,
-                alias: '',
-                function_name: 'count_star',
-                schema: '',
-                children: [],
-                filter: null,
-                order_bys: {
-                    type: _ResultModifier.ResultModifierType.ORDER_MODIFIER,
-                    orders: []
-                },
-                distinct: false,
-                is_operator: false,
-                export_state: false,
-                catalog: ''
-            }
-        ],
-        from_table: {
-            type: _TableRef.TableReferenceType.JOIN,
-            alias: '',
-            sample: null,
-            left: {
-                type: _TableRef.TableReferenceType.BASE_TABLE,
-                alias: '',
-                sample: null,
-                schema_name: '',
-                table_name: 'rev_org',
-                column_name_alias: [],
-                catalog_name: ''
-            },
-            right: {
-                type: _TableRef.TableReferenceType.BASE_TABLE,
-                alias: '',
-                sample: null,
-                schema_name: '',
-                table_name: 'tickets',
-                column_name_alias: [],
-                catalog_name: ''
-            },
-            condition: {
-                class: _Expression.ExpressionClass.COMPARISON,
-                type: _Expression.ExpressionType.COMPARE_EQUAL,
-                alias: '',
-                left: {
-                    class: _Expression.ExpressionClass.COLUMN_REF,
-                    type: _Expression.ExpressionType.COLUMN_REF,
-                    alias: '',
-                    column_names: [
-                        'rev_org',
-                        'id'
-                    ]
-                },
-                right: {
-                    class: _Expression.ExpressionClass.COLUMN_REF,
-                    type: _Expression.ExpressionType.COLUMN_REF,
-                    alias: '',
-                    column_names: [
-                        'tickets',
-                        'rev_oid'
-                    ]
-                }
-            },
-            join_type: _TableRef.JoinType.INNER,
-            ref_type: _TableRef.JoinRefType.REGULAR,
-            using_columns: []
-        },
-        where_clause: {
-            class: _Expression.ExpressionClass.COMPARISON,
-            type: _Expression.ExpressionType.COMPARE_EQUAL,
-            alias: '',
-            left: {
-                class: _Expression.ExpressionClass.COLUMN_REF,
-                type: _Expression.ExpressionType.COLUMN_REF,
-                alias: '',
-                column_names: [
-                    'rev_org',
-                    'tier'
-                ]
-            },
-            right: {
-                class: _Expression.ExpressionClass.COLUMN_REF,
-                type: _Expression.ExpressionType.COLUMN_REF,
-                alias: '',
-                column_names: [
-                    'tier_1'
-                ]
-            }
-        },
-        group_expressions: [
-            {
-                class: _Expression.ExpressionClass.COLUMN_REF,
-                type: _Expression.ExpressionType.COLUMN_REF,
-                alias: '',
-                column_names: [
-                    'rev_org',
-                    'id'
-                ]
-            }
-        ],
-        group_sets: new Set(),
-        aggregate_handling: _QueryNode.AggregateHandling.STANDARD_HANDLING,
-        having: null,
-        sample: null,
-        qualify: null
-    }
-};
-
-//# sourceMappingURL=example.js.map

package/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/types/utils.js

@@ -1,108 +0,0 @@
-"use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    isBetweenExpression: function() {
-        return isBetweenExpression;
-    },
-    isCaseExpression: function() {
-        return isCaseExpression;
-    },
-    isCastExpression: function() {
-        return isCastExpression;
-    },
-    isCollateExpression: function() {
-        return isCollateExpression;
-    },
-    isColumnRefExpression: function() {
-        return isColumnRefExpression;
-    },
-    isComparisonExpression: function() {
-        return isComparisonExpression;
-    },
-    isConjunctionExpression: function() {
-        return isConjunctionExpression;
-    },
-    isConstantExpression: function() {
-        return isConstantExpression;
-    },
-    isFunctionExpression: function() {
-        return isFunctionExpression;
-    },
-    isLambdaExpression: function() {
-        return isLambdaExpression;
-    },
-    isOperatorExpression: function() {
-        return isOperatorExpression;
-    },
-    isParameterExpression: function() {
-        return isParameterExpression;
-    },
-    isPositionalReferenceExpression: function() {
-        return isPositionalReferenceExpression;
-    },
-    isSelectNode: function() {
-        return isSelectNode;
-    },
-    isSubqueryExpression: function() {
-        return isSubqueryExpression;
-    },
-    isWindowExpression: function() {
-        return isWindowExpression;
-    }
-});
-const _duckdbserializationtypes = require("./duckdb-serialization-types");
-const isSelectNode = (node)=>{
-    return node.type === _duckdbserializationtypes.QueryNodeType.SELECT_NODE;
-};
-const isBetweenExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.BETWEEN;
-};
-const isCaseExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.CASE;
-};
-const isCastExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.CAST;
-};
-const isComparisonExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.COMPARISON;
-};
-const isConjunctionExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.CONJUNCTION;
-};
-const isConstantExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.CONSTANT;
-};
-const isColumnRefExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.COLUMN_REF;
-};
-const isCollateExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.COLLATE;
-};
-const isFunctionExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.FUNCTION;
-};
-const isLambdaExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.LAMBDA;
-};
-const isOperatorExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.OPERATOR;
-};
-const isParameterExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.PARAMETER;
-};
-const isPositionalReferenceExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.POSITIONAL_REFERENCE;
-};
-const isSubqueryExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.SUBQUERY;
-};
-const isWindowExpression = (node)=>{
-    return node.class === _duckdbserializationtypes.ExpressionClass.WINDOW;
-};
-
-//# sourceMappingURL=utils.js.map

package/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":["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"}