@intentius/chant-lexicon-sql 0.124.30 → 0.124.32

package/dist/postgres/overlays/extension-objects.js

@@ -0,0 +1,88 @@
+/**
+ * What the common extensions add, for lint: the types, functions, index
+ * access methods and operator classes a declaration may name once the project
+ * declares the extension. The pinned catalogs are read from a server with no
+ * extension installed, so none of these are in them.
+ *
+ * The list is not exhaustive. A name the core catalog does not have and no
+ * entry here covers is reported as a warning when the project declares any
+ * extension (it may come from one), and as an error when it declares none.
+ * A name an entry here covers, used without that extension declared, is an
+ * error that names the extension.
+ *
+ * Sources: the reference page of each contrib module
+ * (https://www.postgresql.org/docs/18/contrib.html), PostGIS
+ * (https://postgis.net/docs/reference.html) and pgvector
+ * (https://github.com/pgvector/pgvector#reference).
+ */
+const BTREE_GIN = [
+    "int2_ops", "int4_ops", "int8_ops", "float4_ops", "float8_ops", "money_ops", "oid_ops", "timestamp_ops", "timestamptz_ops",
+    "time_ops", "timetz_ops", "date_ops", "interval_ops", "macaddr_ops", "macaddr8_ops", "inet_ops", "cidr_ops", "text_ops",
+    "varchar_ops", "char_ops", "bytea_ops", "bit_ops", "varbit_ops", "numeric_ops", "enum_ops", "uuid_ops", "name_ops",
+    "bool_ops", "bpchar_ops",
+];
+const BTREE_GIST = [
+    "gist_int2_ops", "gist_int4_ops", "gist_int8_ops", "gist_float4_ops", "gist_float8_ops", "gist_numeric_ops", "gist_oid_ops",
+    "gist_timestamp_ops", "gist_timestamptz_ops", "gist_time_ops", "gist_timetz_ops", "gist_date_ops", "gist_interval_ops",
+    "gist_cash_ops", "gist_macaddr_ops", "gist_macaddr8_ops", "gist_text_ops", "gist_bpchar_ops", "gist_bytea_ops", "gist_bit_ops",
+    "gist_vbit_ops", "gist_inet_ops", "gist_cidr_ops", "gist_uuid_ops", "gist_enum_ops", "gist_bool_ops",
+];
+const VECTOR_OPS = ["vector_l2_ops", "vector_ip_ops", "vector_cosine_ops", "vector_l1_ops", "halfvec_l2_ops", "halfvec_ip_ops", "halfvec_cosine_ops", "halfvec_l1_ops", "sparsevec_l2_ops", "sparsevec_ip_ops", "sparsevec_cosine_ops", "sparsevec_l1_ops", "bit_hamming_ops", "bit_jaccard_ops"];
+export const EXTENSION_OBJECTS = {
+    bloom: { accessMethods: ["bloom"], opclasses: { bloom: ["int4_ops", "text_ops"] } },
+    btree_gin: { opclasses: { gin: BTREE_GIN } },
+    btree_gist: { opclasses: { gist: BTREE_GIST } },
+    citext: { types: ["citext"], opclasses: { btree: ["citext_ops", "citext_pattern_ops"], hash: ["citext_ops"] } },
+    cube: { types: ["cube"], functions: ["cube", "cube_dim", "cube_ll_coord", "cube_ur_coord", "cube_is_point", "cube_enlarge", "cube_subset", "cube_union", "cube_inter", "cube_size", "cube_distance"], opclasses: { gist: ["gist_cube_ops"] } },
+    earthdistance: { types: ["earth"], functions: ["earth", "earth_distance", "earth_box", "ll_to_earth", "latitude", "longitude", "sec_to_gc", "gc_to_sec"] },
+    fuzzystrmatch: { functions: ["soundex", "difference", "levenshtein", "levenshtein_less_equal", "metaphone", "dmetaphone", "dmetaphone_alt", "daitch_mokotoff"] },
+    hstore: {
+        types: ["hstore"],
+        functions: ["hstore", "akeys", "avals", "skeys", "svals", "hstore_to_array", "hstore_to_matrix", "hstore_to_json", "hstore_to_jsonb", "hstore_to_json_loose", "hstore_to_jsonb_loose", "slice", "exist", "defined", "delete", "each", "populate_record"],
+        opclasses: { gist: ["gist_hstore_ops"], gin: ["gin_hstore_ops"], btree: ["btree_hstore_ops"], hash: ["hash_hstore_ops"] },
+    },
+    intarray: {
+        functions: ["icount", "sort", "sort_asc", "sort_desc", "uniq", "idx", "subarray", "intset"],
+        opclasses: { gist: ["gist__int_ops", "gist__intbig_ops"], gin: ["gin__int_ops"] },
+    },
+    isn: { types: ["ean13", "isbn", "isbn13", "ismn", "ismn13", "issn", "issn13", "upc"], functions: ["isn_weak", "make_valid", "is_valid"] },
+    ltree: {
+        types: ["ltree", "lquery", "ltxtquery"],
+        functions: ["subltree", "subpath", "nlevel", "index", "text2ltree", "ltree2text", "lca"],
+        opclasses: { gist: ["gist_ltree_ops", "gist__ltree_ops"], btree: ["ltree_ops"], hash: ["hash_ltree_ops"] },
+    },
+    pg_trgm: {
+        functions: ["similarity", "word_similarity", "strict_word_similarity", "show_trgm", "show_limit", "set_limit"],
+        opclasses: { gin: ["gin_trgm_ops"], gist: ["gist_trgm_ops"] },
+    },
+    pgcrypto: {
+        functions: [
+            "digest", "hmac", "crypt", "gen_salt", "gen_random_bytes", "gen_random_uuid", "encrypt", "decrypt", "encrypt_iv", "decrypt_iv",
+            "pgp_sym_encrypt", "pgp_sym_encrypt_bytea", "pgp_sym_decrypt", "pgp_sym_decrypt_bytea", "pgp_pub_encrypt", "pgp_pub_encrypt_bytea",
+            "pgp_pub_decrypt", "pgp_pub_decrypt_bytea", "pgp_key_id", "armor", "dearmor", "pgp_armor_headers",
+        ],
+    },
+    postgis: {
+        types: ["geometry", "geography", "box2d", "box3d"],
+        functionPrefixes: ["st_", "postgis_"],
+        opclasses: {
+            gist: ["gist_geometry_ops_2d", "gist_geometry_ops_nd", "gist_geography_ops"],
+            brin: ["brin_geometry_inclusion_ops_2d", "brin_geometry_inclusion_ops_3d", "brin_geometry_inclusion_ops_4d", "brin_geography_inclusion_ops"],
+            spgist: ["spgist_geometry_ops_2d", "spgist_geometry_ops_3d", "spgist_geometry_ops_nd", "spgist_geography_ops_nd"],
+            btree: ["btree_geometry_ops", "btree_geography_ops"],
+            hash: ["hash_geometry_ops"],
+        },
+    },
+    seg: { types: ["seg"], opclasses: { gist: ["gist_seg_ops"] } },
+    tablefunc: { functions: ["crosstab", "normal_rand", "connectby"] },
+    unaccent: { functions: ["unaccent"] },
+    "uuid-ossp": {
+        functions: ["uuid_generate_v1", "uuid_generate_v1mc", "uuid_generate_v3", "uuid_generate_v4", "uuid_generate_v5", "uuid_nil", "uuid_ns_dns", "uuid_ns_url", "uuid_ns_oid", "uuid_ns_x500"],
+    },
+    vector: {
+        types: ["vector", "halfvec", "sparsevec"],
+        functions: ["l2_distance", "inner_product", "cosine_distance", "l1_distance", "vector_dims", "vector_norm", "l2_norm", "l2_normalize", "binary_quantize", "subvector", "hamming_distance", "jaccard_distance"],
+        accessMethods: ["hnsw", "ivfflat"],
+        opclasses: { hnsw: VECTOR_OPS, ivfflat: VECTOR_OPS.filter((o) => !o.startsWith("sparsevec") && !o.endsWith("l1_ops") && o !== "bit_jaccard_ops") },
+    },
+};

