@graffy/clickhouse 0.17.9-alpha.1

package/index.cjs

@@ -0,0 +1,724 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@graffy/common");
+const client = require("@clickhouse/client");
+function quoteIdent(name) {
+  const ident = String(name).replace(/`/g, "``");
+  return `\`${ident}\``;
+}
+function literal(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (typeof value === "boolean") return value ? "1" : "0";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw Error("clickhouse.invalid_number");
+    return String(value);
+  }
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) {
+    return `(${value.map((item) => literal(item)).join(", ")})`;
+  }
+  if (typeof value === "object") {
+    return literal(JSON.stringify(value));
+  }
+  const escaped = String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return `'${escaped}'`;
+}
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && value.constructor === Object;
+}
+function isStringishType(type) {
+  return type === "String" || type === "Nullable(String)";
+}
+function getLookup(prop, options) {
+  const [root, ...suffix] = prop.split(".");
+  const types = options?.schema?.types || {};
+  const type = types[root];
+  if (!type) {
+    throw Error(`clickhouse.no_column ${root}`);
+  }
+  const rootExpr = quoteIdent(root);
+  if (!suffix.length) {
+    return {
+      root,
+      suffix,
+      type,
+      isJsonPath: false,
+      rootExpr,
+      orderExpr: rootExpr,
+      textExpr: type === "String" || type === "Nullable(String)" ? `ifNull(${rootExpr}, '')` : `toString(${rootExpr})`,
+      rawExpr: rootExpr,
+      numericExpr: `toFloat64OrZero(${rootExpr})`
+    };
+  }
+  const pathArgs = suffix.map((seg) => literal(seg)).join(", ");
+  const jsonExpr = `ifNull(${rootExpr}, '{}')`;
+  const textExpr = `JSONExtractString(${jsonExpr}, ${pathArgs})`;
+  return {
+    root,
+    suffix,
+    type,
+    isJsonPath: true,
+    rootExpr,
+    orderExpr: textExpr,
+    textExpr,
+    rawExpr: `JSONExtractRaw(${jsonExpr}, ${pathArgs})`,
+    numericExpr: `toFloat64OrZero(${textExpr})`
+  };
+}
+const valid = {
+  $eq: true,
+  $lt: true,
+  $gt: true,
+  $lte: true,
+  $gte: true,
+  $re: true,
+  $ire: true,
+  $text: true,
+  $and: true,
+  $or: true,
+  $any: true,
+  $all: true,
+  $has: true,
+  $cts: true,
+  $ctd: true,
+  $keycts: true,
+  $keyctd: true
+};
+const inverse = {
+  $eq: "$neq",
+  $neq: "$eq",
+  $in: "$nin",
+  $nin: "$in",
+  $lt: "$gte",
+  $gte: "$lt",
+  $gt: "$lte",
+  $lte: "$gt"
+};
+function getAst(filter) {
+  return simplify(construct(filter));
+}
+function isValidSubQuery(node) {
+  if (!node || typeof node !== "object") return false;
+  const keys = Object.keys(node);
+  for (const key of keys) {
+    if (key[0] === "$" && !["$and", "$or", "$not"].includes(key)) return false;
+    if (key[0] !== "$") return true;
+  }
+  for (const key in node) {
+    if (!isValidSubQuery(node[key])) return false;
+  }
+  return true;
+}
+function construct(node, prop, op) {
+  if (!node || typeof node !== "object" || prop && op) {
+    if (op && prop) return [op, prop, node];
+    if (prop) return ["$eq", prop, node];
+    throw Error(`clickhouse_ast.expected_prop_before:${JSON.stringify(node)}`);
+  }
+  if (Array.isArray(node)) {
+    return ["$or", node.map((item) => construct(item, prop, op))];
+  }
+  if (prop && isValidSubQuery(node)) {
+    return ["$sub", prop, construct(node)];
+  }
+  return [
+    "$and",
+    Object.entries(node).map(([key, val]) => {
+      if (key === "$or" || key === "$and") {
+        return [key, construct(val, prop, op)[1]];
+      }
+      if (key === "$not") {
+        return [key, construct(val, prop, op)];
+      }
+      if (key[0] === "$") {
+        if (!valid[key]) throw Error(`clickhouse_ast.invalid_op:${key}`);
+        if (op) throw Error(`clickhouse_ast.unexpected_op:${op} before:${key}`);
+        if (!prop) throw Error(`clickhouse_ast.expected_prop_before:${key}`);
+        return construct(val, prop, key);
+      }
+      return construct(val, key);
+    })
+  ];
+}
+function simplify(node) {
+  const op = node[0];
+  if (op === "$and" || op === "$or") {
+    node[1] = node[1].map((subnode) => simplify(subnode));
+  } else if (op === "$not") {
+    node[1] = simplify(node[1]);
+  } else if (op === "$sub") {
+    node[2] = simplify(node[2]);
+  }
+  if (op === "$and") {
+    if (!node[1].length) return true;
+    if (node[1].includes(false)) return false;
+    node[1] = node[1].filter((item) => item !== true);
+  } else if (op === "$or") {
+    if (!node[1].length) return false;
+    if (node[1].includes(true)) return true;
+    node[1] = node[1].filter((item) => item !== false);
+  } else if (op === "$not" && typeof node[1] === "boolean") {
+    return !node[1];
+  }
+  if (op === "$or") {
+    const { eqmap, noneq, change } = node[1].reduce(
+      (acc, item) => {
+        if (item[0] !== "$eq" || item[2] === null) {
+          acc.noneq.push(item);
+        } else if (acc.eqmap[item[1]]) {
+          acc.change = true;
+          acc.eqmap[item[1]].push(item[2]);
+          return acc;
+        } else {
+          acc.eqmap[item[1]] = [item[2]];
+        }
+        return acc;
+      },
+      { eqmap: {}, noneq: [], change: false }
+    );
+    if (change) {
+      node[1] = [
+        ...noneq,
+        ...Object.entries(eqmap).map(
+          ([prop, val]) => val.length > 1 ? ["$in", prop, val] : ["$eq", prop, val[0]]
+        )
+      ];
+    }
+  }
+  if ((op === "$and" || op === "$or") && node[1].length === 1) {
+    return node[1][0];
+  }
+  if (op === "$not") {
+    const [subop, ...subargs] = node[1];
+    const invop = inverse[subop];
+    return invop ? [invop, ...subargs] : node;
+  }
+  return node;
+}
+function getTableSql$1({ database = "default", table, final = true }) {
+  const tableSql = `${quoteIdent(database)}.${quoteIdent(table)}`;
+  return final ? `${tableSql} FINAL` : tableSql;
+}
+function getNullCheckSql(lookup, op) {
+  if (lookup.isJsonPath) {
+    const missingExpr = `isNull(nullIf(${lookup.rawExpr}, ''))`;
+    return op === "$eq" ? missingExpr : `NOT (${missingExpr})`;
+  }
+  return op === "$eq" ? `isNull(${lookup.rawExpr})` : `NOT isNull(${lookup.rawExpr})`;
+}
+function getRegexSql(lookup, op, value) {
+  const pattern = literal(String(value));
+  if (op === "$ire") {
+    return `match(${lookup.textExpr}, concat('(?i)', ${pattern}))`;
+  }
+  return `match(${lookup.textExpr}, ${pattern})`;
+}
+function getInSql(lookup, op, value, type) {
+  const values = value.filter((item) => item !== null);
+  const hasNull = values.length !== value.length;
+  const lhs = lookup.isJsonPath || isStringishType(type) ? lookup.textExpr : lookup.rawExpr;
+  const inExpr = values.length ? `${lhs} IN (${values.map((item) => literal(item)).join(", ")})` : null;
+  const nullExpr = hasNull ? getNullCheckSql(lookup, "$eq") : null;
+  if (op === "$in") {
+    if (inExpr && nullExpr) return `(${inExpr} OR ${nullExpr})`;
+    if (inExpr) return inExpr;
+    return nullExpr || "0";
+  }
+  if (inExpr && nullExpr) return `NOT (${inExpr} OR ${nullExpr})`;
+  if (inExpr) return `NOT (${inExpr})`;
+  return nullExpr ? `NOT (${nullExpr})` : "1";
+}
+function getCtsSql(lookup, value) {
+  if (Array.isArray(value) && value.every((item) => isPlainObject(item))) {
+    return value.map((needle) => {
+      const conditions = Object.entries(needle).map(
+        ([k, v]) => `JSONExtractRaw(item, ${literal(k)}) = ${literal(JSON.stringify(v))}`
+      );
+      return `arrayExists(item -> (${conditions.join(" AND ")}), JSONExtractArrayRaw(ifNull(${lookup.rootExpr}, '[]')))`;
+    }).join(" AND ");
+  }
+  if (isPlainObject(value)) {
+    const checks = Object.entries(value).map(
+      ([k, v]) => `JSONExtractRaw(ifNull(${lookup.rootExpr}, '{}'), ${literal(k)}) = ${literal(JSON.stringify(v))}`
+    );
+    return checks.join(" AND ");
+  }
+  return `positionUTF8(ifNull(${lookup.rootExpr}, ''), ${literal(JSON.stringify(value))}) > 0`;
+}
+function getSimpleBinarySql(lookup, op, value) {
+  const opSql = {
+    $eq: "=",
+    $neq: "!=",
+    $lt: "<",
+    $lte: "<=",
+    $gt: ">",
+    $gte: ">="
+  }[op];
+  if (!opSql) throw Error(`clickhouse.getSql_unknown_operator ${op}`);
+  const lhs = lookup.isJsonPath ? typeof value === "string" ? lookup.textExpr : lookup.numericExpr : lookup.rawExpr;
+  return `${lhs} ${opSql} ${literal(value)}`;
+}
+function getBinarySql(node, options) {
+  const [op, prop, value] = node;
+  const lookup = getLookup(prop, options);
+  const type = lookup.type;
+  if (value === null && (op === "$eq" || op === "$neq")) {
+    return getNullCheckSql(lookup, op);
+  }
+  if (op === "$in" || op === "$nin") {
+    return getInSql(lookup, op, value, type);
+  }
+  if (op === "$re" || op === "$ire") {
+    return getRegexSql(lookup, op, value);
+  }
+  if (op === "$cts") {
+    return getCtsSql(lookup, value);
+  }
+  if (op === "$ctd" || op === "$keycts" || op === "$keyctd") {
+    throw Error(`clickhouse.unsupported_operator ${op}`);
+  }
+  return getSimpleBinarySql(lookup, op, value);
+}
+function getNodeSql(ast, options) {
+  if (typeof ast === "boolean") return ast ? "1" : "0";
+  const [op] = ast;
+  if (op === "$and" || op === "$or") {
+    const delim = op === "$and" ? " AND " : " OR ";
+    return `(${ast[1].map((node) => getNodeSql(node, options)).join(delim)})`;
+  }
+  if (op === "$not") {
+    return `NOT (${getNodeSql(ast[1], options)})`;
+  }
+  if (op === "$sub") {
+    const joinName = ast[1];
+    const joinOptions = options.joins?.[joinName];
+    if (!joinOptions) throw Error(`clickhouse.no_join ${joinName}`);
+    const where = [];
+    if (joinOptions.final !== false && joinOptions.schema?.types?._sign) {
+      where.push("`_sign` = 1");
+    }
+    where.push(getNodeSql(ast[2], joinOptions));
+    const rootIdCol = quoteIdent(options.idCol);
+    const joinRefCol = quoteIdent(joinOptions.refCol);
+    return `${rootIdCol} IN (SELECT ${joinRefCol} FROM ${getTableSql$1(joinOptions)} WHERE ${where.join(" AND ")})`;
+  }
+  return getBinarySql(ast, options);
+}
+function getFilterSql(filter, options) {
+  const ast = getAst(filter);
+  return getNodeSql(ast, options);
+}
+const MAX_LIMIT = 4096;
+function getBoundCond(boundCols, bound, kind) {
+  if (!Array.isArray(bound) || !bound.length || boundCols.length !== bound.length) {
+    throw Error(`clickhouse_arg.bad_query bound:${JSON.stringify(bound)}`);
+  }
+  const lhs = `(${boundCols.join(", ")})`;
+  const rhs = `(${bound.map((item) => literal(item)).join(", ")})`;
+  switch (kind) {
+    case "$after":
+      return `${lhs} > ${rhs}`;
+    case "$since":
+      return `${lhs} >= ${rhs}`;
+    case "$before":
+      return `${lhs} < ${rhs}`;
+    case "$until":
+      return `${lhs} <= ${rhs}`;
+    default:
+      throw Error(`clickhouse_arg.bad_bound_kind ${kind}`);
+  }
+}
+function getArgSql({ $first, $last, $after, $before, $since, $until, $all, $cursor: _, ...rest }, options) {
+  const { $order, $group, ...filter } = rest;
+  const groupSpec = $group === true ? true : Array.isArray($group) && $group.length ? $group : null;
+  const hasRangeArg = !!($before || $after || $since || $until || $first || $last || $all);
+  if ($order && $group) {
+    throw Error("clickhouse_arg.order_and_group_unsupported");
+  }
+  if (($order || $group && $group !== true) && !hasRangeArg) {
+    throw Error("clickhouse_arg.range_arg_expected");
+  }
+  const where = [];
+  if (options.final !== false && options.schema?.types?._sign) {
+    where.push("`_sign` = 1");
+  }
+  if (!common.isEmpty(filter)) where.push(getFilterSql(filter, options));
+  if (!hasRangeArg) {
+    return {
+      where,
+      limit: groupSpec ? 1 : 2,
+      orderSpec: groupSpec && groupSpec !== true ? groupSpec : [options.idCol],
+      order: null,
+      groupSpec,
+      ensureSingleRow: !groupSpec,
+      hasRangeArg: false,
+      hasCursor: false,
+      keyBase: rest
+    };
+  }
+  if (groupSpec === true) {
+    return {
+      where,
+      orderSpec: [],
+      order: null,
+      groupSpec,
+      limit: 1,
+      ensureSingleRow: false,
+      hasRangeArg: true,
+      hasCursor: false,
+      keyBase: rest
+    };
+  }
+  const orderSpec = groupSpec || $order || [options.idCol];
+  const boundCols = orderSpec.map((orderItem) => {
+    if (orderItem[0] === "!") {
+      return `-(${getLookup(orderItem.slice(1), options).numericExpr})`;
+    }
+    return getLookup(orderItem, options).orderExpr;
+  });
+  Object.entries({ $after, $before, $since, $until }).forEach(
+    ([kind, value]) => {
+      if (value) where.push(getBoundCond(boundCols, value, kind));
+    }
+  );
+  const order = orderSpec.map((orderItem) => {
+    const desc = orderItem[0] === "!";
+    const prop = desc ? orderItem.slice(1) : orderItem;
+    const lookup = getLookup(prop, options);
+    const direction = desc ? $last ? "ASC" : "DESC" : $last ? "DESC" : "ASC";
+    return `${lookup.orderExpr} ${direction}`;
+  }).join(", ");
+  return {
+    where,
+    orderSpec,
+    order,
+    groupSpec,
+    limit: Math.min(MAX_LIMIT, $first || $last || MAX_LIMIT),
+    ensureSingleRow: false,
+    hasRangeArg: true,
+    hasCursor: true,
+    keyBase: rest
+  };
+}
+const aggOps = {
+  $sum: (lookup) => `sum(${lookup.numericExpr})`,
+  $avg: (lookup) => `avg(${lookup.numericExpr})`,
+  $max: (lookup) => `max(${lookup.numericExpr})`,
+  $min: (lookup) => `min(${lookup.numericExpr})`,
+  $card: (lookup) => `uniqExact(${lookup.rawExpr})`
+};
+const aggOpOrder = ["$sum", "$avg", "$max", "$min", "$card"];
+function getTableSql({ database = "default", table, final = true }) {
+  const tableSql = `${quoteIdent(database)}.${quoteIdent(table)}`;
+  return final ? `${tableSql} FINAL` : tableSql;
+}
+function getAggregateSelectSql(projection, options, groupSpec) {
+  const selectCols = [];
+  const groupExprs = [];
+  const groupAliases = [];
+  const aggregateAliases = {};
+  let aggIx = 0;
+  if (Array.isArray(groupSpec)) {
+    groupSpec.forEach((prop, ix) => {
+      const lookup = getLookup(prop, options);
+      const alias = `__group_${ix}`;
+      selectCols.push(`${lookup.orderExpr} AS ${quoteIdent(alias)}`);
+      groupExprs.push(lookup.orderExpr);
+      groupAliases.push(alias);
+    });
+  }
+  if (projection?.$count) {
+    selectCols.push(`count() AS ${quoteIdent("$count")}`);
+  }
+  aggOpOrder.forEach((op) => {
+    const values = projection?.[op];
+    if (!values || typeof values !== "object") return;
+    Object.keys(values).forEach((prop) => {
+      const alias = `__agg_${aggIx++}`;
+      const lookup = getLookup(prop, options);
+      selectCols.push(`${aggOps[op](lookup)} AS ${quoteIdent(alias)}`);
+      aggregateAliases[alias] = { op, prop };
+    });
+  });
+  if (!selectCols.length) selectCols.push("count() AS `__count`");
+  return {
+    selectSql: selectCols.join(", "),
+    aggregateAliases,
+    groupAliases,
+    groupExprs
+  };
+}
+function selectByArgs(args, projection, options) {
+  const { where, order, limit, groupSpec, ...rest } = getArgSql(args, options);
+  const whereClause = where.length ? ` WHERE ${where.join(" AND ")}` : "";
+  const orderClause = order ? ` ORDER BY ${order}` : "";
+  const wantsAggregate = !!groupSpec || !!projection?.$count || aggOpOrder.some(
+    (op) => projection?.[op] && typeof projection[op] === "object"
+  );
+  if (!wantsAggregate) {
+    return {
+      ...rest,
+      where,
+      order,
+      limit,
+      groupSpec,
+      isAggregate: false,
+      aggregateAliases: {},
+      groupAliases: [],
+      sql: `SELECT * FROM ${getTableSql(options)}${whereClause}${orderClause} LIMIT ${limit}`
+    };
+  }
+  const { selectSql, aggregateAliases, groupAliases, groupExprs } = getAggregateSelectSql(projection, options, groupSpec);
+  const groupClause = groupExprs.length ? ` GROUP BY ${groupExprs.join(", ")}` : "";
+  return {
+    ...rest,
+    where,
+    order,
+    limit,
+    groupSpec,
+    isAggregate: true,
+    aggregateAliases,
+    groupAliases,
+    sql: `SELECT ${selectSql} FROM ${getTableSql(options)}${whereClause}${groupClause}${orderClause} LIMIT ${limit}`
+  };
+}
+function selectByIds(ids, options) {
+  const where = [];
+  if (options.final !== false && options.schema?.types?._sign) {
+    where.push("`_sign` = 1");
+  }
+  where.push(
+    `${quoteIdent(options.idCol)} IN (${ids.map((id) => literal(id)).join(", ")})`
+  );
+  return {
+    sql: `SELECT * FROM ${getTableSql(options)} WHERE ${where.join(" AND ")}`
+  };
+}
+function maybeParseJson(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed) return value;
+  if (trimmed === "null") return null;
+  if (trimmed[0] === "{" && trimmed[trimmed.length - 1] === "}" || trimmed[0] === "[" && trimmed[trimmed.length - 1] === "]") {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function deepCloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function applyAggregateAliases(object, aggregateAliases) {
+  Object.entries(aggregateAliases).forEach(([alias, { op, prop }]) => {
+    if (!(alias in object)) return;
+    if (!object[op] || typeof object[op] !== "object") object[op] = {};
+    object[op][prop] = object[alias];
+    delete object[alias];
+  });
+}
+class Db {
+  constructor(connection) {
+    if (connection?.query && typeof connection.query === "function") {
+      this.client = connection;
+    } else {
+      this.client = client.createClient(connection || {});
+    }
+  }
+  async query(sql) {
+    try {
+      const resultSet = await this.client.query({
+        query: sql,
+        format: "JSONEachRow"
+      });
+      if (Array.isArray(resultSet)) return resultSet;
+      if (resultSet?.data && Array.isArray(resultSet.data))
+        return resultSet.data;
+      if (typeof resultSet?.json === "function") {
+        const rows = await resultSet.json();
+        return Array.isArray(rows) ? rows : [];
+      }
+      return [];
+    } catch (e) {
+      const message = [e?.message, sql].filter(Boolean).join("; ");
+      throw Error(`clickhouse.sql_error ${message}`);
+    }
+  }
+  async ensureSchema(tableOptions) {
+    if (!tableOptions.schema?.types) {
+      const rows = await this.query(`
+        SELECT name, type
+        FROM system.columns
+        WHERE database = ${literal(tableOptions.database || "default")}
+        AND table = ${literal(tableOptions.table)}
+        ORDER BY position
+      `);
+      if (!rows.length) {
+        throw Error(`clickhouse.missing_table ${tableOptions.table}`);
+      }
+      tableOptions.schema = {
+        types: Object.fromEntries(rows.map(({ name, type }) => [name, type]))
+      };
+    }
+    await Promise.all(
+      Object.values(tableOptions.joins || {}).map(
+        (joinOptions) => this.ensureSchema(joinOptions)
+      )
+    );
+  }
+  normalizeRow(row, schema) {
+    const out = {};
+    for (const [key, value] of Object.entries(row)) {
+      const type = schema?.types?.[key];
+      if (value === null || value === void 0) {
+        out[key] = null;
+      } else if (type === "UInt8" || type === "Nullable(UInt8)") {
+        out[key] = Boolean(value);
+      } else if (type === "String" || type === "Nullable(String)") {
+        out[key] = maybeParseJson(value);
+      } else {
+        out[key] = value;
+      }
+    }
+    return out;
+  }
+  getCursorValue(row, orderItem) {
+    const isDesc = orderItem[0] === "!";
+    const prop = isDesc ? orderItem.slice(1) : orderItem;
+    const path = prop.split(".");
+    let value = row[path[0]];
+    for (let i = 1; i < path.length; i += 1) {
+      value = value?.[path[i]];
+    }
+    if (value === void 0) value = null;
+    if (!isDesc || value === null) return value;
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+      throw Error(`clickhouse.cursor_desc_non_numeric ${prop}`);
+    }
+    return -numeric;
+  }
+  async read(rootQuery, tableOptions) {
+    const idQueries = {};
+    const promises = [];
+    const results = [];
+    const { prefix: rawPrefix } = tableOptions;
+    const prefix = common.encodePath(rawPrefix);
+    await this.ensureSchema(tableOptions);
+    const getByArgs = async (args, projection) => {
+      const selection = selectByArgs(args, projection, tableOptions);
+      const rows = await this.query(selection.sql);
+      if (selection.ensureSingleRow && rows.length > 1) {
+        throw Error(`clickhouse.more_than_one_row ${tableOptions.table}`);
+      }
+      const wrappedRows = rows.map((row) => {
+        const object = this.normalizeRow(row, tableOptions.schema);
+        applyAggregateAliases(object, selection.aggregateAliases || {});
+        const key = deepCloneJson(selection.keyBase);
+        if (selection.isAggregate && selection.groupAliases?.length) {
+          key.$cursor = selection.groupAliases.map((alias) => object[alias]);
+        } else if (selection.isAggregate && selection.groupSpec === true && selection.hasRangeArg) {
+          key.$cursor = "";
+        } else if (selection.hasRangeArg && selection.hasCursor) {
+          key.$cursor = selection.orderSpec.map(
+            (orderItem) => this.getCursorValue(object, orderItem)
+          );
+        }
+        (selection.groupAliases || []).forEach((alias) => {
+          delete object[alias];
+        });
+        object.$key = key;
+        object.$ver = object[tableOptions.verCol] ?? object._version ?? null;
+        if (!selection.isAggregate) {
+          object.$ref = [...rawPrefix, object[tableOptions.idCol]];
+        }
+        return object;
+      });
+      common.merge(results, common.encodeGraph(common.wrapObject(wrappedRows, rawPrefix)));
+    };
+    const getByIds = async () => {
+      const selection = selectByIds(Object.keys(idQueries), tableOptions);
+      const rows = await this.query(selection.sql);
+      for (const row of rows) {
+        const object = this.normalizeRow(row, tableOptions.schema);
+        object.$key = object[tableOptions.idCol];
+        object.$ver = object[tableOptions.verCol] ?? object._version ?? null;
+        common.merge(results, common.encodeGraph(common.wrapObject(object, rawPrefix)));
+      }
+    };
+    const query = common.unwrap(rootQuery, prefix);
+    for (const node of query) {
+      const args = common.decodeArgs(node);
+      if (common.isPlainObject(args)) {
+        if (node.prefix) {
+          for (const childNode of node.children) {
+            const childArgs = common.decodeArgs(childNode);
+            const projection = childNode.children ? common.decodeQuery(childNode.children) : null;
+            promises.push(getByArgs({ ...args, ...childArgs }, projection));
+          }
+        } else {
+          const projection = node.children ? common.decodeQuery(node.children) : null;
+          promises.push(getByArgs(args, projection));
+        }
+      } else {
+        idQueries[args] = node.children;
+      }
+    }
+    if (!common.isEmpty(idQueries)) promises.push(getByIds());
+    await Promise.all(promises);
+    return common.finalize(results, common.wrap(query, prefix));
+  }
+}
+function getTableOpts(name, options = {}, parentName = null, parentDefaults = {}) {
+  const { table, idCol, verCol, schema, database, final } = options;
+  const tableName = table || name;
+  const tableDatabase = database || parentDefaults.database || "default";
+  const tableFinal = final ?? parentDefaults.final ?? true;
+  const joins = Object.fromEntries(
+    Object.entries(options.joins || {}).map(([joinName, joinRaw = {}]) => {
+      const { refCol = parentName, ...joinOptions } = joinRaw;
+      return [
+        joinName,
+        {
+          refCol: refCol || parentName || tableName,
+          ...getTableOpts(joinName, joinOptions, tableName, {
+            database: tableDatabase,
+            final: tableFinal
+          })
+        }
+      ];
+    })
+  );
+  return {
+    table: tableName,
+    idCol: idCol || "id",
+    verCol: verCol || "updatedAt",
+    database: tableDatabase,
+    final: tableFinal,
+    schema,
+    joins
+  };
+}
+const clickhouse = (options = {}) => (store) => {
+  const { connection, ...rawOptions } = options;
+  store.on("read", read);
+  const prefix = store.path;
+  const tableOpts = getTableOpts(prefix[prefix.length - 1], rawOptions);
+  tableOpts.prefix = prefix;
+  const defaultDb = new Db(connection);
+  function read(query, _options, next) {
+    const readPromise = defaultDb.read(query, tableOpts);
+    const remainingQuery = common.remove(query, common.encodePath(prefix));
+    const nextPromise = next(remainingQuery);
+    return Promise.all([readPromise, nextPromise]).then(
+      ([readRes, nextRes]) => {
+        return common.merge(readRes, nextRes);
+      }
+    );
+  }
+};
+const ch = clickhouse;
+exports.ch = ch;
+exports.clickhouse = clickhouse;