@devrev/meerkat-core 0.0.77

package/src/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 * 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/**\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 * Time dimension granularity data type.\n */\ntype QueryTimeDimensionGranularity =\n  | 'quarter'\n  | 'day'\n  | 'month'\n  | 'year'\n  | 'week'\n  | 'hour'\n  | 'minute'\n  | 'second';\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 * Query datetime dimention interface.\n */\ninterface QueryTimeDimension {\n  dimension: Member;\n  dateRange?: string[] | string;\n  granularity?: QueryTimeDimensionGranularity;\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 | TimeMember)[];\n  filters?: MeerkatQueryFilter[];\n  timeDimensions?: QueryTimeDimension[];\n  joinPaths?: JoinPath[];\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/**\n * Normalized filter interface.\n */\ninterface NormalizedQueryFilter extends QueryFilter {\n  dimension?: Member;\n}\n\n/**\n * Normalized query interface.\n */\ninterface NormalizedQuery extends Query {\n  filters?: NormalizedQueryFilter[];\n  rowLimit?: null | number;\n  order?: [{ id: string; desc: boolean }];\n}\n\nexport {\n  ApiScopes,\n  ApiType,\n  FilterOperator,\n  JoinPath,\n  LogicalAndFilter,\n  LogicalOrFilter,\n  MeerkatQueryFilter,\n  Member,\n  MemberType,\n  NormalizedQuery,\n  NormalizedQueryFilter,\n  Query,\n  QueryFilter,\n  QueryOrderType,\n  QueryTimeDimension,\n  QueryTimeDimensionGranularity,\n  QueryType,\n  RequestType,\n  ResultType,\n  TimeMember,\n};\n"],"names":["isJoinNode","node"],"mappings":"AAAA;;CAEC;+BAqKYA;;;eAAAA;;;AAAN,MAAMA,aAAa,CAACC;IACzB,OAAO,WAAWA;AACpB"}

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

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

package/src/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/src/types/cube-types/table.d.ts

@@ -0,0 +1,25 @@
+export type MeasureType = 'string' | 'string_array' | 'time' | 'number' | 'number_array' | 'boolean';
+export type DimensionType = 'string' | 'string_array' | 'time' | 'number' | 'number_array' | 'boolean';
+export type Measure = {
+    name: string;
+    sql: string;
+    type: MeasureType;
+};
+export type Dimension = {
+    name: string;
+    sql: string;
+    type: DimensionType;
+};
+export type Join = {
+    sql: string;
+};
+export type TableSchema = {
+    name: string;
+    sql: string;
+    measures: Measure[];
+    dimensions: Dimension[];
+    joins?: Join[];
+};
+export interface ContextParams {
+    [key: string]: string;
+}

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

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

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./serialization/Expression"), exports);
+_export_star._(require("./serialization/Nodes"), exports);
+_export_star._(require("./serialization/ParsedExpression"), exports);
+_export_star._(require("./serialization/QueryNode"), exports);
+_export_star._(require("./serialization/ResultModifier"), exports);
+_export_star._(require("./serialization/Statement"), exports);
+_export_star._(require("./serialization/TableRef"), exports);
+
+//# sourceMappingURL=index.d.js.map

package/src/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/src/types/duckdb-serialization-types/index.d.ts

@@ -0,0 +1,7 @@
+export * from './serialization/Expression';
+export * from './serialization/Nodes';
+export * from './serialization/ParsedExpression';
+export * from './serialization/QueryNode';
+export * from './serialization/ResultModifier';
+export * from './serialization/Statement';
+export * from './serialization/TableRef';

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

@@ -0,0 +1,11 @@
+"use strict";
+const _export_star = require("@swc/helpers/_/_export_star");
+_export_star._(require("./serialization/Expression"), exports);
+_export_star._(require("./serialization/Nodes"), exports);
+_export_star._(require("./serialization/ParsedExpression"), exports);
+_export_star._(require("./serialization/QueryNode"), exports);
+_export_star._(require("./serialization/ResultModifier"), exports);
+_export_star._(require("./serialization/Statement"), exports);
+_export_star._(require("./serialization/TableRef"), exports);
+
+//# sourceMappingURL=index.js.map

package/src/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/src/types/duckdb-serialization-types/serialization/Constraint.d.ts