package/dist/postgres/overlays/indexes.js

@@ -0,0 +1,25 @@
+/**
+ * Index clauses. Which access method supports which of them is in the catalog
+ * (`INDEX_METHOD_PROPERTIES`: `can_include`, `can_unique`, ...); the clause
+ * shapes are here.
+ */
+import { arg } from "./kinds.js";
+export const INDEX_CLAUSES = {
+    key: {
+        summary: "{ column | (expression) } [COLLATE collation] [opclass [(parameters)]] [ASC | DESC] [NULLS FIRST | LAST]",
+        args: [
+            arg("key", "expression"),
+            arg("collation", "identifier", { optional: true }),
+            arg("opclass", "identifier", { optional: true }),
+            arg("order", "keyword", { optional: true, values: ["ASC", "DESC"] }),
+            arg("nulls", "keyword", { optional: true, values: ["FIRST", "LAST"] }),
+        ],
+    },
+    using: { summary: "USING method", args: [arg("method", "keyword")] },
+    include: { summary: "INCLUDE (columns)", args: [arg("columns", "column", { repeated: true })] },
+    where: { summary: "WHERE predicate: a partial index", args: [arg("predicate", "expression")] },
+    nullsNotDistinct: { summary: "NULLS [NOT] DISTINCT, on a unique index", args: [arg("notDistinct", "boolean")], since: 15 },
+    tablespace: { summary: "TABLESPACE name", args: [arg("tablespace", "identifier")] },
+    concurrently: { summary: "CREATE INDEX CONCURRENTLY: not inside a transaction block", args: [arg("concurrently", "boolean")] },
+    only: { summary: "ON ONLY parent: an index on a partitioned table's parent without its partitions", args: [arg("only", "boolean")] },
+};

