@query-farm/vgi 0.37.1 → 0.39.0

package/dist/client-entry.js

@@ -2284,7 +2284,84 @@ function normalizeSchemaPath(path) {
 
 // src/codec/asd.ts
 function encodeASD(schema, obj) {
-  return serializeBatch(batchFromRows([obj], schema));
+  return serializeBatch(batchFromRows([sortMapsForSchema(schema, obj)], schema));
+}
+function compareCodePoints(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0;i < n; i++) {
+    const x = a.charCodeAt(i);
+    const y = b.charCodeAt(i);
+    if (x === y)
+      continue;
+    const xs = x >= 55296 && x <= 57343;
+    const ys = y >= 55296 && y <= 57343;
+    if (xs !== ys)
+      return xs ? 1 : -1;
+    return x - y;
+  }
+  return a.length - b.length;
+}
+function mapPairs(raw) {
+  if (Array.isArray(raw))
+    return raw.map((e) => Array.isArray(e) ? [e[0], e[1]] : [e?.key, e?.value]);
+  if (raw instanceof Map)
+    return Array.from(raw.entries());
+  if (typeof raw[Symbol.iterator] === "function")
+    return Array.from(raw);
+  return Object.entries(raw);
+}
+function compareKeys(a, b) {
+  if (typeof a === "string" && typeof b === "string")
+    return compareCodePoints(a, b);
+  if ((typeof a === "number" || typeof a === "bigint") && (typeof b === "number" || typeof b === "bigint")) {
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  return compareCodePoints(String(a), String(b));
+}
+var HAS_MAP = new WeakMap;
+function typeHasMap(type) {
+  const cached = HAS_MAP.get(type);
+  if (cached !== undefined)
+    return cached;
+  let has = isMap(type);
+  if (!has && (isList(type) || isStruct(type))) {
+    has = type.children.some((c) => typeHasMap(c.type));
+  }
+  HAS_MAP.set(type, has);
+  return has;
+}
+function sortMapsForType(type, value) {
+  if (value == null || !typeHasMap(type))
+    return value;
+  if (isMap(type)) {
+    const entries = type.children[0].type;
+    const valueType = entries.children[1].type;
+    return mapPairs(value).map(([k, v]) => [k, sortMapsForType(valueType, v)]).sort((x, y) => compareKeys(x[0], y[0]));
+  }
+  if (isList(type)) {
+    const child = type.children[0].type;
+    return Array.from(value, (v) => sortMapsForType(child, v));
+  }
+  if (isStruct(type)) {
+    const out = { ...value };
+    for (const cf of type.children)
+      out[cf.name] = sortMapsForType(cf.type, value[cf.name]);
+    return out;
+  }
+  return value;
+}
+function sortMapsForSchema(schema, obj) {
+  let out = null;
+  for (const f of schema.fields) {
+    if (!typeHasMap(f.type))
+      continue;
+    const v = obj[f.name];
+    if (v == null)
+      continue;
+    out ??= { ...obj };
+    out[f.name] = sortMapsForType(f.type, v);
+  }
+  return out ?? obj;
 }
 function decodeASD(schema, bytes) {
   const batch = deserializeBatch(bytes);
@@ -2311,21 +2388,23 @@ function normalizeValue(raw, type) {
     return out;
   }
   if (isMap(type)) {
+    const entries = type.children[0].type;
+    const valueType = entries.children[1].type;
     const out = {};
+    const put = (k, v) => {
+      out[String(k)] = normalizeValue(v, valueType);
+    };
     if (raw[Symbol.iterator]) {
       for (const entry of raw) {
         if (Array.isArray(entry)) {
-          out[String(entry[0])] = String(entry[1] ?? "");
+          put(entry[0], entry[1]);
         } else if (entry && typeof entry === "object") {
-          const k = entry.key ?? entry[0];
-          const v = entry.value ?? entry[1];
-          out[String(k)] = v == null ? "" : String(v);
+          put(entry.key ?? entry[0], entry.value ?? entry[1]);
         }
       }
     } else if (typeof raw === "object") {
-      for (const [k, v] of Object.entries(raw)) {
-        out[String(k)] = v == null ? "" : String(v);
-      }
+      for (const [k, v] of Object.entries(raw))
+        put(k, v);
     }
     return out;
   }
@@ -2540,6 +2619,18 @@ var ForeignKeyInfoSchema = schema2([
   field2("referenced_table", utf82(), false),
   field2("referenced_schema_path", list2(field2("item", utf82(), true)), false)
 ]);
+var SchemaContentsSchema = schema2([
+  field2("path", list2(field2("item", utf82(), true)), false),
+  field2("schema", binary2(), false),
+  field2("tables", list2(field2("item", binary2(), true)), false),
+  field2("views", list2(field2("item", binary2(), true)), false),
+  field2("scalar_functions", list2(field2("item", binary2(), true)), false),
+  field2("aggregate_functions", list2(field2("item", binary2(), true)), false),
+  field2("table_functions", list2(field2("item", binary2(), true)), false),
+  field2("scalar_macros", list2(field2("item", binary2(), true)), false),
+  field2("table_macros", list2(field2("item", binary2(), true)), false),
+  field2("indexes", list2(field2("item", binary2(), true)), false)
+]);
 var AggregateBindRequestSchema = schema2([
   field2("function_name", utf82(), false),
   field2("arguments", binary2(), false),
@@ -2862,11 +2953,18 @@ var CatalogAttachResultSchema = schema2([
   field2("global_functions", list2(field2("item", binary2(), true)), false),
   field2("global_function_prefix", utf82(), false),
   field2("resolved_data_version", utf82(), true),
-  field2("resolved_implementation_version", utf82(), true)
+  field2("resolved_implementation_version", utf82(), true),
+  field2("supports_catalog_contents", bool2(), false)
 ]);
 var CatalogCatalogsResultSchema = schema2([
   field2("items", list2(field2("item", binary2(), true)), false)
 ]);
+var CatalogContentsResultSchema = schema2([
+  field2("catalog_version", int642(), false),
+  field2("etag", utf82(), true),
+  field2("not_modified", bool2(), false),
+  field2("schemas", list2(field2("item", struct2([field2("path", list2(field2("item", utf82(), true)), false), field2("schema", binary2(), false), field2("tables", list2(field2("item", binary2(), true)), false), field2("views", list2(field2("item", binary2(), true)), false), field2("scalar_functions", list2(field2("item", binary2(), true)), false), field2("aggregate_functions", list2(field2("item", binary2(), true)), false), field2("table_functions", list2(field2("item", binary2(), true)), false), field2("scalar_macros", list2(field2("item", binary2(), true)), false), field2("table_macros", list2(field2("item", binary2(), true)), false), field2("indexes", list2(field2("item", binary2(), true)), false)]), true)), false)
+]);
 var CatalogCopyFromFormatsResultSchema = schema2([
   field2("items", list2(field2("item", binary2(), true)), false)
 ]);
@@ -2985,6 +3083,10 @@ var CatalogAttachParamsSchema = schema2([
   field2("request", binary2(), false)
 ]);
 var CatalogCatalogsParamsSchema = schema2([]);
+var CatalogContentsParamsSchema = schema2([
+  field2("attach_opaque_data", binary2(), false),
+  field2("if_none_match", utf82(), true)
+]);
 var CatalogCopyFromFormatsParamsSchema = schema2([
   field2("attach_opaque_data", binary2(), false),
   field2("transaction_opaque_data", binary2(), true)
@@ -3315,10 +3417,14 @@ var TableFunctionStatisticsParamsSchema = schema2([
   field2("request", binary2(), false)
 ]);
 
+// src/generated/vgi-protocol-types.ts
+var decodeCatalogContentsResponse = (b) => decodeASD(CatalogContentsResultSchema, b);
+
 // src/generated/vgi-client.ts
 var decodeCatalogInfo = (b) => decodeASD(CatalogInfoSchema, b);
 var encodeFunctionInfo = (v) => encodeASD(FunctionInfoSchema, v);
 var decodeFunctionInfo = (b) => decodeASD(FunctionInfoSchema, b);
+var decodeIndexInfo = (b) => decodeASD(IndexInfoSchema, b);
 var encodeMacroInfo = (v) => encodeASD(MacroInfoSchema, v);
 var decodeMacroInfo = (b) => decodeASD(MacroInfoSchema, b);
 var encodeSchemaInfo = (v) => encodeASD(SchemaInfoSchema, v);
@@ -3833,7 +3939,118 @@ class VgiClient {
       global_functions: inner.global_functions ? (Array.isArray(inner.global_functions) ? inner.global_functions : [...inner.global_functions]).map(toUint8Array) : [],
       global_function_prefix: inner.global_function_prefix ?? "",
       resolved_data_version: inner.resolved_data_version ?? null,
-      resolved_implementation_version: inner.resolved_implementation_version ?? null
+      resolved_implementation_version: inner.resolved_implementation_version ?? null,
+      supports_catalog_contents: inner.supports_catalog_contents ?? false
+    };
+  }
+  async catalogContents(attachOpaqueData, ifNoneMatch = null) {
+    const result = await this.rpc.call("catalog_contents", {
+      attach_opaque_data: attachOpaqueData,
+      if_none_match: ifNoneMatch
+    });
+    if (!result)
+      throw new VgiClientError("catalog_contents returned null");
+    const response = decodeCatalogContentsResponse(toUint8Array(result.result));
+    const schemas = response.schemas.map((c) => {
+      const schema = decodeSchemaInfo(c.schema);
+      if (JSON.stringify(c.path) !== JSON.stringify(schema.path)) {
+        throw new VgiClientError(`catalog_contents: SchemaContents.path ${JSON.stringify(c.path)} != SchemaInfo.path ${JSON.stringify(schema.path)}`);
+      }
+      return {
+        schema,
+        tables: c.tables.map(decodeTableInfo),
+        views: c.views.map(decodeViewInfo),
+        scalar_functions: c.scalar_functions.map(decodeFunctionInfo),
+        aggregate_functions: c.aggregate_functions.map(decodeFunctionInfo),
+        table_functions: c.table_functions.map(decodeFunctionInfo),
+        scalar_macros: c.scalar_macros.map(decodeMacroInfo),
+        table_macros: c.table_macros.map(decodeMacroInfo),
+        indexes: c.indexes.map(decodeIndexInfo)
+      };
+    });
+    return {
+      catalog_version: Number(response.catalog_version ?? 0),
+      etag: response.etag ?? null,
+      not_modified: Boolean(response.not_modified),
+      schemas
+    };
+  }
+  async loadCatalog(attach, opts) {
+    const attachOpaqueData = attach.attach_opaque_data;
+    const previous = opts?.previous ?? null;
+    const useContents = attach.supports_catalog_contents === true && opts?.useCatalogContents !== false && opts?.transactionOpaqueData == null;
+    if (!useContents) {
+      return this._loadCatalogPerSchema(attachOpaqueData, opts?.transactionOpaqueData, null);
+    }
+    let fallbackError = null;
+    const ifNoneMatch = previous?.etag ?? null;
+    const knownVersion = previous?.catalog_version ?? 0;
+    for (let attempt = 0;attempt < 2; attempt++) {
+      let response;
+      try {
+        response = await this.catalogContents(attachOpaqueData, ifNoneMatch);
+      } catch (err) {
+        fallbackError = err instanceof Error ? err.message : String(err);
+        break;
+      }
+      if (response.not_modified) {
+        if (previous == null || ifNoneMatch == null) {
+          fallbackError = "catalog_contents answered not_modified to an unconditional request";
+          break;
+        }
+        return {
+          ...previous,
+          catalog_version: response.catalog_version !== 0 ? response.catalog_version : previous.catalog_version,
+          etag: response.etag ?? ifNoneMatch,
+          not_modified: true,
+          fallback_error: null
+        };
+      }
+      if (response.catalog_version !== 0 && knownVersion !== 0 && response.catalog_version < knownVersion) {
+        fallbackError = `catalog_contents snapshot version ${response.catalog_version} is older than the known version ${knownVersion}`;
+        continue;
+      }
+      return {
+        catalog_version: response.catalog_version,
+        etag: response.etag,
+        source: "catalog_contents",
+        not_modified: false,
+        fallback_error: null,
+        schemas: response.schemas
+      };
+    }
+    return this._loadCatalogPerSchema(attachOpaqueData, undefined, fallbackError);
+  }
+  async _loadCatalogPerSchema(attachOpaqueData, transactionOpaqueData, fallbackError) {
+    const schemas = await this.schemas(attachOpaqueData, transactionOpaqueData);
+    const out = [];
+    for (const schema of schemas) {
+      const counts = schema.estimated_object_count ?? {};
+      const path = schema.path;
+      const has = (kind) => {
+        const n = counts[kind];
+        return n == null || Number(n) !== 0;
+      };
+      const t = transactionOpaqueData;
+      out.push({
+        schema,
+        tables: has("table") ? await this.schemaContentsTables(attachOpaqueData, path, t) : [],
+        views: has("view") ? await this.schemaContentsViews(attachOpaqueData, path, t) : [],
+        scalar_functions: has("scalar_function") ? await this.schemaContentsFunctions(attachOpaqueData, path, "SCALAR_FUNCTION", t) : [],
+        aggregate_functions: has("aggregate_function") ? await this.schemaContentsFunctions(attachOpaqueData, path, "AGGREGATE_FUNCTION", t) : [],
+        table_functions: has("table_function") ? await this.schemaContentsFunctions(attachOpaqueData, path, "TABLE_FUNCTION", t) : [],
+        scalar_macros: has("macro") ? await this.schemaContentsMacros(attachOpaqueData, path, "SCALAR_MACRO", t) : [],
+        table_macros: has("macro") ? await this.schemaContentsMacros(attachOpaqueData, path, "TABLE_MACRO", t) : [],
+        indexes: has("index") ? await this.schemaContentsIndexes(attachOpaqueData, path, t) : []
+      });
+    }
+    return {
+      catalog_version: null,
+      etag: null,
+      source: "per_schema",
+      not_modified: false,
+      fallback_error: fallbackError,
+      schemas: out
     };
   }
   async catalogDetach(attachOpaqueData) {
@@ -3974,6 +4191,17 @@ class VgiClient {
     const inner = unwrapResult(result);
     return deserializeInfoList(inner.items, decodeFunctionInfo);
   }
+  async schemaContentsIndexes(attachOpaqueData, path, transactionOpaqueData) {
+    const result = await this.rpc.call("catalog_schema_contents_indexes", {
+      attach_opaque_data: attachOpaqueData,
+      path: normalizeSchemaPath(path),
+      transaction_opaque_data: transactionOpaqueData ?? null
+    });
+    if (!result)
+      return [];
+    const inner = unwrapResult(result);
+    return deserializeInfoList(inner.items, decodeIndexInfo);
+  }
   async tableGet(attachOpaqueData, schemaPath, name, transactionOpaqueData) {
     const result = await this.rpc.call("catalog_table_get", {
       attach_opaque_data: attachOpaqueData,
@@ -4412,4 +4640,4 @@ export {
   typeSignature
 };
 
-//# debugId=8BECE39CB65F6AD764756E2164756E21
+//# debugId=A700197CD6EACFA764756E2164756E21