@@ -0,0 +1,47 @@
+import { ParsedExpression } from './ParsedExpression';
+export declare enum ConstraintType {
+    INVALID = "INVALID",
+    NOT_NULL = "NOT_NULL",
+    CHECK = "CHECK",
+    UNIQUE = "UNIQUE",
+    FOREIGN_KEY = "FOREIGN_KEY"
+}
+export declare enum ForeignKeyType {
+    FK_TYPE_PRIMARY_KEY_TABLE = "FK_TYPE_PRIMARY_KEY_TABLE",
+    FK_TYPE_FOREIGN_KEY_TABLE = "FK_TYPE_FOREIGN_KEY_TABLE",
+    FK_TYPE_SELF_REFERENCE_TABLE = "FK_TYPE_SELF_REFERENCE_TABLE"
+}
+export interface BaseConstraint {
+    type: ConstraintType;
+}
+export type Constraint = NotNullConstraint | CheckConstraint | ForeignKeyConstraint | UniqueConstraint;
+export interface LogicalIndex {
+    index: number;
+}
+export interface PhysicalIndex {
+    index: number;
+}
+export interface NotNullConstraint extends BaseConstraint {
+    enum: 'NOT_NULL';
+    index: LogicalIndex;
+}
+export interface CheckConstraint extends BaseConstraint {
+    enum: 'CHECK';
+    expression: ParsedExpression;
+}
+export interface ForeignKeyConstraint extends BaseConstraint {
+    enum: 'FOREIGN_KEY';
+    pk_columns: string[];
+    fk_columns: string[];
+    fk_type: ForeignKeyType;
+    schema: string;
+    table: string;
+    pk_keys: PhysicalIndex[];
+    fk_keys: PhysicalIndex[];
+}
+export interface UniqueConstraint extends BaseConstraint {
+    enum: 'UNIQUE';
+    is_primary_key: boolean;
+    index: LogicalIndex;
+    columns: string[];
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ConstraintType: function() {
+        return ConstraintType;
+    },
+    ForeignKeyType: function() {
+        return ForeignKeyType;
+    }
+});
+var ConstraintType;
+(function(ConstraintType) {
+    ConstraintType["INVALID"] = "INVALID";
+    ConstraintType["NOT_NULL"] = "NOT_NULL";
+    ConstraintType["CHECK"] = "CHECK";
+    ConstraintType["UNIQUE"] = "UNIQUE";
+    ConstraintType["FOREIGN_KEY"] = "FOREIGN_KEY";
+})(ConstraintType || (ConstraintType = {}));
+var ForeignKeyType;
+(function(ForeignKeyType) {
+    ForeignKeyType["FK_TYPE_PRIMARY_KEY_TABLE"] = "FK_TYPE_PRIMARY_KEY_TABLE";
+    ForeignKeyType["FK_TYPE_FOREIGN_KEY_TABLE"] = "FK_TYPE_FOREIGN_KEY_TABLE";
+    ForeignKeyType["FK_TYPE_SELF_REFERENCE_TABLE"] = "FK_TYPE_SELF_REFERENCE_TABLE";
+})(ForeignKeyType || (ForeignKeyType = {}));
+
+//# sourceMappingURL=Constraint.js.map

package/src/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","INVALID","NOT_NULL","CHECK","UNIQUE","FOREIGN_KEY","ForeignKeyType","FK_TYPE_PRIMARY_KEY_TABLE","FK_TYPE_FOREIGN_KEY_TABLE","FK_TYPE_SELF_REFERENCE_TABLE"],"mappings":";;;;;;;;;;;;;;;IAEO;UAAKA,cAAc;IAAdA,eACVC,aAAAA;IADUD,eAEVE,cAAAA;IAFUF,eAGVG,WAAAA;IAHUH,eAIVI,YAAAA;IAJUJ,eAKVK,iBAAAA;GALUL,mBAAAA;IAQL;UAAKM,cAAc;IAAdA,eACVC,+BAAAA;IADUD,eAEVE,+BAAAA;IAFUF,eAGVG,kCAAAA;GAHUH,mBAAAA"}

package/src/types/duckdb-serialization-types/serialization/CreateInfo.d.ts