package/dist/postgres/overlays/kinds.js

@@ -0,0 +1,2 @@
+export const arg = (name, kind, extra = {}) => ({ name, kind, ...extra });
+export const INT_MAX = 2147483647;

package/dist/postgres/overlays/partitioning.js

@@ -0,0 +1,23 @@
+/** Partitioning: `PARTITION BY`, partition bounds, `DEFAULT` partitions, `ATTACH` and `DETACH`. */
+import { arg } from "./kinds.js";
+export const PARTITION_STRATEGIES = ["RANGE", "LIST", "HASH"];
+export const PARTITIONING = {
+    partitionBy: {
+        summary: "PARTITION BY { RANGE | LIST | HASH } ({ column | (expression) } [COLLATE c] [opclass], ...)",
+        args: [arg("strategy", "keyword", { values: PARTITION_STRATEGIES }), arg("keys", "expression", { repeated: true })],
+    },
+    forValuesRange: { summary: "FOR VALUES FROM (bounds) TO (bounds); MINVALUE and MAXVALUE stand for unbounded", args: [arg("from", "expression", { repeated: true }), arg("to", "expression", { repeated: true })] },
+    forValuesList: { summary: "FOR VALUES IN (values)", args: [arg("values", "expression", { repeated: true })] },
+    forValuesHash: {
+        summary: "FOR VALUES WITH (MODULUS m, REMAINDER r)",
+        args: [arg("modulus", "number", { range: [1, 2147483647] }), arg("remainder", "number", { range: [0, 2147483646] })],
+    },
+    default: { summary: "DEFAULT partition", args: [] },
+    attach: { summary: "ALTER TABLE parent ATTACH PARTITION child { FOR VALUES ... | DEFAULT }", args: [arg("partition", "identifier")] },
+    detach: {
+        summary: "ALTER TABLE parent DETACH PARTITION child [CONCURRENTLY | FINALIZE]",
+        args: [arg("partition", "identifier"), arg("mode", "keyword", { optional: true, values: ["CONCURRENTLY", "FINALIZE"] })],
+    },
+    mergePartitions: { summary: "ALTER TABLE parent MERGE PARTITIONS (children) INTO child", args: [arg("partitions", "identifier", { repeated: true })], since: 18 },
+    splitPartition: { summary: "ALTER TABLE parent SPLIT PARTITION child INTO (partitions)", args: [arg("partition", "identifier")], since: 18 },
+};

package/dist/postgres/overlays/relations.js

