@jaepil/usqldb 0.3.0

package/dist/usqldb.es.js

@@ -0,0 +1,3598 @@
+var ue = Object.defineProperty;
+var _e = (u, e, l) => e in u ? ue(u, e, { enumerable: !0, configurable: !0, writable: !0, value: l }) : u[e] = l;
+var A = (u, e, l) => _e(u, typeof e != "symbol" ? e + "" : e, l);
+import { Engine as de } from "@jaepil/uqa";
+function me(u) {
+  if (u.length === 0) return u;
+  const e = [];
+  for (const l of u) {
+    const o = {};
+    for (const [t, n] of Object.entries(l))
+      typeof n == "boolean" ? o[t] = n ? 1 : 0 : typeof n == "number" && (Number.isNaN(n) || !Number.isFinite(n)) ? o[t] = null : o[t] = n;
+    e.push(o);
+  }
+  return e;
+}
+const ee = {
+  boolean: 16,
+  bool: 16,
+  bytea: 17,
+  name: 19,
+  bigint: 20,
+  int8: 20,
+  smallint: 21,
+  int2: 21,
+  integer: 23,
+  int: 23,
+  int4: 23,
+  oid: 26,
+  text: 25,
+  json: 114,
+  xml: 142,
+  point: 600,
+  real: 700,
+  float: 700,
+  float4: 700,
+  "double precision": 701,
+  float8: 701,
+  character: 1042,
+  char: 1042,
+  "character varying": 1043,
+  varchar: 1043,
+  date: 1082,
+  time: 1083,
+  timestamp: 1114,
+  "timestamp without time zone": 1114,
+  timestamptz: 1184,
+  "timestamp with time zone": 1184,
+  interval: 1186,
+  numeric: 1700,
+  decimal: 1700,
+  uuid: 2950,
+  jsonb: 3802,
+  serial: 23,
+  bigserial: 20,
+  vector: 16385
+}, Z = {
+  16: 1e3,
+  // bool[]
+  17: 1001,
+  // bytea[]
+  20: 1016,
+  // int8[]
+  21: 1005,
+  // int2[]
+  23: 1007,
+  // int4[]
+  25: 1009,
+  // text[]
+  26: 1028,
+  // oid[]
+  114: 199,
+  // json[]
+  700: 1021,
+  // float4[]
+  701: 1022,
+  // float8[]
+  1042: 1014,
+  // bpchar[]
+  1043: 1015,
+  // varchar[]
+  1082: 1182,
+  // date[]
+  1083: 1183,
+  // time[]
+  1114: 1115,
+  // timestamp[]
+  1184: 1185,
+  // timestamptz[]
+  1700: 1231,
+  // numeric[]
+  2950: 2951,
+  // uuid[]
+  3802: 3807
+  // jsonb[]
+}, J = {
+  pg_catalog: 11,
+  public: 2200,
+  information_schema: 13182
+}, R = 1, T = 10, z = 403, pe = 405, te = 2, fe = 16386, ge = 16387, ne = {
+  int: "integer",
+  int2: "smallint",
+  int4: "integer",
+  int8: "bigint",
+  float: "real",
+  float4: "real",
+  float8: "double precision",
+  bool: "boolean",
+  serial: "integer",
+  bigserial: "bigint",
+  decimal: "numeric",
+  char: "character",
+  "character varying": "character varying",
+  varchar: "character varying",
+  name: "name",
+  "timestamp without time zone": "timestamp without time zone",
+  "timestamp with time zone": "timestamp with time zone"
+}, ae = {
+  16: 1,
+  // bool
+  17: -1,
+  // bytea
+  19: 64,
+  // name
+  20: 8,
+  // int8
+  21: 2,
+  // int2
+  23: 4,
+  // int4
+  25: -1,
+  // text
+  26: 4,
+  // oid
+  114: -1,
+  // json
+  142: -1,
+  // xml
+  600: 16,
+  // point
+  700: 4,
+  // float4
+  701: 8,
+  // float8
+  1042: -1,
+  // bpchar
+  1043: -1,
+  // varchar
+  1082: 4,
+  // date
+  1083: 8,
+  // time
+  1114: 8,
+  // timestamp
+  1184: 8,
+  // timestamptz
+  1186: 16,
+  // interval
+  1700: -1,
+  // numeric
+  2950: 16,
+  // uuid
+  3802: -1,
+  // jsonb
+  16385: -1
+  // vector
+}, le = {
+  16: !0,
+  // bool
+  21: !0,
+  // int2
+  23: !0,
+  // int4
+  26: !0,
+  // oid
+  700: !0
+  // float4
+}, K = {
+  16: "c",
+  // char alignment
+  17: "i",
+  // int alignment
+  19: "c",
+  // char
+  20: "d",
+  // double
+  21: "s",
+  // short
+  23: "i",
+  // int
+  25: "i",
+  // int
+  26: "i",
+  // int
+  700: "i",
+  // int
+  701: "d",
+  // double
+  1042: "i",
+  // int
+  1043: "i",
+  // int
+  1082: "i",
+  // int
+  1083: "d",
+  // double
+  1114: "d",
+  // double
+  1184: "d",
+  // double
+  1186: "d",
+  // double
+  1700: "i",
+  // int
+  2950: "c",
+  // char
+  3802: "i"
+  // int
+}, V = {
+  16: "p",
+  // plain
+  17: "x",
+  // extended
+  19: "p",
+  // plain
+  20: "p",
+  // plain
+  21: "p",
+  // plain
+  23: "p",
+  // plain
+  25: "x",
+  // extended
+  26: "p",
+  // plain
+  114: "x",
+  // extended
+  700: "p",
+  // plain
+  701: "p",
+  // plain
+  1042: "x",
+  // extended
+  1043: "x",
+  // extended
+  1082: "p",
+  // plain
+  1114: "p",
+  // plain
+  1184: "p",
+  // plain
+  1700: "m",
+  // main
+  2950: "p",
+  // plain
+  3802: "x"
+  // extended
+};
+function I(u) {
+  if (u.endsWith("[]")) {
+    const e = u.slice(0, -2), l = ee[e] ?? 25;
+    return Z[l] ?? 1009;
+  }
+  return ee[u] ?? 25;
+}
+function Y(u) {
+  if (u.endsWith("[]")) {
+    const e = u.slice(0, -2);
+    return `${ne[e] ?? e}[]`;
+  }
+  return ne[u] ?? u;
+}
+function L(u) {
+  const e = I(u);
+  return {
+    21: 16,
+    // int2
+    23: 32,
+    // int4
+    20: 64,
+    // int8
+    700: 24,
+    // float4
+    701: 53
+    // float8
+  }[e] ?? null;
+}
+function W(u) {
+  const e = I(u);
+  return e === 21 || e === 23 || e === 20 ? 0 : null;
+}
+function B(u) {
+  const e = I(u);
+  return e === 21 || e === 23 || e === 20 || e === 1700 ? 10 : e === 700 || e === 701 ? 2 : null;
+}
+function be(u) {
+  return null;
+}
+function ye(u) {
+  const e = I(u);
+  return e === 25 || e === 1042 || e === 1043 ? 1073741824 : null;
+}
+class he {
+  constructor(e) {
+    A(this, "_map");
+    A(this, "_next");
+    this._map = /* @__PURE__ */ new Map(), this._next = 16384, this._build(e);
+  }
+  _alloc() {
+    const e = this._next;
+    return this._next += 1, e;
+  }
+  _build(e) {
+    for (const t of [...e._tables.keys()].sort())
+      this._map.set(`table:${t}`, this._alloc()), this._map.set(`table_type:${t}`, this._alloc()), this._map.set(`toast:${t}`, this._alloc());
+    for (const t of [...e._views.keys()].sort())
+      this._map.set(`view:${t}`, this._alloc());
+    for (const t of [...e._sequences.keys()].sort())
+      this._map.set(`sequence:${t}`, this._alloc());
+    for (const t of [...e._foreignTables.keys()].sort())
+      this._map.set(`foreign_table:${t}`, this._alloc());
+    for (const t of [...e._foreignServers.keys()].sort())
+      this._map.set(`foreign_server:${t}`, this._alloc());
+    const l = /* @__PURE__ */ new Set();
+    for (const t of e._foreignServers.values())
+      l.add(t.fdwType);
+    for (const t of [...l].sort())
+      this._map.set(`fdw:${t}`, this._alloc());
+    const o = e._indexManager;
+    if (o != null) {
+      const t = o._indexes;
+      if (t !== void 0)
+        for (const n of [...t.keys()].sort())
+          this._map.set(`index:${n}`, this._alloc());
+    }
+    for (const t of [...e._tables.keys()].sort()) {
+      const n = e._tables.get(t);
+      n.primaryKey && (this._map.set(`constraint:${t}_pkey`, this._alloc()), this._map.set(`index:${t}_pkey`, this._alloc()));
+      for (const [a, s] of n.columns)
+        s.unique && !s.primaryKey && (this._map.set(`constraint:${t}_${a}_key`, this._alloc()), this._map.set(`index:${t}_${a}_key`, this._alloc()));
+      for (const a of n.foreignKeys)
+        this._map.set(`constraint:${t}_${a.column}_fkey`, this._alloc());
+      for (const [a] of n.checkConstraints)
+        this._map.set(`constraint:${t}_${a}_check`, this._alloc());
+    }
+  }
+  get(e, l) {
+    return this._map.get(`${e}:${l}`) ?? null;
+  }
+  getOrAlloc(e, l) {
+    const o = `${e}:${l}`, t = this._map.get(o);
+    if (t !== void 0) return t;
+    const n = this._alloc();
+    return this._map.set(o, n), n;
+  }
+  relationOid(e, l) {
+    for (const o of ["table", "view", "foreign_table", "sequence"]) {
+      const t = this._map.get(`${o}:${e}`);
+      if (t !== void 0) return t;
+    }
+    return null;
+  }
+  allByCategory(e) {
+    const l = `${e}:`, o = /* @__PURE__ */ new Map();
+    for (const [t, n] of this._map)
+      t.startsWith(l) && o.set(t.slice(l.length), n);
+    return o;
+  }
+}
+const m = "uqa", h = "public", q = "uqa";
+function se(u) {
+  const e = {
+    integer: "int4",
+    int: "int4",
+    int4: "int4",
+    bigint: "int8",
+    int8: "int8",
+    smallint: "int2",
+    int2: "int2",
+    serial: "int4",
+    bigserial: "int8",
+    text: "text",
+    varchar: "varchar",
+    "character varying": "varchar",
+    character: "bpchar",
+    char: "bpchar",
+    name: "name",
+    boolean: "bool",
+    bool: "bool",
+    real: "float4",
+    float: "float4",
+    float4: "float4",
+    "double precision": "float8",
+    float8: "float8",
+    numeric: "numeric",
+    decimal: "numeric",
+    date: "date",
+    timestamp: "timestamp",
+    "timestamp without time zone": "timestamp",
+    timestamptz: "timestamptz",
+    "timestamp with time zone": "timestamptz",
+    json: "json",
+    jsonb: "jsonb",
+    uuid: "uuid",
+    bytea: "bytea",
+    point: "point",
+    vector: "vector"
+  };
+  if (u.endsWith("[]")) {
+    const l = u.slice(0, -2);
+    return `_${e[l] ?? l}`;
+  }
+  return e[u] ?? u;
+}
+function ve(u) {
+  return typeof u == "string" ? `'${u.replace(/'/g, "''")}'::text` : typeof u == "boolean" ? u ? "true" : "false" : String(u);
+}
+function oe(u) {
+  return u.typeName === "float" && u.numericScale !== null ? "numeric" : u.typeName;
+}
+const k = class k {
+  static supportedViews() {
+    return Object.keys(k._VIEWS);
+  }
+  static build(e, l, o) {
+    const t = k._VIEWS[e];
+    if (t === void 0)
+      throw new Error(`Unknown information_schema view: '${e}'`);
+    return t(l, o);
+  }
+  // ==================================================================
+  // information_schema.schemata
+  // ==================================================================
+  static _buildSchemata(e, l) {
+    return [[
+      "catalog_name",
+      "schema_name",
+      "schema_owner",
+      "default_character_set_catalog",
+      "default_character_set_schema",
+      "default_character_set_name",
+      "sql_path"
+    ], [
+      {
+        catalog_name: m,
+        schema_name: "public",
+        schema_owner: q,
+        default_character_set_catalog: null,
+        default_character_set_schema: null,
+        default_character_set_name: null,
+        sql_path: null
+      },
+      {
+        catalog_name: m,
+        schema_name: "information_schema",
+        schema_owner: q,
+        default_character_set_catalog: null,
+        default_character_set_schema: null,
+        default_character_set_name: null,
+        sql_path: null
+      },
+      {
+        catalog_name: m,
+        schema_name: "pg_catalog",
+        schema_owner: q,
+        default_character_set_catalog: null,
+        default_character_set_schema: null,
+        default_character_set_name: null,
+        sql_path: null
+      }
+    ]];
+  }
+  // ==================================================================
+  // information_schema.tables
+  // ==================================================================
+  static _buildTables(e, l) {
+    const o = [
+      "table_catalog",
+      "table_schema",
+      "table_name",
+      "table_type",
+      "self_referencing_column_name",
+      "reference_generation",
+      "user_defined_type_catalog",
+      "user_defined_type_schema",
+      "user_defined_type_name",
+      "is_insertable_into",
+      "is_typed",
+      "commit_action"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tempTables.has(n);
+      t.push({
+        table_catalog: m,
+        table_schema: h,
+        table_name: n,
+        table_type: a ? "LOCAL TEMPORARY" : "BASE TABLE",
+        self_referencing_column_name: null,
+        reference_generation: null,
+        user_defined_type_catalog: null,
+        user_defined_type_schema: null,
+        user_defined_type_name: null,
+        is_insertable_into: "YES",
+        is_typed: "NO",
+        commit_action: null
+      });
+    }
+    for (const n of [...e._views.keys()].sort())
+      t.push({
+        table_catalog: m,
+        table_schema: h,
+        table_name: n,
+        table_type: "VIEW",
+        self_referencing_column_name: null,
+        reference_generation: null,
+        user_defined_type_catalog: null,
+        user_defined_type_schema: null,
+        user_defined_type_name: null,
+        is_insertable_into: "NO",
+        is_typed: "NO",
+        commit_action: null
+      });
+    for (const n of [...e._foreignTables.keys()].sort())
+      t.push({
+        table_catalog: m,
+        table_schema: h,
+        table_name: n,
+        table_type: "FOREIGN",
+        self_referencing_column_name: null,
+        reference_generation: null,
+        user_defined_type_catalog: null,
+        user_defined_type_schema: null,
+        user_defined_type_name: null,
+        is_insertable_into: "NO",
+        is_typed: "NO",
+        commit_action: null
+      });
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.columns
+  // ==================================================================
+  static _buildColumns(e, l) {
+    const o = [
+      "table_catalog",
+      "table_schema",
+      "table_name",
+      "column_name",
+      "ordinal_position",
+      "column_default",
+      "is_nullable",
+      "data_type",
+      "character_maximum_length",
+      "character_octet_length",
+      "numeric_precision",
+      "numeric_precision_radix",
+      "numeric_scale",
+      "datetime_precision",
+      "interval_type",
+      "interval_precision",
+      "character_set_catalog",
+      "character_set_schema",
+      "character_set_name",
+      "collation_catalog",
+      "collation_schema",
+      "collation_name",
+      "domain_catalog",
+      "domain_schema",
+      "domain_name",
+      "udt_catalog",
+      "udt_schema",
+      "udt_name",
+      "scope_catalog",
+      "scope_schema",
+      "scope_name",
+      "maximum_cardinality",
+      "dtd_identifier",
+      "is_self_referencing",
+      "is_identity",
+      "identity_generation",
+      "identity_start",
+      "identity_increment",
+      "identity_maximum",
+      "identity_minimum",
+      "identity_cycle",
+      "is_generated",
+      "generation_expression",
+      "is_updatable"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n);
+      let s = 0;
+      for (const [i, r] of a.columns) {
+        s++;
+        const c = oe(r), _ = Y(c), d = se(c);
+        let v = null;
+        r.autoIncrement ? v = `nextval('${n}_${i}_seq'::regclass)` : r.defaultValue !== null && r.defaultValue !== void 0 && (v = ve(r.defaultValue));
+        const p = r.autoIncrement ? "YES" : "NO", f = r.autoIncrement ? "BY DEFAULT" : null;
+        let b = null;
+        [
+          "timestamp",
+          "timestamptz",
+          "timestamp without time zone",
+          "timestamp with time zone",
+          "date",
+          "time"
+        ].includes(c) && (b = 6), t.push({
+          table_catalog: m,
+          table_schema: h,
+          table_name: n,
+          column_name: i,
+          ordinal_position: s,
+          column_default: v,
+          is_nullable: r.notNull ? "NO" : "YES",
+          data_type: _,
+          character_maximum_length: be(),
+          character_octet_length: ye(c),
+          numeric_precision: r.numericPrecision !== null ? r.numericPrecision : L(c),
+          numeric_precision_radix: B(c),
+          numeric_scale: r.numericScale !== null ? r.numericScale : W(c),
+          datetime_precision: b,
+          interval_type: null,
+          interval_precision: null,
+          character_set_catalog: null,
+          character_set_schema: null,
+          character_set_name: null,
+          collation_catalog: null,
+          collation_schema: null,
+          collation_name: null,
+          domain_catalog: null,
+          domain_schema: null,
+          domain_name: null,
+          udt_catalog: m,
+          udt_schema: "pg_catalog",
+          udt_name: d,
+          scope_catalog: null,
+          scope_schema: null,
+          scope_name: null,
+          maximum_cardinality: null,
+          dtd_identifier: String(s),
+          is_self_referencing: "NO",
+          is_identity: p,
+          identity_generation: f,
+          identity_start: r.autoIncrement ? "1" : null,
+          identity_increment: r.autoIncrement ? "1" : null,
+          identity_maximum: null,
+          identity_minimum: null,
+          identity_cycle: r.autoIncrement ? "NO" : null,
+          is_generated: "NEVER",
+          generation_expression: null,
+          is_updatable: "YES"
+        });
+      }
+    }
+    for (const n of [...e._foreignTables.keys()].sort()) {
+      const a = e._foreignTables.get(n);
+      let s = 0;
+      for (const [i, r] of a.columns) {
+        s++;
+        const c = oe(r), _ = Y(c), d = se(c);
+        t.push({
+          table_catalog: m,
+          table_schema: h,
+          table_name: n,
+          column_name: i,
+          ordinal_position: s,
+          column_default: null,
+          is_nullable: "YES",
+          data_type: _,
+          character_maximum_length: null,
+          character_octet_length: null,
+          numeric_precision: L(c),
+          numeric_precision_radix: B(c),
+          numeric_scale: W(c),
+          datetime_precision: null,
+          interval_type: null,
+          interval_precision: null,
+          character_set_catalog: null,
+          character_set_schema: null,
+          character_set_name: null,
+          collation_catalog: null,
+          collation_schema: null,
+          collation_name: null,
+          domain_catalog: null,
+          domain_schema: null,
+          domain_name: null,
+          udt_catalog: m,
+          udt_schema: "pg_catalog",
+          udt_name: d,
+          scope_catalog: null,
+          scope_schema: null,
+          scope_name: null,
+          maximum_cardinality: null,
+          dtd_identifier: String(s),
+          is_self_referencing: "NO",
+          is_identity: "NO",
+          identity_generation: null,
+          identity_start: null,
+          identity_increment: null,
+          identity_maximum: null,
+          identity_minimum: null,
+          identity_cycle: null,
+          is_generated: "NEVER",
+          generation_expression: null,
+          is_updatable: "NO"
+        });
+      }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.table_constraints
+  // ==================================================================
+  static _buildTableConstraints(e, l) {
+    const o = [
+      "constraint_catalog",
+      "constraint_schema",
+      "constraint_name",
+      "table_catalog",
+      "table_schema",
+      "table_name",
+      "constraint_type",
+      "is_deferrable",
+      "initially_deferred",
+      "enforced",
+      "nulls_distinct"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n);
+      a.primaryKey && t.push({
+        constraint_catalog: m,
+        constraint_schema: h,
+        constraint_name: `${n}_pkey`,
+        table_catalog: m,
+        table_schema: h,
+        table_name: n,
+        constraint_type: "PRIMARY KEY",
+        is_deferrable: "NO",
+        initially_deferred: "NO",
+        enforced: "YES",
+        nulls_distinct: null
+      });
+      for (const [s, i] of a.columns)
+        i.unique && !i.primaryKey && t.push({
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s}_key`,
+          table_catalog: m,
+          table_schema: h,
+          table_name: n,
+          constraint_type: "UNIQUE",
+          is_deferrable: "NO",
+          initially_deferred: "NO",
+          enforced: "YES",
+          nulls_distinct: "YES"
+        });
+      for (const s of a.foreignKeys)
+        t.push({
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s.column}_fkey`,
+          table_catalog: m,
+          table_schema: h,
+          table_name: n,
+          constraint_type: "FOREIGN KEY",
+          is_deferrable: "NO",
+          initially_deferred: "NO",
+          enforced: "YES",
+          nulls_distinct: null
+        });
+      for (const [s] of a.checkConstraints)
+        t.push({
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s}_check`,
+          table_catalog: m,
+          table_schema: h,
+          table_name: n,
+          constraint_type: "CHECK",
+          is_deferrable: "NO",
+          initially_deferred: "NO",
+          enforced: "YES",
+          nulls_distinct: null
+        });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.key_column_usage
+  // ==================================================================
+  static _buildKeyColumnUsage(e, l) {
+    const o = [
+      "constraint_catalog",
+      "constraint_schema",
+      "constraint_name",
+      "table_catalog",
+      "table_schema",
+      "table_name",
+      "column_name",
+      "ordinal_position",
+      "position_in_unique_constraint"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n);
+      a.primaryKey && t.push({
+        constraint_catalog: m,
+        constraint_schema: h,
+        constraint_name: `${n}_pkey`,
+        table_catalog: m,
+        table_schema: h,
+        table_name: n,
+        column_name: a.primaryKey,
+        ordinal_position: 1,
+        position_in_unique_constraint: null
+      });
+      for (const [s, i] of a.columns)
+        i.unique && !i.primaryKey && t.push({
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s}_key`,
+          table_catalog: m,
+          table_schema: h,
+          table_name: n,
+          column_name: s,
+          ordinal_position: 1,
+          position_in_unique_constraint: null
+        });
+      for (const s of a.foreignKeys) {
+        const i = e._tables.get(s.refTable);
+        let r = null;
+        i !== void 0 && [...i.columns.keys()].includes(s.refColumn) && (r = 1), t.push({
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s.column}_fkey`,
+          table_catalog: m,
+          table_schema: h,
+          table_name: n,
+          column_name: s.column,
+          ordinal_position: 1,
+          position_in_unique_constraint: r
+        });
+      }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.referential_constraints
+  // ==================================================================
+  static _buildReferentialConstraints(e, l) {
+    const o = [
+      "constraint_catalog",
+      "constraint_schema",
+      "constraint_name",
+      "unique_constraint_catalog",
+      "unique_constraint_schema",
+      "unique_constraint_name",
+      "match_option",
+      "update_rule",
+      "delete_rule"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n);
+      for (const s of a.foreignKeys) {
+        const i = e._tables.get(s.refTable);
+        let r = null;
+        i !== void 0 && (i.primaryKey === s.refColumn ? r = `${s.refTable}_pkey` : r = `${s.refTable}_${s.refColumn}_key`), t.push({
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s.column}_fkey`,
+          unique_constraint_catalog: m,
+          unique_constraint_schema: h,
+          unique_constraint_name: r,
+          match_option: "NONE",
+          update_rule: "NO ACTION",
+          delete_rule: "NO ACTION"
+        });
+      }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.constraint_column_usage
+  // ==================================================================
+  static _buildConstraintColumnUsage(e, l) {
+    const o = [
+      "table_catalog",
+      "table_schema",
+      "table_name",
+      "column_name",
+      "constraint_catalog",
+      "constraint_schema",
+      "constraint_name"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n);
+      a.primaryKey && t.push({
+        table_catalog: m,
+        table_schema: h,
+        table_name: n,
+        column_name: a.primaryKey,
+        constraint_catalog: m,
+        constraint_schema: h,
+        constraint_name: `${n}_pkey`
+      });
+      for (const [s, i] of a.columns)
+        i.unique && !i.primaryKey && t.push({
+          table_catalog: m,
+          table_schema: h,
+          table_name: n,
+          column_name: s,
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s}_key`
+        });
+      for (const s of a.foreignKeys)
+        t.push({
+          table_catalog: m,
+          table_schema: h,
+          table_name: s.refTable,
+          column_name: s.refColumn,
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s.column}_fkey`
+        });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.check_constraints
+  // ==================================================================
+  static _buildCheckConstraints(e, l) {
+    const o = [
+      "constraint_catalog",
+      "constraint_schema",
+      "constraint_name",
+      "check_clause"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n);
+      for (const [s, i] of a.columns)
+        i.notNull && !i.primaryKey && t.push({
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s}_not_null`,
+          check_clause: `${s} IS NOT NULL`
+        });
+      for (const [s] of a.checkConstraints)
+        t.push({
+          constraint_catalog: m,
+          constraint_schema: h,
+          constraint_name: `${n}_${s}_check`,
+          check_clause: s
+        });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.views
+  // ==================================================================
+  static _buildViews(e, l) {
+    const o = [
+      "table_catalog",
+      "table_schema",
+      "table_name",
+      "view_definition",
+      "check_option",
+      "is_updatable",
+      "is_insertable_into",
+      "is_trigger_updatable",
+      "is_trigger_deletable",
+      "is_trigger_insertable_into"
+    ], t = [];
+    for (const n of [...e._views.keys()].sort())
+      t.push({
+        table_catalog: m,
+        table_schema: h,
+        table_name: n,
+        view_definition: "",
+        check_option: "NONE",
+        is_updatable: "NO",
+        is_insertable_into: "NO",
+        is_trigger_updatable: "NO",
+        is_trigger_deletable: "NO",
+        is_trigger_insertable_into: "NO"
+      });
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.sequences
+  // ==================================================================
+  static _buildSequences(e, l) {
+    const o = [
+      "sequence_catalog",
+      "sequence_schema",
+      "sequence_name",
+      "data_type",
+      "numeric_precision",
+      "numeric_precision_radix",
+      "numeric_scale",
+      "start_value",
+      "minimum_value",
+      "maximum_value",
+      "increment",
+      "cycle_option"
+    ], t = [];
+    for (const n of [...e._sequences.keys()].sort()) {
+      const a = e._sequences.get(n);
+      t.push({
+        sequence_catalog: m,
+        sequence_schema: h,
+        sequence_name: n,
+        data_type: "bigint",
+        numeric_precision: 64,
+        numeric_precision_radix: 2,
+        numeric_scale: 0,
+        start_value: String(a.start ?? 1),
+        minimum_value: "1",
+        maximum_value: "9223372036854775807",
+        increment: String(a.increment ?? 1),
+        cycle_option: "NO"
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.routines (empty)
+  // ==================================================================
+  static _buildRoutines(e, l) {
+    return [[
+      "specific_catalog",
+      "specific_schema",
+      "specific_name",
+      "routine_catalog",
+      "routine_schema",
+      "routine_name",
+      "routine_type",
+      "data_type",
+      "type_udt_catalog",
+      "type_udt_schema",
+      "type_udt_name",
+      "routine_definition",
+      "external_language",
+      "is_deterministic",
+      "security_type"
+    ], []];
+  }
+  // ==================================================================
+  // information_schema.parameters (empty)
+  // ==================================================================
+  static _buildParameters(e, l) {
+    return [[
+      "specific_catalog",
+      "specific_schema",
+      "specific_name",
+      "ordinal_position",
+      "parameter_mode",
+      "is_result",
+      "as_locator",
+      "parameter_name",
+      "data_type",
+      "parameter_default"
+    ], []];
+  }
+  // ==================================================================
+  // information_schema.foreign_tables
+  // ==================================================================
+  static _buildForeignTables(e, l) {
+    const o = [
+      "foreign_table_catalog",
+      "foreign_table_schema",
+      "foreign_table_name",
+      "foreign_server_catalog",
+      "foreign_server_name"
+    ], t = [];
+    for (const n of [...e._foreignTables.keys()].sort()) {
+      const a = e._foreignTables.get(n);
+      t.push({
+        foreign_table_catalog: m,
+        foreign_table_schema: h,
+        foreign_table_name: n,
+        foreign_server_catalog: m,
+        foreign_server_name: a.serverName
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.foreign_servers
+  // ==================================================================
+  static _buildForeignServers(e, l) {
+    const o = [
+      "foreign_server_catalog",
+      "foreign_server_name",
+      "foreign_data_wrapper_catalog",
+      "foreign_data_wrapper_name",
+      "foreign_server_type",
+      "foreign_server_version",
+      "authorization_identifier"
+    ], t = [];
+    for (const n of [...e._foreignServers.keys()].sort()) {
+      const a = e._foreignServers.get(n);
+      t.push({
+        foreign_server_catalog: m,
+        foreign_server_name: n,
+        foreign_data_wrapper_catalog: m,
+        foreign_data_wrapper_name: a.fdwType,
+        foreign_server_type: null,
+        foreign_server_version: null,
+        authorization_identifier: q
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.foreign_server_options
+  // ==================================================================
+  static _buildForeignServerOptions(e, l) {
+    const o = [
+      "foreign_server_catalog",
+      "foreign_server_name",
+      "option_name",
+      "option_value"
+    ], t = [];
+    for (const n of [...e._foreignServers.keys()].sort()) {
+      const a = e._foreignServers.get(n);
+      for (const s of Object.keys(a.options).sort())
+        t.push({
+          foreign_server_catalog: m,
+          foreign_server_name: n,
+          option_name: s,
+          option_value: a.options[s]
+        });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.foreign_table_options
+  // ==================================================================
+  static _buildForeignTableOptions(e, l) {
+    const o = [
+      "foreign_table_catalog",
+      "foreign_table_schema",
+      "foreign_table_name",
+      "option_name",
+      "option_value"
+    ], t = [];
+    for (const n of [...e._foreignTables.keys()].sort()) {
+      const a = e._foreignTables.get(n);
+      for (const s of Object.keys(a.options).sort())
+        t.push({
+          foreign_table_catalog: m,
+          foreign_table_schema: h,
+          foreign_table_name: n,
+          option_name: s,
+          option_value: a.options[s]
+        });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.enabled_roles
+  // ==================================================================
+  static _buildEnabledRoles(e, l) {
+    return [["role_name"], [{ role_name: q }]];
+  }
+  // ==================================================================
+  // information_schema.applicable_roles
+  // ==================================================================
+  static _buildApplicableRoles(e, l) {
+    return [
+      ["grantee", "role_name", "is_grantable"],
+      [{ grantee: q, role_name: q, is_grantable: "YES" }]
+    ];
+  }
+  // ==================================================================
+  // information_schema.character_sets
+  // ==================================================================
+  static _buildCharacterSets(e, l) {
+    return [
+      [
+        "character_set_catalog",
+        "character_set_schema",
+        "character_set_name",
+        "character_repertoire",
+        "form_of_use",
+        "default_collate_catalog",
+        "default_collate_schema",
+        "default_collate_name"
+      ],
+      [
+        {
+          character_set_catalog: null,
+          character_set_schema: null,
+          character_set_name: "UTF8",
+          character_repertoire: "UCS",
+          form_of_use: "UTF8",
+          default_collate_catalog: m,
+          default_collate_schema: "pg_catalog",
+          default_collate_name: "en_US.utf8"
+        }
+      ]
+    ];
+  }
+  // ==================================================================
+  // information_schema.collations
+  // ==================================================================
+  static _buildCollations(e, l) {
+    return [
+      [
+        "collation_catalog",
+        "collation_schema",
+        "collation_name",
+        "pad_attribute"
+      ],
+      [
+        {
+          collation_catalog: m,
+          collation_schema: "pg_catalog",
+          collation_name: "en_US.utf8",
+          pad_attribute: "NO PAD"
+        }
+      ]
+    ];
+  }
+  // ==================================================================
+  // information_schema.domains (empty)
+  // ==================================================================
+  static _buildDomains(e, l) {
+    return [[
+      "domain_catalog",
+      "domain_schema",
+      "domain_name",
+      "data_type",
+      "character_maximum_length",
+      "numeric_precision",
+      "domain_default"
+    ], []];
+  }
+  // ==================================================================
+  // information_schema.element_types
+  // ==================================================================
+  static _buildElementTypes(e, l) {
+    const o = [
+      "object_catalog",
+      "object_schema",
+      "object_name",
+      "object_type",
+      "collection_type_identifier",
+      "data_type",
+      "character_maximum_length",
+      "numeric_precision",
+      "numeric_precision_radix",
+      "numeric_scale",
+      "dtd_identifier"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n);
+      let s = 0;
+      for (const [, i] of a.columns)
+        if (s++, i.typeName.endsWith("[]")) {
+          const r = i.typeName.slice(0, -2), c = Y(r);
+          t.push({
+            object_catalog: m,
+            object_schema: h,
+            object_name: n,
+            object_type: "TABLE",
+            collection_type_identifier: String(s),
+            data_type: c,
+            character_maximum_length: null,
+            numeric_precision: L(r),
+            numeric_precision_radix: B(r),
+            numeric_scale: W(r),
+            dtd_identifier: String(s)
+          });
+        }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // information_schema.triggers (empty)
+  // ==================================================================
+  static _buildTriggers(e, l) {
+    return [[
+      "trigger_catalog",
+      "trigger_schema",
+      "trigger_name",
+      "event_manipulation",
+      "event_object_catalog",
+      "event_object_schema",
+      "event_object_table",
+      "action_order",
+      "action_condition",
+      "action_statement",
+      "action_orientation",
+      "action_timing"
+    ], []];
+  }
+};
+A(k, "_VIEWS", {
+  schemata: k._buildSchemata,
+  tables: k._buildTables,
+  columns: k._buildColumns,
+  table_constraints: k._buildTableConstraints,
+  key_column_usage: k._buildKeyColumnUsage,
+  referential_constraints: k._buildReferentialConstraints,
+  constraint_column_usage: k._buildConstraintColumnUsage,
+  check_constraints: k._buildCheckConstraints,
+  views: k._buildViews,
+  sequences: k._buildSequences,
+  routines: k._buildRoutines,
+  parameters: k._buildParameters,
+  foreign_tables: k._buildForeignTables,
+  foreign_servers: k._buildForeignServers,
+  foreign_server_options: k._buildForeignServerOptions,
+  foreign_table_options: k._buildForeignTableOptions,
+  enabled_roles: k._buildEnabledRoles,
+  applicable_roles: k._buildApplicableRoles,
+  character_sets: k._buildCharacterSets,
+  collations: k._buildCollations,
+  domains: k._buildDomains,
+  element_types: k._buildElementTypes,
+  triggers: k._buildTriggers
+});
+let D = k;
+const we = /* @__PURE__ */ new Map();
+function xe() {
+  return Array.from(we.values());
+}
+function ie(u) {
+  return u.typeName === "float" && u.numericScale !== null ? "numeric" : u.typeName;
+}
+const G = "uqa", N = "public", $ = "uqa", ke = 6, E = J.pg_catalog, U = J.public, Se = J.information_schema;
+function P(u) {
+  const e = u.reltuples ?? -1;
+  return {
+    oid: u.oid,
+    relname: u.relname,
+    relnamespace: u.relnamespace,
+    reltype: u.reltype ?? 0,
+    reloftype: u.reloftype ?? 0,
+    relowner: u.relowner ?? T,
+    relam: u.relam ?? 0,
+    relfilenode: u.oid,
+    reltablespace: 0,
+    relpages: e > 0 ? Math.max(1, Math.floor(e / 100)) : 0,
+    reltuples: e,
+    relallvisible: 0,
+    reltoastrelid: 0,
+    relhasindex: u.relhasindex ?? !1,
+    relisshared: !1,
+    relpersistence: "p",
+    relkind: u.relkind ?? "r",
+    relnatts: u.relnatts ?? 0,
+    relchecks: u.relchecks ?? 0,
+    relhasrules: u.relhasrules ?? !1,
+    relhastriggers: !1,
+    relhassubclass: !1,
+    relrowsecurity: !1,
+    relforcerowsecurity: !1,
+    relispopulated: !0,
+    relreplident: "d",
+    relispartition: !1,
+    relrewrite: 0,
+    relfrozenxid: 0,
+    relminmxid: 1,
+    relacl: null,
+    reloptions: null,
+    relpartbound: null
+  };
+}
+function H(u) {
+  const e = u._indexManager;
+  if (e == null) return null;
+  const l = e._indexes;
+  return l === void 0 ? null : l;
+}
+const g = class g {
+  static supportedTables() {
+    return Object.keys(g._TABLES);
+  }
+  static build(e, l, o) {
+    const t = g._TABLES[e];
+    if (t === void 0)
+      throw new Error(`Unknown pg_catalog table: '${e}'`);
+    return t(l, o);
+  }
+  // ==================================================================
+  // pg_namespace -- schemas
+  // ==================================================================
+  static _buildPgNamespace(e, l) {
+    return [["oid", "nspname", "nspowner", "nspacl"], [
+      {
+        oid: E,
+        nspname: "pg_catalog",
+        nspowner: T,
+        nspacl: null
+      },
+      {
+        oid: U,
+        nspname: "public",
+        nspowner: T,
+        nspacl: null
+      },
+      {
+        oid: Se,
+        nspname: "information_schema",
+        nspowner: T,
+        nspacl: null
+      }
+    ]];
+  }
+  // ==================================================================
+  // pg_class -- all relations (tables, views, indexes, sequences, etc.)
+  // ==================================================================
+  static _buildPgClass(e, l) {
+    const o = [
+      "oid",
+      "relname",
+      "relnamespace",
+      "reltype",
+      "reloftype",
+      "relowner",
+      "relam",
+      "relfilenode",
+      "reltablespace",
+      "relpages",
+      "reltuples",
+      "relallvisible",
+      "reltoastrelid",
+      "relhasindex",
+      "relisshared",
+      "relpersistence",
+      "relkind",
+      "relnatts",
+      "relchecks",
+      "relhasrules",
+      "relhastriggers",
+      "relhassubclass",
+      "relrowsecurity",
+      "relforcerowsecurity",
+      "relispopulated",
+      "relreplident",
+      "relispartition",
+      "relrewrite",
+      "relfrozenxid",
+      "relminmxid",
+      "relacl",
+      "reloptions",
+      "relpartbound"
+    ], t = [], n = U;
+    for (const s of [...e._tables.keys()].sort()) {
+      const i = e._tables.get(s), r = l.get("table", s) ?? 0, c = l.get("table_type", s) ?? 0, _ = i.primaryKey !== null || [...i.columns.values()].some((p) => p.unique), d = i.checkConstraints.length, v = i.rowCount;
+      t.push(
+        P({
+          oid: r,
+          relname: s,
+          relnamespace: n,
+          reltype: c,
+          relam: te,
+          reltuples: v,
+          relhasindex: _,
+          relkind: "r",
+          relnatts: i.columns.size,
+          relchecks: d
+        })
+      );
+    }
+    for (const s of [...e._views.keys()].sort()) {
+      const i = l.get("view", s) ?? 0;
+      t.push(
+        P({
+          oid: i,
+          relname: s,
+          relnamespace: n,
+          relkind: "v",
+          relhasrules: !0
+        })
+      );
+    }
+    for (const s of [...e._sequences.keys()].sort()) {
+      const i = l.get("sequence", s) ?? 0;
+      t.push(
+        P({
+          oid: i,
+          relname: s,
+          relnamespace: n,
+          relkind: "S",
+          relnatts: 3
+        })
+      );
+    }
+    for (const s of [...e._foreignTables.keys()].sort()) {
+      const i = l.get("foreign_table", s) ?? 0, r = e._foreignTables.get(s);
+      t.push(
+        P({
+          oid: i,
+          relname: s,
+          relnamespace: n,
+          relkind: "f",
+          relnatts: r.columns.size
+        })
+      );
+    }
+    const a = H(e);
+    if (a !== null)
+      for (const s of [...a.keys()].sort()) {
+        const i = a.get(s), r = l.get("index", s) ?? 0, c = i.indexDef;
+        t.push(
+          P({
+            oid: r,
+            relname: s,
+            relnamespace: n,
+            relam: z,
+            relkind: "i",
+            relnatts: c.columns.length
+          })
+        );
+      }
+    for (const s of [...e._tables.keys()].sort()) {
+      const i = e._tables.get(s);
+      if (i.primaryKey) {
+        const r = `${s}_pkey`, c = l.get("index", r) ?? 0;
+        t.push(
+          P({
+            oid: c,
+            relname: r,
+            relnamespace: n,
+            relam: z,
+            relkind: "i",
+            relnatts: 1
+          })
+        );
+      }
+      for (const [r, c] of i.columns)
+        if (c.unique && !c.primaryKey) {
+          const _ = `${s}_${r}_key`, d = l.get("index", _) ?? 0;
+          t.push(
+            P({
+              oid: d,
+              relname: _,
+              relnamespace: n,
+              relam: z,
+              relkind: "i",
+              relnatts: 1
+            })
+          );
+        }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_attribute -- columns of all relations
+  // ==================================================================
+  static _buildPgAttribute(e, l) {
+    const o = [
+      "attrelid",
+      "attname",
+      "atttypid",
+      "attstattarget",
+      "attlen",
+      "attnum",
+      "attndims",
+      "attcacheoff",
+      "atttypmod",
+      "attbyval",
+      "attalign",
+      "attstorage",
+      "attcompression",
+      "attnotnull",
+      "atthasdef",
+      "atthasmissing",
+      "attidentity",
+      "attgenerated",
+      "attisdropped",
+      "attislocal",
+      "attinhcount",
+      "attcollation",
+      "attacl",
+      "attoptions",
+      "attfdwoptions",
+      "attmissingval"
+    ], t = [], n = [
+      ["tableoid", 26, 4, -6],
+      ["cmax", 29, 4, -5],
+      ["xmax", 28, 4, -4],
+      ["cmin", 29, 4, -3],
+      ["xmin", 28, 4, -2],
+      ["ctid", 27, 6, -1]
+    ];
+    for (const a of [...e._tables.keys()].sort()) {
+      const s = e._tables.get(a), i = l.get("table", a) ?? 0;
+      let r = 0;
+      for (const [c, _] of s.columns) {
+        r++;
+        const d = I(ie(_)), v = ae[d] ?? -1, p = le[d] ?? !1, f = K[d] ?? "i", b = V[d] ?? "p", x = _.typeName.endsWith("[]") ? 1 : 0, y = _.defaultValue !== null && _.defaultValue !== void 0 || _.autoIncrement, S = _.autoIncrement ? "d" : "", w = d === 25 || d === 1042 || d === 1043 ? 100 : 0;
+        t.push({
+          attrelid: i,
+          attname: c,
+          atttypid: d,
+          attstattarget: -1,
+          attlen: v,
+          attnum: r,
+          attndims: x,
+          attcacheoff: -1,
+          atttypmod: -1,
+          attbyval: p,
+          attalign: f,
+          attstorage: b,
+          attcompression: "",
+          attnotnull: _.notNull || _.primaryKey,
+          atthasdef: y,
+          atthasmissing: !1,
+          attidentity: S,
+          attgenerated: "",
+          attisdropped: !1,
+          attislocal: !0,
+          attinhcount: 0,
+          attcollation: w,
+          attacl: null,
+          attoptions: null,
+          attfdwoptions: null,
+          attmissingval: null
+        });
+      }
+      for (const [c, _, d, v] of n)
+        t.push({
+          attrelid: i,
+          attname: c,
+          atttypid: _,
+          attstattarget: 0,
+          attlen: d,
+          attnum: v,
+          attndims: 0,
+          attcacheoff: -1,
+          atttypmod: -1,
+          attbyval: !0,
+          attalign: d === 4 ? "i" : "s",
+          attstorage: "p",
+          attcompression: "",
+          attnotnull: !0,
+          atthasdef: !1,
+          atthasmissing: !1,
+          attidentity: "",
+          attgenerated: "",
+          attisdropped: !1,
+          attislocal: !0,
+          attinhcount: 0,
+          attcollation: 0,
+          attacl: null,
+          attoptions: null,
+          attfdwoptions: null,
+          attmissingval: null
+        });
+    }
+    for (const a of [...e._foreignTables.keys()].sort()) {
+      const s = e._foreignTables.get(a), i = l.get("foreign_table", a) ?? 0;
+      let r = 0;
+      for (const [c, _] of s.columns) {
+        r++;
+        const d = I(ie(_)), v = ae[d] ?? -1;
+        t.push({
+          attrelid: i,
+          attname: c,
+          atttypid: d,
+          attstattarget: -1,
+          attlen: v,
+          attnum: r,
+          attndims: 0,
+          attcacheoff: -1,
+          atttypmod: -1,
+          attbyval: le[d] ?? !1,
+          attalign: K[d] ?? "i",
+          attstorage: V[d] ?? "p",
+          attcompression: "",
+          attnotnull: !1,
+          atthasdef: !1,
+          atthasmissing: !1,
+          attidentity: "",
+          attgenerated: "",
+          attisdropped: !1,
+          attislocal: !0,
+          attinhcount: 0,
+          attcollation: d === 25 || d === 1042 || d === 1043 ? 100 : 0,
+          attacl: null,
+          attoptions: null,
+          attfdwoptions: null,
+          attmissingval: null
+        });
+      }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_type -- data types
+  // ==================================================================
+  static _buildPgType(e, l) {
+    const o = [
+      "oid",
+      "typname",
+      "typnamespace",
+      "typowner",
+      "typlen",
+      "typbyval",
+      "typtype",
+      "typcategory",
+      "typispreferred",
+      "typisdefined",
+      "typdelim",
+      "typrelid",
+      "typsubscript",
+      "typelem",
+      "typarray",
+      "typinput",
+      "typoutput",
+      "typreceive",
+      "typsend",
+      "typmodin",
+      "typmodout",
+      "typanalyze",
+      "typalign",
+      "typstorage",
+      "typnotnull",
+      "typbasetype",
+      "typtypmod",
+      "typndims",
+      "typcollation",
+      "typdefaultbin",
+      "typdefault",
+      "typacl"
+    ], t = E, n = [], a = [
+      [16, "bool", 1, !0, "B", !0],
+      [17, "bytea", -1, !1, "U", !1],
+      [18, "char", 1, !0, "Z", !1],
+      [19, "name", 64, !1, "S", !1],
+      [20, "int8", 8, !0, "N", !1],
+      [21, "int2", 2, !0, "N", !1],
+      [23, "int4", 4, !0, "N", !1],
+      [25, "text", -1, !1, "S", !0],
+      [26, "oid", 4, !0, "N", !1],
+      [27, "tid", 6, !1, "U", !1],
+      [28, "xid", 4, !0, "U", !1],
+      [29, "cid", 4, !0, "U", !1],
+      [114, "json", -1, !1, "U", !1],
+      [142, "xml", -1, !1, "U", !1],
+      [600, "point", 16, !1, "G", !1],
+      [700, "float4", 4, !0, "N", !1],
+      [701, "float8", 8, !0, "N", !0],
+      [1042, "bpchar", -1, !1, "S", !1],
+      [1043, "varchar", -1, !1, "S", !1],
+      [1082, "date", 4, !0, "D", !1],
+      [1083, "time", 8, !0, "D", !1],
+      [1114, "timestamp", 8, !0, "D", !1],
+      [1184, "timestamptz", 8, !0, "D", !0],
+      [1186, "interval", 16, !1, "T", !0],
+      [1700, "numeric", -1, !1, "N", !1],
+      [2205, "regclass", 4, !0, "N", !1],
+      [2249, "record", -1, !1, "P", !1],
+      [2278, "void", 4, !0, "P", !1],
+      [2950, "uuid", 16, !1, "U", !1],
+      [3802, "jsonb", -1, !1, "U", !1],
+      [16385, "vector", -1, !1, "U", !1]
+    ];
+    for (const [i, r, c, _, d, v] of a) {
+      const p = Z[i] ?? 0, f = K[i] ?? "i", b = V[i] ?? "p", x = d === "S" ? 100 : 0;
+      n.push({
+        oid: i,
+        typname: r,
+        typnamespace: t,
+        typowner: T,
+        typlen: c,
+        typbyval: _,
+        typtype: "b",
+        typcategory: d,
+        typispreferred: v,
+        typisdefined: !0,
+        typdelim: ",",
+        typrelid: 0,
+        typsubscript: "",
+        typelem: 0,
+        typarray: p,
+        typinput: `${r}in`,
+        typoutput: `${r}out`,
+        typreceive: `${r}recv`,
+        typsend: `${r}send`,
+        typmodin: "",
+        typmodout: "",
+        typanalyze: "",
+        typalign: f,
+        typstorage: b,
+        typnotnull: !1,
+        typbasetype: 0,
+        typtypmod: -1,
+        typndims: 0,
+        typcollation: x,
+        typdefaultbin: null,
+        typdefault: null,
+        typacl: null
+      });
+    }
+    const s = Object.entries(Z).map(([i, r]) => [Number(i), r]).sort((i, r) => i[0] - r[0]);
+    for (const [i, r] of s) {
+      let c = "";
+      for (const [_, d] of a)
+        if (_ === i) {
+          c = d;
+          break;
+        }
+      c && n.push({
+        oid: r,
+        typname: `_${c}`,
+        typnamespace: t,
+        typowner: T,
+        typlen: -1,
+        typbyval: !1,
+        typtype: "b",
+        typcategory: "A",
+        typispreferred: !1,
+        typisdefined: !0,
+        typdelim: ",",
+        typrelid: 0,
+        typsubscript: "array_subscript_handler",
+        typelem: i,
+        typarray: 0,
+        typinput: "array_in",
+        typoutput: "array_out",
+        typreceive: "array_recv",
+        typsend: "array_send",
+        typmodin: "",
+        typmodout: "",
+        typanalyze: "",
+        typalign: "i",
+        typstorage: "x",
+        typnotnull: !1,
+        typbasetype: 0,
+        typtypmod: -1,
+        typndims: 0,
+        typcollation: 0,
+        typdefaultbin: null,
+        typdefault: null,
+        typacl: null
+      });
+    }
+    for (const i of [...e._tables.keys()].sort()) {
+      const r = l.get("table_type", i) ?? 0, c = l.get("table", i) ?? 0;
+      n.push({
+        oid: r,
+        typname: i,
+        typnamespace: U,
+        typowner: T,
+        typlen: -1,
+        typbyval: !1,
+        typtype: "c",
+        typcategory: "C",
+        typispreferred: !1,
+        typisdefined: !0,
+        typdelim: ",",
+        typrelid: c,
+        typsubscript: "",
+        typelem: 0,
+        typarray: 0,
+        typinput: "record_in",
+        typoutput: "record_out",
+        typreceive: "record_recv",
+        typsend: "record_send",
+        typmodin: "",
+        typmodout: "",
+        typanalyze: "",
+        typalign: "d",
+        typstorage: "x",
+        typnotnull: !1,
+        typbasetype: 0,
+        typtypmod: -1,
+        typndims: 0,
+        typcollation: 0,
+        typdefaultbin: null,
+        typdefault: null,
+        typacl: null
+      });
+    }
+    return [o, n];
+  }
+  // ==================================================================
+  // pg_constraint
+  // ==================================================================
+  static _buildPgConstraint(e, l) {
+    const o = [
+      "oid",
+      "conname",
+      "connamespace",
+      "contype",
+      "condeferrable",
+      "condeferred",
+      "convalidated",
+      "conrelid",
+      "contypid",
+      "conindid",
+      "conparentid",
+      "confrelid",
+      "confupdtype",
+      "confdeltype",
+      "confmatchtype",
+      "conislocal",
+      "coninhcount",
+      "connoinherit",
+      "conkey",
+      "confkey",
+      "conpfeqop",
+      "conppeqop",
+      "conffeqop",
+      "conexclop",
+      "conbin"
+    ], t = [], n = U;
+    for (const a of [...e._tables.keys()].sort()) {
+      const s = e._tables.get(a), i = l.get("table", a) ?? 0, r = /* @__PURE__ */ new Map();
+      let c = 0;
+      for (const _ of s.columns.keys())
+        c++, r.set(_, c);
+      if (s.primaryKey) {
+        const _ = `${a}_pkey`, d = l.get("constraint", _) ?? 0, v = l.get("index", _) ?? 0, p = r.get(s.primaryKey) ?? 1;
+        t.push({
+          oid: d,
+          conname: _,
+          connamespace: n,
+          contype: "p",
+          condeferrable: !1,
+          condeferred: !1,
+          convalidated: !0,
+          conrelid: i,
+          contypid: 0,
+          conindid: v,
+          conparentid: 0,
+          confrelid: 0,
+          confupdtype: " ",
+          confdeltype: " ",
+          confmatchtype: " ",
+          conislocal: !0,
+          coninhcount: 0,
+          connoinherit: !0,
+          conkey: `{${p}}`,
+          confkey: null,
+          conpfeqop: null,
+          conppeqop: null,
+          conffeqop: null,
+          conexclop: null,
+          conbin: null
+        });
+      }
+      for (const [_, d] of s.columns)
+        if (d.unique && !d.primaryKey) {
+          const v = `${a}_${_}_key`, p = l.get("constraint", v) ?? 0, f = l.get("index", v) ?? 0, b = r.get(_) ?? 1;
+          t.push({
+            oid: p,
+            conname: v,
+            connamespace: n,
+            contype: "u",
+            condeferrable: !1,
+            condeferred: !1,
+            convalidated: !0,
+            conrelid: i,
+            contypid: 0,
+            conindid: f,
+            conparentid: 0,
+            confrelid: 0,
+            confupdtype: " ",
+            confdeltype: " ",
+            confmatchtype: " ",
+            conislocal: !0,
+            coninhcount: 0,
+            connoinherit: !0,
+            conkey: `{${b}}`,
+            confkey: null,
+            conpfeqop: null,
+            conppeqop: null,
+            conffeqop: null,
+            conexclop: null,
+            conbin: null
+          });
+        }
+      for (const _ of s.foreignKeys) {
+        const d = `${a}_${_.column}_fkey`, v = l.get("constraint", d) ?? 0, p = r.get(_.column) ?? 1, f = l.get("table", _.refTable) ?? 0, b = e._tables.get(_.refTable);
+        let x = 1;
+        if (b !== void 0) {
+          const y = /* @__PURE__ */ new Map();
+          let S = 0;
+          for (const w of b.columns.keys())
+            S++, y.set(w, S);
+          x = y.get(_.refColumn) ?? 1;
+        }
+        t.push({
+          oid: v,
+          conname: d,
+          connamespace: n,
+          contype: "f",
+          condeferrable: !1,
+          condeferred: !1,
+          convalidated: !0,
+          conrelid: i,
+          contypid: 0,
+          conindid: 0,
+          conparentid: 0,
+          confrelid: f,
+          confupdtype: "a",
+          confdeltype: "a",
+          confmatchtype: "s",
+          conislocal: !0,
+          coninhcount: 0,
+          connoinherit: !0,
+          conkey: `{${p}}`,
+          confkey: `{${x}}`,
+          conpfeqop: null,
+          conppeqop: null,
+          conffeqop: null,
+          conexclop: null,
+          conbin: null
+        });
+      }
+      for (const [_] of s.checkConstraints) {
+        const d = `${a}_${_}_check`, v = l.get("constraint", d) ?? 0;
+        t.push({
+          oid: v,
+          conname: d,
+          connamespace: n,
+          contype: "c",
+          condeferrable: !1,
+          condeferred: !1,
+          convalidated: !0,
+          conrelid: i,
+          contypid: 0,
+          conindid: 0,
+          conparentid: 0,
+          confrelid: 0,
+          confupdtype: " ",
+          confdeltype: " ",
+          confmatchtype: " ",
+          conislocal: !0,
+          coninhcount: 0,
+          connoinherit: !0,
+          conkey: null,
+          confkey: null,
+          conpfeqop: null,
+          conppeqop: null,
+          conffeqop: null,
+          conexclop: null,
+          conbin: null
+        });
+      }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_index
+  // ==================================================================
+  static _buildPgIndex(e, l) {
+    const o = [
+      "indexrelid",
+      "indrelid",
+      "indnatts",
+      "indnkeyatts",
+      "indisunique",
+      "indisprimary",
+      "indisexclusion",
+      "indimmediate",
+      "indisclustered",
+      "indisvalid",
+      "indcheckxmin",
+      "indisready",
+      "indislive",
+      "indisreplident",
+      "indkey",
+      "indcollation",
+      "indclass",
+      "indoption",
+      "indexprs",
+      "indpred"
+    ], t = [], n = H(e);
+    if (n !== null)
+      for (const a of [...n.keys()].sort()) {
+        const s = n.get(a), i = l.get("index", a) ?? 0, r = s.indexDef, c = l.get("table", r.tableName) ?? 0, _ = e._tables.get(r.tableName), d = r.columns.length, v = [];
+        if (_ !== void 0) {
+          const b = /* @__PURE__ */ new Map();
+          let x = 0;
+          for (const y of _.columns.keys())
+            x++, b.set(y, x);
+          for (const y of r.columns)
+            v.push(String(b.get(y) ?? 0));
+        }
+        const p = v.length > 0 ? v.join(" ") : "0", f = r.unique ?? !1;
+        t.push({
+          indexrelid: i,
+          indrelid: c,
+          indnatts: d,
+          indnkeyatts: d,
+          indisunique: f,
+          indisprimary: !1,
+          indisexclusion: !1,
+          indimmediate: !0,
+          indisclustered: !1,
+          indisvalid: !0,
+          indcheckxmin: !1,
+          indisready: !0,
+          indislive: !0,
+          indisreplident: !1,
+          indkey: p,
+          indcollation: "",
+          indclass: "",
+          indoption: "",
+          indexprs: null,
+          indpred: null
+        });
+      }
+    for (const a of [...e._tables.keys()].sort()) {
+      const s = e._tables.get(a), i = l.get("table", a) ?? 0, r = /* @__PURE__ */ new Map();
+      let c = 0;
+      for (const _ of s.columns.keys())
+        c++, r.set(_, c);
+      if (s.primaryKey) {
+        const _ = `${a}_pkey`, d = l.get("index", _) ?? 0, v = r.get(s.primaryKey) ?? 0;
+        t.push({
+          indexrelid: d,
+          indrelid: i,
+          indnatts: 1,
+          indnkeyatts: 1,
+          indisunique: !0,
+          indisprimary: !0,
+          indisexclusion: !1,
+          indimmediate: !0,
+          indisclustered: !1,
+          indisvalid: !0,
+          indcheckxmin: !1,
+          indisready: !0,
+          indislive: !0,
+          indisreplident: !1,
+          indkey: String(v),
+          indcollation: "",
+          indclass: "",
+          indoption: "",
+          indexprs: null,
+          indpred: null
+        });
+      }
+      for (const [_, d] of s.columns)
+        if (d.unique && !d.primaryKey) {
+          const v = `${a}_${_}_key`, p = l.get("index", v) ?? 0, f = r.get(_) ?? 0;
+          t.push({
+            indexrelid: p,
+            indrelid: i,
+            indnatts: 1,
+            indnkeyatts: 1,
+            indisunique: !0,
+            indisprimary: !1,
+            indisexclusion: !1,
+            indimmediate: !0,
+            indisclustered: !1,
+            indisvalid: !0,
+            indcheckxmin: !1,
+            indisready: !0,
+            indislive: !0,
+            indisreplident: !1,
+            indkey: String(f),
+            indcollation: "",
+            indclass: "",
+            indoption: "",
+            indexprs: null,
+            indpred: null
+          });
+        }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_attrdef -- column defaults
+  // ==================================================================
+  static _buildPgAttrdef(e, l) {
+    const o = ["oid", "adrelid", "adnum", "adbin"], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n), s = l.get("table", n) ?? 0;
+      let i = 0;
+      for (const [r, c] of a.columns)
+        if (i++, c.defaultValue !== null && c.defaultValue !== void 0 || c.autoIncrement) {
+          const _ = l.getOrAlloc("attrdef", `${n}.${r}`);
+          let d;
+          c.autoIncrement ? d = `nextval('${n}_${r}_seq'::regclass)` : d = String(c.defaultValue), t.push({
+            oid: _,
+            adrelid: s,
+            adnum: i,
+            adbin: d
+          });
+        }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_am -- access methods
+  // ==================================================================
+  static _buildPgAm(e, l) {
+    return [["oid", "amname", "amhandler", "amtype"], [
+      {
+        oid: te,
+        amname: "heap",
+        amhandler: "heap_tableam_handler",
+        amtype: "t"
+      },
+      {
+        oid: z,
+        amname: "btree",
+        amhandler: "bthandler",
+        amtype: "i"
+      },
+      {
+        oid: pe,
+        amname: "hash",
+        amhandler: "hashhandler",
+        amtype: "i"
+      },
+      {
+        oid: fe,
+        amname: "hnsw",
+        amhandler: "hnsw_handler",
+        amtype: "i"
+      },
+      {
+        oid: ge,
+        amname: "ivf",
+        amhandler: "ivf_handler",
+        amtype: "i"
+      }
+    ]];
+  }
+  // ==================================================================
+  // pg_database
+  // ==================================================================
+  static _buildPgDatabase(e, l) {
+    return [[
+      "oid",
+      "datname",
+      "datdba",
+      "encoding",
+      "datlocprovider",
+      "datistemplate",
+      "datallowconn",
+      "datconnlimit",
+      "datfrozenxid",
+      "datminmxid",
+      "dattablespace",
+      "datcollate",
+      "datctype",
+      "datlocale",
+      "datcollversion",
+      "datacl"
+    ], [
+      {
+        oid: R,
+        datname: G,
+        datdba: T,
+        encoding: ke,
+        datlocprovider: "c",
+        datistemplate: !1,
+        datallowconn: !0,
+        datconnlimit: -1,
+        datfrozenxid: 0,
+        datminmxid: 1,
+        dattablespace: 1663,
+        datcollate: "en_US.UTF-8",
+        datctype: "en_US.UTF-8",
+        datlocale: null,
+        datcollversion: null,
+        datacl: null
+      }
+    ]];
+  }
+  // ==================================================================
+  // pg_roles
+  // ==================================================================
+  static _buildPgRoles(e, l) {
+    return [[
+      "oid",
+      "rolname",
+      "rolsuper",
+      "rolinherit",
+      "rolcreaterole",
+      "rolcreatedb",
+      "rolcanlogin",
+      "rolreplication",
+      "rolconnlimit",
+      "rolpassword",
+      "rolvaliduntil",
+      "rolbypassrls",
+      "rolconfig"
+    ], [
+      {
+        oid: T,
+        rolname: $,
+        rolsuper: !0,
+        rolinherit: !0,
+        rolcreaterole: !0,
+        rolcreatedb: !0,
+        rolcanlogin: !0,
+        rolreplication: !0,
+        rolconnlimit: -1,
+        rolpassword: null,
+        rolvaliduntil: null,
+        rolbypassrls: !0,
+        rolconfig: null
+      }
+    ]];
+  }
+  // ==================================================================
+  // pg_user -- simplified view over pg_roles
+  // ==================================================================
+  static _buildPgUser(e, l) {
+    return [[
+      "usename",
+      "usesysid",
+      "usecreatedb",
+      "usesuper",
+      "userepl",
+      "usebypassrls",
+      "passwd",
+      "valuntil",
+      "useconfig"
+    ], [
+      {
+        usename: $,
+        usesysid: T,
+        usecreatedb: !0,
+        usesuper: !0,
+        userepl: !0,
+        usebypassrls: !0,
+        passwd: null,
+        valuntil: null,
+        useconfig: null
+      }
+    ]];
+  }
+  // ==================================================================
+  // pg_tables -- convenience view
+  // ==================================================================
+  static _buildPgTables(e, l) {
+    const o = [
+      "schemaname",
+      "tablename",
+      "tableowner",
+      "tablespace",
+      "hasindexes",
+      "hasrules",
+      "hastriggers",
+      "rowsecurity"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n), s = a.primaryKey !== null || [...a.columns.values()].some((i) => i.unique);
+      t.push({
+        schemaname: N,
+        tablename: n,
+        tableowner: $,
+        tablespace: null,
+        hasindexes: s,
+        hasrules: !1,
+        hastriggers: !1,
+        rowsecurity: !1
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_views -- convenience view
+  // ==================================================================
+  static _buildPgViews(e, l) {
+    const o = ["schemaname", "viewname", "viewowner", "definition"], t = [];
+    for (const n of [...e._views.keys()].sort())
+      t.push({
+        schemaname: N,
+        viewname: n,
+        viewowner: $,
+        definition: ""
+      });
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_indexes -- convenience view
+  // ==================================================================
+  static _buildPgIndexes(e, l) {
+    const o = ["schemaname", "tablename", "indexname", "tablespace", "indexdef"], t = [], n = H(e);
+    if (n !== null)
+      for (const a of [...n.keys()].sort()) {
+        const i = n.get(a).indexDef, r = i.columns.join(", ");
+        t.push({
+          schemaname: N,
+          tablename: i.tableName,
+          indexname: a,
+          tablespace: null,
+          indexdef: `CREATE INDEX ${a} ON ${i.tableName} (${r})`
+        });
+      }
+    for (const a of [...e._tables.keys()].sort()) {
+      const s = e._tables.get(a);
+      if (s.primaryKey) {
+        const i = `${a}_pkey`;
+        t.push({
+          schemaname: N,
+          tablename: a,
+          indexname: i,
+          tablespace: null,
+          indexdef: `CREATE UNIQUE INDEX ${i} ON ${a} (${s.primaryKey})`
+        });
+      }
+      for (const [i, r] of s.columns)
+        if (r.unique && !r.primaryKey) {
+          const c = `${a}_${i}_key`;
+          t.push({
+            schemaname: N,
+            tablename: a,
+            indexname: c,
+            tablespace: null,
+            indexdef: `CREATE UNIQUE INDEX ${c} ON ${a} (${i})`
+          });
+        }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_matviews -- materialized views (empty, UQA has none)
+  // ==================================================================
+  static _buildPgMatviews(e, l) {
+    return [[
+      "schemaname",
+      "matviewname",
+      "matviewowner",
+      "tablespace",
+      "hasindexes",
+      "ispopulated",
+      "definition"
+    ], []];
+  }
+  // ==================================================================
+  // pg_sequences
+  // ==================================================================
+  static _buildPgSequences(e, l) {
+    const o = [
+      "schemaname",
+      "sequencename",
+      "sequenceowner",
+      "data_type",
+      "start_value",
+      "min_value",
+      "max_value",
+      "increment_by",
+      "cycle",
+      "cache_size",
+      "last_value"
+    ], t = [];
+    for (const n of [...e._sequences.keys()].sort()) {
+      const a = e._sequences.get(n);
+      t.push({
+        schemaname: N,
+        sequencename: n,
+        sequenceowner: $,
+        data_type: "bigint",
+        start_value: a.start ?? 1,
+        min_value: 1,
+        max_value: 9223372036854776e3,
+        increment_by: a.increment ?? 1,
+        cycle: !1,
+        cache_size: 1,
+        last_value: a.current ?? a.start ?? 1
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_settings -- runtime parameters (GUC)
+  // ==================================================================
+  static _buildPgSettings(e, l) {
+    const o = [
+      "name",
+      "setting",
+      "unit",
+      "category",
+      "short_desc",
+      "extra_desc",
+      "context",
+      "vartype",
+      "source",
+      "min_val",
+      "max_val",
+      "enumvals",
+      "boot_val",
+      "reset_val",
+      "sourcefile",
+      "sourceline",
+      "pending_restart"
+    ], t = [
+      [
+        "server_version",
+        "17.0",
+        null,
+        "Preset Options",
+        "Shows the server version.",
+        null,
+        "internal",
+        "string",
+        "default",
+        null,
+        null,
+        null,
+        "17.0",
+        "17.0",
+        null,
+        null,
+        !1
+      ],
+      [
+        "server_version_num",
+        "170000",
+        null,
+        "Preset Options",
+        "Shows the server version as an integer.",
+        null,
+        "internal",
+        "integer",
+        "default",
+        null,
+        null,
+        null,
+        "170000",
+        "170000",
+        null,
+        null,
+        !1
+      ],
+      [
+        "server_encoding",
+        "UTF8",
+        null,
+        "Preset Options",
+        "Shows the server encoding.",
+        null,
+        "internal",
+        "string",
+        "default",
+        null,
+        null,
+        null,
+        "UTF8",
+        "UTF8",
+        null,
+        null,
+        !1
+      ],
+      [
+        "client_encoding",
+        "UTF8",
+        null,
+        "Client Connection Defaults",
+        "Sets the client encoding.",
+        null,
+        "user",
+        "string",
+        "default",
+        null,
+        null,
+        null,
+        "UTF8",
+        "UTF8",
+        null,
+        null,
+        !1
+      ],
+      [
+        "lc_collate",
+        "en_US.UTF-8",
+        null,
+        "Preset Options",
+        "Shows the collation order locale.",
+        null,
+        "internal",
+        "string",
+        "default",
+        null,
+        null,
+        null,
+        "en_US.UTF-8",
+        "en_US.UTF-8",
+        null,
+        null,
+        !1
+      ],
+      [
+        "lc_ctype",
+        "en_US.UTF-8",
+        null,
+        "Preset Options",
+        "Shows the character classification locale.",
+        null,
+        "internal",
+        "string",
+        "default",
+        null,
+        null,
+        null,
+        "en_US.UTF-8",
+        "en_US.UTF-8",
+        null,
+        null,
+        !1
+      ],
+      [
+        "DateStyle",
+        "ISO, MDY",
+        null,
+        "Client Connection Defaults",
+        "Sets the display format for date and time.",
+        null,
+        "user",
+        "string",
+        "default",
+        null,
+        null,
+        null,
+        "ISO, MDY",
+        "ISO, MDY",
+        null,
+        null,
+        !1
+      ],
+      [
+        "TimeZone",
+        "UTC",
+        null,
+        "Client Connection Defaults",
+        "Sets the time zone.",
+        null,
+        "user",
+        "string",
+        "default",
+        null,
+        null,
+        null,
+        "UTC",
+        "UTC",
+        null,
+        null,
+        !1
+      ],
+      [
+        "standard_conforming_strings",
+        "on",
+        null,
+        "Client Connection Defaults",
+        "Causes strings to treat backslashes literally.",
+        null,
+        "user",
+        "bool",
+        "default",
+        null,
+        null,
+        null,
+        "on",
+        "on",
+        null,
+        null,
+        !1
+      ],
+      [
+        "search_path",
+        '"$user", public',
+        null,
+        "Client Connection Defaults",
+        "Sets the schema search order.",
+        null,
+        "user",
+        "string",
+        "default",
+        null,
+        null,
+        null,
+        '"$user", public',
+        '"$user", public',
+        null,
+        null,
+        !1
+      ],
+      [
+        "default_transaction_isolation",
+        "read committed",
+        null,
+        "Client Connection Defaults",
+        "Sets the default transaction isolation level.",
+        null,
+        "user",
+        "enum",
+        "default",
+        null,
+        null,
+        "serializable,repeatable read,read committed,read uncommitted",
+        "read committed",
+        "read committed",
+        null,
+        null,
+        !1
+      ],
+      [
+        "max_connections",
+        "100",
+        null,
+        "Connections and Authentication",
+        "Sets the maximum number of concurrent connections.",
+        null,
+        "postmaster",
+        "integer",
+        "default",
+        "1",
+        "262143",
+        null,
+        "100",
+        "100",
+        null,
+        null,
+        !1
+      ],
+      [
+        "shared_buffers",
+        "16384",
+        "8kB",
+        "Resource Usage / Memory",
+        "Sets the number of shared memory buffers.",
+        null,
+        "postmaster",
+        "integer",
+        "default",
+        "16",
+        "1073741823",
+        null,
+        "16384",
+        "16384",
+        null,
+        null,
+        !1
+      ],
+      [
+        "work_mem",
+        "4096",
+        "kB",
+        "Resource Usage / Memory",
+        "Sets the maximum memory for query operations.",
+        null,
+        "user",
+        "integer",
+        "default",
+        "64",
+        "2147483647",
+        null,
+        "4096",
+        "4096",
+        null,
+        null,
+        !1
+      ],
+      [
+        "is_superuser",
+        "on",
+        null,
+        "Preset Options",
+        "Shows whether the current user is a superuser.",
+        null,
+        "internal",
+        "bool",
+        "default",
+        null,
+        null,
+        null,
+        "on",
+        "on",
+        null,
+        null,
+        !1
+      ],
+      [
+        "transaction_isolation",
+        "read committed",
+        null,
+        "Client Connection Defaults",
+        "Shows the current transaction isolation level.",
+        null,
+        "user",
+        "string",
+        "override",
+        null,
+        null,
+        null,
+        "read committed",
+        "read committed",
+        null,
+        null,
+        !1
+      ],
+      [
+        "integer_datetimes",
+        "on",
+        null,
+        "Preset Options",
+        "Shows if datetimes are stored as 64-bit integers.",
+        null,
+        "internal",
+        "bool",
+        "default",
+        null,
+        null,
+        null,
+        "on",
+        "on",
+        null,
+        null,
+        !1
+      ]
+    ], n = [];
+    for (const a of t)
+      n.push({
+        name: a[0],
+        setting: a[1],
+        unit: a[2],
+        category: a[3],
+        short_desc: a[4],
+        extra_desc: a[5],
+        context: a[6],
+        vartype: a[7],
+        source: a[8],
+        min_val: a[9],
+        max_val: a[10],
+        enumvals: a[11],
+        boot_val: a[12],
+        reset_val: a[13],
+        sourcefile: a[14],
+        sourceline: a[15],
+        pending_restart: a[16]
+      });
+    return [o, n];
+  }
+  // ==================================================================
+  // pg_foreign_server
+  // ==================================================================
+  static _buildPgForeignServer(e, l) {
+    const o = [
+      "oid",
+      "srvname",
+      "srvowner",
+      "srvfdw",
+      "srvtype",
+      "srvversion",
+      "srvacl",
+      "srvoptions"
+    ], t = [];
+    for (const n of [...e._foreignServers.keys()].sort()) {
+      const a = e._foreignServers.get(n), s = l.get("foreign_server", n) ?? 0, i = l.get("fdw", a.fdwType) ?? 0, r = Object.entries(a.options).sort(([c], [_]) => c.localeCompare(_)).map(([c, _]) => `${c}=${_}`);
+      t.push({
+        oid: s,
+        srvname: n,
+        srvowner: T,
+        srvfdw: i,
+        srvtype: null,
+        srvversion: null,
+        srvacl: null,
+        srvoptions: r.length > 0 ? `{${r.join(",")}}` : null
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_foreign_table
+  // ==================================================================
+  static _buildPgForeignTable(e, l) {
+    const o = ["ftrelid", "ftserver", "ftoptions"], t = [];
+    for (const n of [...e._foreignTables.keys()].sort()) {
+      const a = e._foreignTables.get(n), s = l.get("foreign_table", n) ?? 0, i = l.get("foreign_server", a.serverName) ?? 0, r = Object.entries(a.options).sort(([c], [_]) => c.localeCompare(_)).map(([c, _]) => `${c}=${_}`);
+      t.push({
+        ftrelid: s,
+        ftserver: i,
+        ftoptions: r.length > 0 ? `{${r.join(",")}}` : null
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_foreign_data_wrapper
+  // ==================================================================
+  static _buildPgForeignDataWrapper(e, l) {
+    const o = [
+      "oid",
+      "fdwname",
+      "fdwowner",
+      "fdwhandler",
+      "fdwvalidator",
+      "fdwacl",
+      "fdwoptions"
+    ], t = [], n = /* @__PURE__ */ new Set();
+    for (const a of [...e._foreignServers.keys()].sort()) {
+      const s = e._foreignServers.get(a);
+      if (n.has(s.fdwType)) continue;
+      n.add(s.fdwType);
+      const i = l.get("fdw", s.fdwType) ?? 0;
+      t.push({
+        oid: i,
+        fdwname: s.fdwType,
+        fdwowner: T,
+        fdwhandler: 0,
+        fdwvalidator: 0,
+        fdwacl: null,
+        fdwoptions: null
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_description -- object comments
+  // ==================================================================
+  static _buildPgDescription(e, l) {
+    return [["objoid", "classoid", "objsubid", "description"], []];
+  }
+  // ==================================================================
+  // pg_depend -- object dependencies
+  // ==================================================================
+  static _buildPgDepend(e, l) {
+    return [[
+      "classid",
+      "objid",
+      "objsubid",
+      "refclassid",
+      "refobjid",
+      "refobjsubid",
+      "deptype"
+    ], []];
+  }
+  // ==================================================================
+  // pg_stat_user_tables (also used for pg_stat_all_tables)
+  // ==================================================================
+  static _buildPgStatUserTables(e, l) {
+    const o = [
+      "relid",
+      "schemaname",
+      "relname",
+      "seq_scan",
+      "seq_tup_read",
+      "idx_scan",
+      "idx_tup_fetch",
+      "n_tup_ins",
+      "n_tup_upd",
+      "n_tup_del",
+      "n_tup_hot_upd",
+      "n_live_tup",
+      "n_dead_tup",
+      "n_mod_since_analyze",
+      "n_ins_since_vacuum",
+      "last_vacuum",
+      "last_autovacuum",
+      "last_analyze",
+      "last_autoanalyze",
+      "vacuum_count",
+      "autovacuum_count",
+      "analyze_count",
+      "autoanalyze_count"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n), s = l.get("table", n) ?? 0, i = a.rowCount, r = !!a._stats;
+      t.push({
+        relid: s,
+        schemaname: N,
+        relname: n,
+        seq_scan: 0,
+        seq_tup_read: 0,
+        idx_scan: 0,
+        idx_tup_fetch: 0,
+        n_tup_ins: i,
+        n_tup_upd: 0,
+        n_tup_del: 0,
+        n_tup_hot_upd: 0,
+        n_live_tup: i,
+        n_dead_tup: 0,
+        n_mod_since_analyze: r ? 0 : i,
+        n_ins_since_vacuum: i,
+        last_vacuum: null,
+        last_autovacuum: null,
+        last_analyze: null,
+        last_autoanalyze: null,
+        vacuum_count: 0,
+        autovacuum_count: 0,
+        analyze_count: r ? 1 : 0,
+        autoanalyze_count: 0
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_stat_user_indexes
+  // ==================================================================
+  static _buildPgStatUserIndexes(e, l) {
+    const o = [
+      "relid",
+      "indexrelid",
+      "schemaname",
+      "relname",
+      "indexrelname",
+      "idx_scan",
+      "idx_tup_read",
+      "idx_tup_fetch"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = e._tables.get(n), s = l.get("table", n) ?? 0;
+      if (a.primaryKey) {
+        const i = `${n}_pkey`, r = l.get("index", i) ?? 0;
+        t.push({
+          relid: s,
+          indexrelid: r,
+          schemaname: N,
+          relname: n,
+          indexrelname: i,
+          idx_scan: 0,
+          idx_tup_read: 0,
+          idx_tup_fetch: 0
+        });
+      }
+      for (const [i, r] of a.columns)
+        if (r.unique && !r.primaryKey) {
+          const c = `${n}_${i}_key`, _ = l.get("index", c) ?? 0;
+          t.push({
+            relid: s,
+            indexrelid: _,
+            schemaname: N,
+            relname: n,
+            indexrelname: c,
+            idx_scan: 0,
+            idx_tup_read: 0,
+            idx_tup_fetch: 0
+          });
+        }
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_stat_activity -- active sessions
+  // ==================================================================
+  static _buildPgStatActivity(e, l) {
+    const o = [
+      "datid",
+      "datname",
+      "pid",
+      "leader_pid",
+      "usesysid",
+      "usename",
+      "application_name",
+      "client_addr",
+      "client_hostname",
+      "client_port",
+      "backend_start",
+      "xact_start",
+      "query_start",
+      "state_change",
+      "wait_event_type",
+      "wait_event",
+      "state",
+      "backend_xid",
+      "backend_xmin",
+      "query_id",
+      "query",
+      "backend_type"
+    ], t = xe();
+    let n;
+    return t.length > 0 ? n = t.map((a) => {
+      var s, i, r, c;
+      return {
+        datid: R,
+        datname: a.database || G,
+        pid: a.pid,
+        leader_pid: null,
+        usesysid: T,
+        usename: a.username || $,
+        application_name: a.applicationName,
+        client_addr: a.clientAddr,
+        client_hostname: null,
+        client_port: a.clientPort,
+        backend_start: ((s = a.backendStart) == null ? void 0 : s.toISOString()) ?? null,
+        xact_start: ((i = a.xactStart) == null ? void 0 : i.toISOString()) ?? null,
+        query_start: ((r = a.queryStart) == null ? void 0 : r.toISOString()) ?? null,
+        state_change: ((c = a.stateChange) == null ? void 0 : c.toISOString()) ?? null,
+        wait_event_type: null,
+        wait_event: null,
+        state: a.state,
+        backend_xid: null,
+        backend_xmin: null,
+        query_id: null,
+        query: a.query,
+        backend_type: a.backendType
+      };
+    }) : n = [
+      {
+        datid: R,
+        datname: G,
+        pid: process.pid,
+        leader_pid: null,
+        usesysid: T,
+        usename: $,
+        application_name: "usqldb",
+        client_addr: null,
+        client_hostname: null,
+        client_port: -1,
+        backend_start: null,
+        xact_start: null,
+        query_start: null,
+        state_change: null,
+        wait_event_type: null,
+        wait_event: null,
+        state: "active",
+        backend_xid: null,
+        backend_xmin: null,
+        query_id: null,
+        query: "",
+        backend_type: "client backend"
+      }
+    ], [o, n];
+  }
+  // ==================================================================
+  // pg_proc -- functions/procedures
+  // ==================================================================
+  static _buildPgProc(e, l) {
+    const o = [
+      "oid",
+      "proname",
+      "pronamespace",
+      "proowner",
+      "prolang",
+      "procost",
+      "prorows",
+      "provariadic",
+      "prosupport",
+      "prokind",
+      "prosecdef",
+      "proleakproof",
+      "proisstrict",
+      "proretset",
+      "provolatile",
+      "proparallel",
+      "pronargs",
+      "pronargdefaults",
+      "prorettype",
+      "proargtypes",
+      "proallargtypes",
+      "proargmodes",
+      "proargnames",
+      "proargdefaults",
+      "protrftypes",
+      "prosrc",
+      "probin",
+      "prosqlbody",
+      "proconfig",
+      "proacl"
+    ], t = [
+      ["text_match", 2, 25, "25 25"],
+      ["bayesian_match", 2, 25, "25 25"],
+      ["knn_match", 3, 25, "25 2277 23"],
+      ["traverse_match", 3, 25, "23 25 23"],
+      ["fuse_log_odds", 0, 25, ""],
+      ["fuse_prob_and", 0, 25, ""],
+      ["fuse_prob_or", 0, 25, ""],
+      ["fuse_prob_not", 1, 25, "25"],
+      ["spatial_within", 4, 25, "25 600 600 701"]
+    ], n = [], a = U;
+    for (const [s, i, r, c] of t) {
+      const _ = l.getOrAlloc("function", s);
+      n.push({
+        oid: _,
+        proname: s,
+        pronamespace: a,
+        proowner: T,
+        prolang: 14,
+        // SQL
+        procost: 100,
+        prorows: 0,
+        provariadic: 0,
+        prosupport: "",
+        prokind: "f",
+        prosecdef: !1,
+        proleakproof: !1,
+        proisstrict: !1,
+        proretset: !1,
+        provolatile: "v",
+        proparallel: "u",
+        pronargs: i,
+        pronargdefaults: 0,
+        prorettype: r,
+        proargtypes: c,
+        proallargtypes: null,
+        proargmodes: null,
+        proargnames: null,
+        proargdefaults: null,
+        protrftypes: null,
+        prosrc: s,
+        probin: null,
+        prosqlbody: null,
+        proconfig: null,
+        proacl: null
+      });
+    }
+    return [o, n];
+  }
+  // ==================================================================
+  // pg_extension
+  // ==================================================================
+  static _buildPgExtension(e, l) {
+    return [[
+      "oid",
+      "extname",
+      "extowner",
+      "extnamespace",
+      "extrelocatable",
+      "extversion",
+      "extconfig",
+      "extcondition"
+    ], [
+      {
+        oid: 13181,
+        extname: "plpgsql",
+        extowner: T,
+        extnamespace: E,
+        extrelocatable: !1,
+        extversion: "1.0",
+        extconfig: null,
+        extcondition: null
+      }
+    ]];
+  }
+  // ==================================================================
+  // pg_collation
+  // ==================================================================
+  static _buildPgCollation(e, l) {
+    return [[
+      "oid",
+      "collname",
+      "collnamespace",
+      "collowner",
+      "collprovider",
+      "collisdeterministic",
+      "collencoding",
+      "collcollate",
+      "collctype",
+      "colliculocale",
+      "collicurules",
+      "collversion"
+    ], [
+      {
+        oid: 100,
+        collname: "default",
+        collnamespace: E,
+        collowner: T,
+        collprovider: "d",
+        collisdeterministic: !0,
+        collencoding: -1,
+        collcollate: "",
+        collctype: "",
+        colliculocale: null,
+        collicurules: null,
+        collversion: null
+      },
+      {
+        oid: 950,
+        collname: "C",
+        collnamespace: E,
+        collowner: T,
+        collprovider: "c",
+        collisdeterministic: !0,
+        collencoding: -1,
+        collcollate: "C",
+        collctype: "C",
+        colliculocale: null,
+        collicurules: null,
+        collversion: null
+      },
+      {
+        oid: 951,
+        collname: "POSIX",
+        collnamespace: E,
+        collowner: T,
+        collprovider: "c",
+        collisdeterministic: !0,
+        collencoding: -1,
+        collcollate: "POSIX",
+        collctype: "POSIX",
+        colliculocale: null,
+        collicurules: null,
+        collversion: null
+      }
+    ]];
+  }
+  // ==================================================================
+  // pg_enum (empty -- UQA has no enum types)
+  // ==================================================================
+  static _buildPgEnum(e, l) {
+    return [["oid", "enumtypid", "enumsortorder", "enumlabel"], []];
+  }
+  // ==================================================================
+  // pg_inherits (empty -- no inheritance)
+  // ==================================================================
+  static _buildPgInherits(e, l) {
+    return [["inhrelid", "inhparent", "inhseqno", "inhdetachpending"], []];
+  }
+  // ==================================================================
+  // pg_trigger (empty -- no triggers)
+  // ==================================================================
+  static _buildPgTrigger(e, l) {
+    return [[
+      "oid",
+      "tgrelid",
+      "tgparentid",
+      "tgname",
+      "tgfoid",
+      "tgtype",
+      "tgenabled",
+      "tgisinternal",
+      "tgconstrrelid",
+      "tgconstrindid",
+      "tgconstraint",
+      "tgdeferrable",
+      "tginitdeferred",
+      "tgnargs",
+      "tgattr",
+      "tgargs",
+      "tgqual",
+      "tgoldtable",
+      "tgnewtable"
+    ], []];
+  }
+  // ==================================================================
+  // pg_statio_user_tables
+  // ==================================================================
+  static _buildPgStatioUserTables(e, l) {
+    const o = [
+      "relid",
+      "schemaname",
+      "relname",
+      "heap_blks_read",
+      "heap_blks_hit",
+      "idx_blks_read",
+      "idx_blks_hit",
+      "toast_blks_read",
+      "toast_blks_hit",
+      "tidx_blks_read",
+      "tidx_blks_hit"
+    ], t = [];
+    for (const n of [...e._tables.keys()].sort()) {
+      const a = l.get("table", n) ?? 0;
+      t.push({
+        relid: a,
+        schemaname: N,
+        relname: n,
+        heap_blks_read: 0,
+        heap_blks_hit: 0,
+        idx_blks_read: 0,
+        idx_blks_hit: 0,
+        toast_blks_read: 0,
+        toast_blks_hit: 0,
+        tidx_blks_read: 0,
+        tidx_blks_hit: 0
+      });
+    }
+    return [o, t];
+  }
+  // ==================================================================
+  // pg_auth_members (empty -- single user)
+  // ==================================================================
+  static _buildPgAuthMembers(e, l) {
+    return [[
+      "oid",
+      "roleid",
+      "member",
+      "grantor",
+      "admin_option",
+      "inherit_option",
+      "set_option"
+    ], []];
+  }
+  // ==================================================================
+  // pg_available_extensions
+  // ==================================================================
+  static _buildPgAvailableExtensions(e, l) {
+    return [["name", "default_version", "installed_version", "comment"], [
+      {
+        name: "plpgsql",
+        default_version: "1.0",
+        installed_version: "1.0",
+        comment: "PL/pgSQL procedural language"
+      }
+    ]];
+  }
+};
+A(g, "_TABLES", {
+  pg_namespace: g._buildPgNamespace,
+  pg_class: g._buildPgClass,
+  pg_attribute: g._buildPgAttribute,
+  pg_type: g._buildPgType,
+  pg_constraint: g._buildPgConstraint,
+  pg_index: g._buildPgIndex,
+  pg_attrdef: g._buildPgAttrdef,
+  pg_am: g._buildPgAm,
+  pg_database: g._buildPgDatabase,
+  pg_roles: g._buildPgRoles,
+  pg_user: g._buildPgUser,
+  pg_tables: g._buildPgTables,
+  pg_views: g._buildPgViews,
+  pg_indexes: g._buildPgIndexes,
+  pg_matviews: g._buildPgMatviews,
+  pg_sequences: g._buildPgSequences,
+  pg_settings: g._buildPgSettings,
+  pg_foreign_server: g._buildPgForeignServer,
+  pg_foreign_table: g._buildPgForeignTable,
+  pg_foreign_data_wrapper: g._buildPgForeignDataWrapper,
+  pg_description: g._buildPgDescription,
+  pg_depend: g._buildPgDepend,
+  pg_stat_user_tables: g._buildPgStatUserTables,
+  pg_stat_user_indexes: g._buildPgStatUserIndexes,
+  pg_stat_activity: g._buildPgStatActivity,
+  pg_proc: g._buildPgProc,
+  pg_extension: g._buildPgExtension,
+  pg_collation: g._buildPgCollation,
+  pg_enum: g._buildPgEnum,
+  pg_inherits: g._buildPgInherits,
+  pg_trigger: g._buildPgTrigger,
+  pg_statio_user_tables: g._buildPgStatioUserTables,
+  pg_auth_members: g._buildPgAuthMembers,
+  pg_available_extensions: g._buildPgAvailableExtensions,
+  pg_stat_all_tables: g._buildPgStatUserTables
+});
+let F = g;
+const X = new Set(
+  F.supportedTables()
+), Q = new Set(
+  D.supportedViews()
+);
+function re(u, e) {
+  return {
+    _tables: u._tables,
+    _views: u._views,
+    _sequences: u._sequences,
+    _foreignServers: u._foreignServers,
+    _foreignTables: u._foreignTables,
+    _tempTables: e._tempTables ?? /* @__PURE__ */ new Set(),
+    _indexManager: e._indexManager ?? null
+  };
+}
+function Oe(u) {
+  if (u.length === 0) return !0;
+  if (u.length !== 1) return !1;
+  try {
+    return "A_Star" in u[0].ResTarget.val.ColumnRef.fields[0];
+  } catch {
+    return !1;
+  }
+}
+class qe extends de {
+  constructor(l) {
+    super(l);
+    A(this, "_oidAllocator", null);
+    this._patchCompiler();
+  }
+  _patchCompiler() {
+    const l = this._compiler, o = this._getOids.bind(this), t = this, n = l._applyAlias, a = l._resultToTable;
+    function s(p, f, b, x) {
+      const y = me(x), S = a.call(p, f, {
+        columns: b,
+        rows: y
+      }), w = p._tables, O = p._shadowedTables, C = p._expandedViews, j = w.get(f);
+      return j !== void 0 && !O.has(f) && O.set(f, j), w.set(f, S), C.push(f), f;
+    }
+    function i(p, f) {
+      const b = re(p, t), x = o(b), [y, S] = D.build(
+        f,
+        b,
+        x
+      );
+      return s(p, `_info_schema_${f}`, y, S);
+    }
+    function r(p, f) {
+      const b = re(p, t), x = o(b), [y, S] = F.build(f, b, x);
+      return s(p, `_pg_${f}`, y, S);
+    }
+    function c(p, f, b) {
+      const y = p._tables.get(f);
+      if (!y) return [];
+      const S = y.documentStore, w = [];
+      for (const [, O] of S.iterAll())
+        w.push({ ...O });
+      return n.call(p, w, b);
+    }
+    const _ = l._resolveFromItem;
+    l._resolveFromItem = function(p, f) {
+      const b = p == null ? void 0 : p.RangeVar;
+      if (b) {
+        const x = b.schemaname || null, y = b.relname, S = b.alias, w = S && S.aliasname || y;
+        if (x === "information_schema") {
+          const O = i(
+            this,
+            y
+          );
+          return c(this, O, w);
+        }
+        if (x === "pg_catalog") {
+          const O = r(
+            this,
+            y
+          );
+          return c(this, O, w);
+        }
+        if (x === null && y) {
+          const O = this._tables, C = this._views, j = this._foreignTables, ce = this._inlinedCTEs;
+          if (!O.has(y) && !C.has(y) && !j.has(y) && !ce.has(y)) {
+            if (X.has(y)) {
+              const M = r(
+                this,
+                y
+              );
+              return c(
+                this,
+                M,
+                w
+              );
+            }
+            if (Q.has(y)) {
+              const M = i(
+                this,
+                y
+              );
+              return c(
+                this,
+                M,
+                w
+              );
+            }
+          }
+        }
+      }
+      return _.call(this, p, f);
+    };
+    const d = l._projectColumns;
+    l._projectColumns = function(p, f, b) {
+      if (f.length === 0 && Oe(p)) {
+        const x = this._expandedViews, y = this._tables;
+        for (let S = x.length - 1; S >= 0; S--) {
+          const w = x[S];
+          if (w.startsWith("_pg_") || w.startsWith("_info_schema_")) {
+            const O = y.get(w);
+            if (O) {
+              const C = O.columns;
+              if (C.size > 0)
+                return [[...C.keys()], []];
+            }
+          }
+        }
+      }
+      return d.call(this, p, f, b);
+    };
+    const v = l.constructor;
+    v._walkAstForTables = function p(f, b) {
+      if (f == null || typeof f != "object") return;
+      if (Array.isArray(f)) {
+        for (const w of f)
+          p(w, b);
+        return;
+      }
+      const x = f, y = x.RangeVar;
+      if (y !== void 0) {
+        const w = y.schemaname;
+        if (w === "information_schema" || w === "pg_catalog")
+          return;
+        const O = y.relname;
+        if (!w && O && (X.has(O) || Q.has(O)))
+          return;
+        O && b.add(O);
+        return;
+      }
+      const S = x.relname;
+      if (typeof S == "string" && S) {
+        const w = x.schemaname;
+        w === "information_schema" || w === "pg_catalog" || !w && (X.has(S) || Q.has(S)) || b.add(S);
+      }
+      for (const w of Object.values(x))
+        w !== null && typeof w == "object" && p(w, b);
+    };
+  }
+  _getOids(l) {
+    return this._oidAllocator === null && (this._oidAllocator = new he(l ?? this)), this._oidAllocator;
+  }
+  async sql(l, o) {
+    return this._oidAllocator = null, await this.init(), super.sql(l, o);
+  }
+}
+export {
+  D as InformationSchemaProvider,
+  he as OIDAllocator,
+  F as PGCatalogProvider,
+  qe as USQLEngine,
+  me as normalizeRows
+};
+//# sourceMappingURL=usqldb.es.js.map