@@ -0,0 +1,95 @@
+import { Constraint } from './Constraint';
+import { MacroFunction } from './MacroFunction';
+import { Value } from './Misc';
+import { ColumnList, LogicalType } from './Nodes';
+import { ParsedExpression } from './ParsedExpression';
+import { SelectStatement } from './Statement';
+export declare enum OnCreateConflict {
+    ERROR_ON_CONFLICT = "ERROR_ON_CONFLICT",
+    IGNORE_ON_CONFLICT = "IGNORE_ON_CONFLICT",
+    REPLACE_ON_CONFLICT = "REPLACE_ON_CONFLICT",
+    ALTER_ON_CONFLICT = "ALTER_ON_CONFLICT"
+}
+export declare enum CatalogType {
+    INVALID = "INVALID",
+    TABLE_ENTRY = "TABLE_ENTRY",
+    SCHEMA_ENTRY = "SCHEMA_ENTRY",
+    VIEW_ENTRY = "VIEW_ENTRY",
+    INDEX_ENTRY = "INDEX_ENTRY",
+    PREPARED_STATEMENT = "PREPARED_STATEMENT",
+    SEQUENCE_ENTRY = "SEQUENCE_ENTRY",
+    COLLATION_ENTRY = "COLLATION_ENTRY",
+    TYPE_ENTRY = "TYPE_ENTRY",
+    DATABASE_ENTRY = "DATABASE_ENTRY",
+    TABLE_FUNCTION_ENTRY = "TABLE_FUNCTION_ENTRY",
+    SCALAR_FUNCTION_ENTRY = "SCALAR_FUNCTION_ENTRY",
+    AGGREGATE_FUNCTION_ENTRY = "AGGREGATE_FUNCTION_ENTRY",
+    PRAGMA_FUNCTION_ENTRY = "PRAGMA_FUNCTION_ENTRY",
+    COPY_FUNCTION_ENTRY = "COPY_FUNCTION_ENTRY",
+    MACRO_ENTRY = "MACRO_ENTRY",
+    TABLE_MACRO_ENTRY = "TABLE_MACRO_ENTRY",
+    UPDATED_ENTRY = "UPDATED_ENTRY",
+    DELETED_ENTRY = "DELETED_ENTRY"
+}
+export interface BaseCreateInfo {
+    type: CatalogType;
+    catalog: string;
+    schema: string;
+    temporary: boolean;
+    internal: boolean;
+    on_conflict: OnCreateConflict;
+    sql: string;
+}
+export type CreateInfo = CreateIndexInfo | CreateTableInfo | CreateSchemaInfo | CreateViewInfo | CreateTypeInfo | CreateMacroInfo | CreateSequenceInfo;
+export declare enum IndexType {
+    INVALID = "INVALID",
+    ART = "ART",
+    EXTENSION = "EXTENSION"
+}
+export declare enum IndexConstraintType {
+    NONE = "NONE",
+    UNIQUE = "UNIQUE",
+    PRIMARY = "PRIMARY",
+    FOREIGN = "FOREIGN"
+}
+export interface CreateIndexInfo extends BaseCreateInfo {
+    name: string;
+    table: string;
+    index_type: IndexType;
+    constraint_type: IndexConstraintType;
+    parsed_expressions: ParsedExpression[];
+    names: string[];
+    column_ids: number[];
+    options: Record<string, Value>;
+    index_type_name: string;
+}
+export interface CreateTableInfo extends BaseCreateInfo {
+    table: string;
+    columns: ColumnList;
+    constraints: Constraint[];
+    query?: SelectStatement;
+}
+export type CreateSchemaInfo = BaseCreateInfo;
+export interface CreateViewInfo extends BaseCreateInfo {
+    view_name: string;
+    aliases: string[];
+    types: LogicalType[];
+    query?: SelectStatement;
+}
+export interface CreateTypeInfo extends BaseCreateInfo {
+    name: string;
+    logical_type: LogicalType;
+}
+export interface CreateMacroInfo extends BaseCreateInfo {
+    name: string;
+    function: MacroFunction;
+}
+export interface CreateSequenceInfo extends BaseCreateInfo {
+    name: string;
+    usage_count: number;
+    increment: number;
+    min_value: number;
+    max_value: number;
+    start_value: number;
+    cycle: boolean;
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    OnCreateConflict: function() {
+        return OnCreateConflict;
+    },
+    CatalogType: function() {
+        return CatalogType;
+    },
+    IndexType: function() {
+        return IndexType;
+    },
+    IndexConstraintType: function() {
+        return IndexConstraintType;
+    }
+});
+var OnCreateConflict;
+(function(OnCreateConflict) {
+    OnCreateConflict["ERROR_ON_CONFLICT"] = "ERROR_ON_CONFLICT";
+    OnCreateConflict["IGNORE_ON_CONFLICT"] = "IGNORE_ON_CONFLICT";
+    OnCreateConflict["REPLACE_ON_CONFLICT"] = "REPLACE_ON_CONFLICT";
+    OnCreateConflict["ALTER_ON_CONFLICT"] = "ALTER_ON_CONFLICT";
+})(OnCreateConflict || (OnCreateConflict = {}));
+var CatalogType;
+(function(CatalogType) {
+    CatalogType["INVALID"] = "INVALID";
+    CatalogType["TABLE_ENTRY"] = "TABLE_ENTRY";
+    CatalogType["SCHEMA_ENTRY"] = "SCHEMA_ENTRY";
+    CatalogType["VIEW_ENTRY"] = "VIEW_ENTRY";
+    CatalogType["INDEX_ENTRY"] = "INDEX_ENTRY";
+    CatalogType["PREPARED_STATEMENT"] = "PREPARED_STATEMENT";
+    CatalogType["SEQUENCE_ENTRY"] = "SEQUENCE_ENTRY";
+    CatalogType["COLLATION_ENTRY"] = "COLLATION_ENTRY";
+    CatalogType["TYPE_ENTRY"] = "TYPE_ENTRY";
+    CatalogType["DATABASE_ENTRY"] = "DATABASE_ENTRY";
+    CatalogType[// functions
+    "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";
+    CatalogType["DELETED_ENTRY"] = "DELETED_ENTRY";
+})(CatalogType || (CatalogType = {}));
+var IndexType;
+(function(IndexType) {
+    IndexType["INVALID"] = "INVALID";
+    IndexType["ART"] = "ART";
+    IndexType["EXTENSION"] = "EXTENSION";
+})(IndexType || (IndexType = {}));
+var IndexConstraintType;
+(function(IndexConstraintType) {
+    IndexConstraintType["NONE"] = "NONE";
+    IndexConstraintType["UNIQUE"] = "UNIQUE";
+    IndexConstraintType["PRIMARY"] = "PRIMARY";
+    IndexConstraintType["FOREIGN"] = "FOREIGN";
+})(IndexConstraintType || (IndexConstraintType = {}));
+
+//# sourceMappingURL=CreateInfo.js.map

package/src/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","ERROR_ON_CONFLICT","IGNORE_ON_CONFLICT","REPLACE_ON_CONFLICT","ALTER_ON_CONFLICT","CatalogType","INVALID","TABLE_ENTRY","SCHEMA_ENTRY","VIEW_ENTRY","INDEX_ENTRY","PREPARED_STATEMENT","SEQUENCE_ENTRY","COLLATION_ENTRY","TYPE_ENTRY","DATABASE_ENTRY","TABLE_FUNCTION_ENTRY","SCALAR_FUNCTION_ENTRY","AGGREGATE_FUNCTION_ENTRY","PRAGMA_FUNCTION_ENTRY","COPY_FUNCTION_ENTRY","MACRO_ENTRY","TABLE_MACRO_ENTRY","UPDATED_ENTRY","DELETED_ENTRY","IndexType","ART","EXTENSION","IndexConstraintType","NONE","UNIQUE","PRIMARY","FOREIGN"],"mappings":";;;;;;;;;;;;;;;;;;;;;IAOO;UAAKA,gBAAgB;IAAhBA,iBACVC,uBAAAA;IADUD,iBAEVE,wBAAAA;IAFUF,iBAGVG,yBAAAA;IAHUH,iBAIVI,uBAAAA;GAJUJ,qBAAAA;IAOL;UAAKK,WAAW;IAAXA,YACVC,aAAAA;IADUD,YAEVE,iBAAAA;IAFUF,YAGVG,kBAAAA;IAHUH,YAIVI,gBAAAA;IAJUJ,YAKVK,iBAAAA;IALUL,YAMVM,wBAAAA;IANUN,YAOVO,oBAAAA;IAPUP,YAQVQ,qBAAAA;IARUR,YASVS,gBAAAA;IATUT,YAUVU,oBAAAA;IAVUV,YAYV,YAAY;IACZW,0BAAAA;IAbUX,YAcVY,2BAAAA;IAdUZ,YAeVa,8BAAAA;IAfUb,YAgBVc,2BAAAA;IAhBUd,YAiBVe,yBAAAA;IAjBUf,YAkBVgB,iBAAAA;IAlBUhB,YAmBViB,uBAAAA;IAnBUjB,YAqBV,eAAe;IACfkB,mBAAAA;IAtBUlB,YAuBVmB,mBAAAA;GAvBUnB,gBAAAA;IA6CL;UAAKoB,SAAS;IAATA,UACVnB,aAAAA;IADUmB,UAEVC,SAAAA;IAFUD,UAGVE,eAAAA;GAHUF,cAAAA;IAML;UAAKG,mBAAmB;IAAnBA,oBACVC,UAAAA;IADUD,oBAEVE,YAAAA;IAFUF,oBAGVG,aAAAA;IAHUH,oBAIVI,aAAAA;GAJUJ,wBAAAA"}

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

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

package/src/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/duckdb-serialization-types/serialization/Expression.d.ts

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