@@ -0,0 +1,25 @@
+/** Table and relation clauses, views, materialized views and sequences. */
+import { arg } from "./kinds.js";
+export const RELATION_CLAUSES = {
+    persistence: { summary: "{ TEMPORARY | UNLOGGED } TABLE", args: [arg("persistence", "keyword", { values: ["TEMPORARY", "UNLOGGED"] })] },
+    inherits: { summary: "INHERITS (parents)", args: [arg("parents", "identifier", { repeated: true })] },
+    tablespace: { summary: "TABLESPACE name", args: [arg("tablespace", "identifier")] },
+    using: { summary: "USING access_method", args: [arg("method", "keyword")] },
+    onCommit: { summary: "ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP }, temporary tables only", args: [arg("action", "keyword", { values: ["PRESERVE ROWS", "DELETE ROWS", "DROP"] })] },
+    withParameters: { summary: "WITH (storage_parameter = value, ...)", args: [arg("parameters", "expression", { repeated: true })] },
+    likeSource: { summary: "LIKE source [INCLUDING | EXCLUDING option]", args: [arg("source", "identifier"), arg("options", "keyword", { optional: true, repeated: true, values: ["COMMENTS", "COMPRESSION", "CONSTRAINTS", "DEFAULTS", "GENERATED", "IDENTITY", "INDEXES", "STATISTICS", "STORAGE", "ALL"] })] },
+    ofType: { summary: "OF composite_type: a typed table", args: [arg("type", "identifier")] },
+};
+export const VIEW_CLAUSES = {
+    query: { summary: "AS query", args: [arg("query", "query")] },
+    columns: { summary: "(column_names)", args: [arg("columns", "column", { repeated: true })] },
+    recursive: { summary: "CREATE RECURSIVE VIEW", args: [arg("recursive", "boolean")] },
+    checkOption: { summary: "WITH [CASCADED | LOCAL] CHECK OPTION, on an updatable view", args: [arg("option", "keyword", { values: ["CASCADED", "LOCAL"] })] },
+    securityInvoker: { summary: "WITH (security_invoker = true): check permissions as the caller", args: [arg("securityInvoker", "boolean")], since: 15 },
+    securityBarrier: { summary: "WITH (security_barrier = true)", args: [arg("securityBarrier", "boolean")] },
+    withNoData: { summary: "WITH NO DATA: a materialized view created unpopulated", args: [arg("noData", "boolean")] },
+};
+export const SEQUENCE_CLAUSES = {
+    persistence: { summary: "[ { TEMPORARY | UNLOGGED } ] SEQUENCE", args: [arg("persistence", "keyword", { values: ["TEMPORARY", "UNLOGGED"] })] },
+    options: { summary: "AS type, INCREMENT, MINVALUE, MAXVALUE, START, CACHE, [NO] CYCLE, OWNED BY (see SEQUENCE_OPTIONS)", args: [] },
+};

package/dist/postgres/overlays/storage.js

@@ -0,0 +1,65 @@
+/**
+ * Storage parameters (`WITH (fillfactor = 70)`): the overlay half.
+ *
+ * No catalog table lists them; they are compiled into `reloptions.c`.
+ * Generation probes the server instead: it tries every `pg_settings` name plus
+ * {@link STORAGE_PARAMETER_SEED} as `WITH (name = 1)` on each relation kind
+ * and keeps every name the server does not reject as unrecognized. The probe
+ * yields names only, so the types and ranges are here, and generation fails
+ * when a name the probe found has no entry (a pin move that adds a parameter
+ * has to type it in the same commit) or an entry names nothing the probe found.
+ */
+import { INT_MAX } from "./kinds.js";
+/** The reloptions that are not `pg_settings` names, so the probe would never try them. */
+export const STORAGE_PARAMETER_SEED = [
+    "fillfactor", "toast_tuple_target", "parallel_workers", "user_catalog_table", "autovacuum_enabled",
+    "vacuum_index_cleanup", "vacuum_truncate", "autovacuum_vacuum_threshold", "autovacuum_vacuum_scale_factor",
+    "autovacuum_vacuum_max_threshold", "autovacuum_vacuum_insert_threshold", "autovacuum_vacuum_insert_scale_factor",
+    "autovacuum_analyze_threshold", "autovacuum_analyze_scale_factor", "autovacuum_vacuum_cost_delay",
+    "autovacuum_vacuum_cost_limit", "autovacuum_freeze_min_age", "autovacuum_freeze_max_age",
+    "autovacuum_freeze_table_age", "autovacuum_multixact_freeze_min_age", "autovacuum_multixact_freeze_max_age",
+    "autovacuum_multixact_freeze_table_age", "log_autovacuum_min_duration", "deduplicate_items", "buffering",
+    "fastupdate", "gin_pending_list_limit", "pages_per_range", "autosummarize", "security_barrier",
+    "security_invoker", "check_option", "vacuum_cleanup_index_scale_factor", "vacuum_max_eager_freeze_failure_rate",
+];
+const int = (min, max) => ({ kind: "integer", range: [min, max] });
+const real = (min, max) => ({ kind: "real", range: [min, max] });
+const bool = { kind: "boolean" };
+/** Keyed by parameter name; the same name has the same type on every relation kind that accepts it. */
+export const STORAGE_PARAMETER_TYPES = {
+    fillfactor: int(10, 100),
+    toast_tuple_target: int(128, 1073741823),
+    parallel_workers: int(0, 1024),
+    user_catalog_table: bool,
+    autovacuum_enabled: bool,
+    vacuum_index_cleanup: { kind: "enum", values: ["auto", "on", "off", "true", "false"] },
+    vacuum_truncate: bool,
+    autovacuum_vacuum_threshold: int(0, INT_MAX),
+    autovacuum_vacuum_scale_factor: real(0, 100),
+    autovacuum_vacuum_max_threshold: int(-1, INT_MAX),
+    autovacuum_vacuum_insert_threshold: int(-1, INT_MAX),
+    autovacuum_vacuum_insert_scale_factor: real(0, 100),
+    autovacuum_analyze_threshold: int(0, INT_MAX),
+    autovacuum_analyze_scale_factor: real(0, 100),
+    autovacuum_vacuum_cost_delay: real(-1, 100),
+    autovacuum_vacuum_cost_limit: int(-1, 10000),
+    autovacuum_freeze_min_age: int(0, 1000000000),
+    autovacuum_freeze_max_age: int(100000, 2000000000),
+    autovacuum_freeze_table_age: int(0, 2000000000),
+    autovacuum_multixact_freeze_min_age: int(0, 1000000000),
+    autovacuum_multixact_freeze_max_age: int(10000, 2000000000),
+    autovacuum_multixact_freeze_table_age: int(0, 2000000000),
+    log_autovacuum_min_duration: int(-1, INT_MAX),
+    vacuum_max_eager_freeze_failure_rate: real(0, 1),
+    security_barrier: bool,
+    security_invoker: bool,
+    check_option: { kind: "enum", values: ["local", "cascaded"] },
+    deduplicate_items: bool,
+    // Accepted and ignored since 14, which removed the feature; kept so a dump from 13 still restores.
+    vacuum_cleanup_index_scale_factor: real(0, 10000000000),
+    buffering: { kind: "enum", values: ["on", "off", "auto"] },
+    fastupdate: bool,
+    gin_pending_list_limit: int(64, INT_MAX),
+    pages_per_range: int(1, 131072),
+    autosummarize: bool,
+};

package/dist/postgres/overlays/type-ddl.js

@@ -0,0 +1,36 @@
+/**
+ * `CREATE TYPE` and `CREATE DOMAIN`: the forms for new types. The catalog lists
+ * the built-ins; the grammar for declaring more is not in it.
+ */
+import { arg } from "./kinds.js";
+export const TYPE_DDL = {
+    enum: {
+        summary: "CREATE TYPE name AS ENUM ('label', ...)",
+        args: [arg("labels", "string", { repeated: true })],
+    },
+    composite: {
+        summary: "CREATE TYPE name AS (attribute type [COLLATE c], ...)",
+        args: [arg("attributes", "type", { repeated: true })],
+    },
+    domain: {
+        summary: "CREATE DOMAIN name [AS] type [COLLATE c] [DEFAULT expression] [NOT NULL] [CHECK (expression)]",
+        args: [
+            arg("type", "type"),
+            arg("collation", "identifier", { optional: true }),
+            arg("default", "expression", { optional: true }),
+            arg("notNull", "boolean", { optional: true }),
+            arg("check", "expression", { optional: true, repeated: true }),
+        ],
+    },
+    range: {
+        summary: "CREATE TYPE name AS RANGE (SUBTYPE = type [, SUBTYPE_OPCLASS, COLLATION, CANONICAL, SUBTYPE_DIFF, MULTIRANGE_TYPE_NAME])",
+        args: [
+            arg("subtype", "type"),
+            arg("subtypeOpclass", "identifier", { optional: true }),
+            arg("collation", "identifier", { optional: true }),
+            arg("canonical", "identifier", { optional: true }),
+            arg("subtypeDiff", "identifier", { optional: true }),
+            arg("multirangeTypeName", "identifier", { optional: true }),
+        ],
+    },
+};

package/dist/postgres/overlays/types.js

@@ -0,0 +1,74 @@
+/**
+ * Column type parameters and spellings: the overlay half.
+ *
+ * `pg_type` lists the types and `format_type()` gives each one's SQL spelling
+ * (`int4` is `integer`). The parameters (`varchar(n)`, `numeric(p, s)`,
+ * `timestamp(p)`, `interval` fields) and the spellings no catalog row carries
+ * (`int`, `decimal`, `serial`) are in no catalog table. A type missing here
+ * takes no parameters; generation fails when a key here is not a type at the
+ * pins.
+ */
+import { arg } from "./kinds.js";
+/** Keyed by the canonical SQL name `format_type()` gives. */
+export const COLUMN_TYPE_PARAMETERS = {
+    "character varying": [arg("length", "number", { optional: true, range: [1, 10485760] })],
+    character: [arg("length", "number", { optional: true, range: [1, 10485760] })],
+    bit: [arg("length", "number", { optional: true, range: [1, 83886080] })],
+    "bit varying": [arg("length", "number", { optional: true, range: [1, 83886080] })],
+    numeric: [arg("precision", "number", { optional: true, range: [1, 1000] }), arg("scale", "number", { optional: true, range: [-1000, 1000] })],
+    "timestamp without time zone": [arg("precision", "number", { optional: true, range: [0, 6] })],
+    "timestamp with time zone": [arg("precision", "number", { optional: true, range: [0, 6] })],
+    "time without time zone": [arg("precision", "number", { optional: true, range: [0, 6] })],
+    "time with time zone": [arg("precision", "number", { optional: true, range: [0, 6] })],
+    interval: [
+        arg("fields", "keyword", {
+            optional: true,
+            values: ["YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND", "YEAR TO MONTH", "DAY TO HOUR", "DAY TO MINUTE", "DAY TO SECOND", "HOUR TO MINUTE", "HOUR TO SECOND", "MINUTE TO SECOND"],
+        }),
+        arg("precision", "number", { optional: true, range: [0, 6] }),
+    ],
+};
+/** Spellings that are not `format_type()` output, and the canonical name each stands for. */
+export const TYPE_SPELLINGS = {
+    int: "integer",
+    decimal: "numeric",
+    float: "double precision",
+    varchar: "character varying",
+    char: "character",
+    varbit: "bit varying",
+    timestamp: "timestamp without time zone",
+    timestamptz: "timestamp with time zone",
+    time: "time without time zone",
+    timetz: "time with time zone",
+};
+/** Pseudo-types that declare a sequence-backed column; each stands for a type plus a default and a sequence. */
+export const SERIAL_TYPES = {
+    smallserial: "smallint",
+    serial: "integer",
+    bigserial: "bigint",
+};
+/** An array suffix: `integer[]`, `text[3]`, `ARRAY`. Dimensions are documentation only to the server. */
+export const ARRAY_SUFFIX = { brackets: "[]", dimensioned: "[n]", keyword: "ARRAY" };
+/**
+ * Spellings the grammar accepts that neither `pg_type` nor {@link TYPE_SPELLINGS}
+ * lists, and the canonical name each stands for (gram.y, `Numeric`,
+ * `Character`, `ConstDatetime`). Lint reads them beside the catalog so every
+ * spelling Postgres accepts resolves. `float(p)` is `real` for p up to 24 and
+ * `double precision` above; lint reads the precision.
+ */
+export const GRAMMAR_TYPE_SPELLINGS = {
+    dec: "numeric",
+    "char varying": "character varying",
+    "national character": "character",
+    "national char": "character",
+    nchar: "character",
+    "national character varying": "character varying",
+    "national char varying": "character varying",
+    "nchar varying": "character varying",
+};
+/** The serial spellings with a width suffix, beside {@link SERIAL_TYPES}. */
+export const SERIAL_WIDTH_SPELLINGS = {
+    serial2: "smallint",
+    serial4: "integer",
+    serial8: "bigint",
+};