effect-qb 0.20.0 → 0.22.0

package/dist/postgres/metadata.js

@@ -2639,6 +2639,33 @@ var sqliteSpecificDatatypeKeys = [
 ];
 var pickDatatypeConstructors = (module, keys) => Object.fromEntries(keys.map((key2) => [key2, module[key2]]));
 
+// src/internal/custom-sql-renderer.ts
+var renderCustomSql = (node, state, dialect, renderExpression2) => node.strings.map((part, index3) => {
+  const value = node.values[index3];
+  if (value === undefined) {
+    return part;
+  }
+  return part + (TypeId2 in value ? renderExpression2(value, state, dialect) : value.parts.map((segment) => dialect.quoteIdentifier(segment)).join("."));
+}).join("");
+
+// src/internal/window-renderer.ts
+var renderBoundary = (boundary) => {
+  if (boundary === "unboundedPreceding") {
+    return "unbounded preceding";
+  }
+  if (boundary === "currentRow") {
+    return "current row";
+  }
+  if (boundary === "unboundedFollowing") {
+    return "unbounded following";
+  }
+  if ("preceding" in boundary) {
+    return `${boundary.preceding} preceding`;
+  }
+  return `${boundary.following} following`;
+};
+var renderWindowFrame = (frame) => frame.end === undefined ? `${frame.unit} ${renderBoundary(frame.start)}` : `${frame.unit} between ${renderBoundary(frame.start)} and ${renderBoundary(frame.end)}`;
+
 // src/internal/dsl-plan-runtime.ts
 var renderSelectLockMode = (mode) => mode === "update" ? "for update" : "for share";
 var renderMysqlMutationLockMode = (mode, _statement) => {
@@ -3804,8 +3831,9 @@ var normalizeOffsetTime = (value) => {
     return `${formatLocalTime(validDate(value))}Z`;
   }
   const raw = expectString(value, "offset time").trim();
-  if (isValidOffsetTimeString(raw)) {
-    return raw;
+  const canonical = raw.replace(/([+-]\d{2})$/, "$1:00").replace(/([+-]\d{2})(\d{2})$/, "$1:$2");
+  if (isValidOffsetTimeString(canonical)) {
+    return canonical;
   }
   throw new Error("Expected an offset-time value");
 };
@@ -4245,6 +4273,14 @@ var castTargetGroupingKey = (target) => {
 };
 var escapeGroupingText = (value) => value.replace(/\\/g, "\\\\").replace(/,/g, "\\,").replace(/\|/g, "\\|").replace(/=/g, "\\=").replace(/>/g, "\\>");
 var functionCallNameGroupingKey = (name) => escapeGroupingText(name);
+var customSqlGroupingKey = (strings, values) => strings.map((part, index3) => {
+  const value = values[index3];
+  if (value === undefined) {
+    return escapeGroupingText(part);
+  }
+  const rendered = isExpression3(value) ? groupingKeyOfExpression(value) : `identifier:${value.parts.map(escapeGroupingText).join(".")}`;
+  return `${escapeGroupingText(part)}${rendered}`;
+}).join("|");
 var quantifiedComparisonGroupingName = (kind) => kind === "comparisonAny" ? "compareAny" : "compareAll";
 var caseGroupingKey = (branches, fallback) => {
   const typedBranches = branches;
@@ -4326,12 +4362,19 @@ var groupingKeyOfExpression = (expression) => {
       return `collate(${requiredExpressionGroupingKey("collate", ast.value)},${collationGroupingKey(ast.collation)})`;
     case "function":
       return `function(${functionCallNameGroupingKey(ast.name)},${functionCallArgsGroupingKey(ast.args)})`;
+    case "customSql":
+      return `customSql(${customSqlGroupingKey(ast.strings, ast.values)})`;
     case "isNull":
     case "isNotNull":
     case "not":
     case "upper":
     case "lower":
     case "count":
+    case "sum":
+    case "avg":
+    case "abs":
+    case "round":
+    case "negate":
     case "max":
     case "min":
       return `${ast.kind}(${requiredExpressionGroupingKey(ast.kind, ast.value)})`;
@@ -4352,6 +4395,11 @@ var groupingKeyOfExpression = (expression) => {
     case "contains":
     case "containedBy":
     case "overlaps":
+    case "add":
+    case "subtract":
+    case "multiply":
+    case "divide":
+    case "modulo":
       return `${ast.kind}(${requiredBinaryExpressionGroupingKey(ast.kind, ast.left, ast.right)})`;
     case "and":
     case "or":
@@ -4701,6 +4749,15 @@ var renderBinaryExpression = (functionName, operator, left, right, state, dialec
   const [leftExpression, rightExpression] = expectBinaryExpressions(functionName, left, right);
   return `(${renderExpression2(leftExpression, state, dialect)} ${operator} ${renderExpression2(rightExpression, state, dialect)})`;
 };
+var renderNumericExpression = (expression, state, dialect) => {
+  const rendered = renderExpression2(expression, state, dialect);
+  const ast = expression[TypeId3];
+  return dialect.name === "postgres" && ast.kind === "literal" ? `cast(${rendered} as ${renderCastType(dialect, expression[TypeId2].dbType)})` : rendered;
+};
+var renderNumericBinaryExpression = (functionName, operator, left, right, state, dialect) => {
+  const [leftExpression, rightExpression] = expectBinaryExpressions(functionName, left, right);
+  return `(${renderNumericExpression(leftExpression, state, dialect)} ${operator} ${renderNumericExpression(rightExpression, state, dialect)})`;
+};
 var postgresRangeSubtypeByKind = {
   int4range: "int4",
   int8range: "int8",
@@ -5735,6 +5792,8 @@ var renderExpression2 = (expression, state, dialect) => {
       return `(${renderExpression2(expectValueExpression("collate", ast.value), state, dialect)} collate ${renderCollation(ast.collation)})`;
     case "function":
       return renderFunctionCall(ast.name, ast.args, state, dialect);
+    case "customSql":
+      return renderCustomSql(ast, state, dialect, renderExpression2);
     case "eq":
       return renderBinaryExpression("eq", "=", ast.left, ast.right, state, dialect);
     case "neq":
@@ -5747,6 +5806,16 @@ var renderExpression2 = (expression, state, dialect) => {
       return renderBinaryExpression("gt", ">", ast.left, ast.right, state, dialect);
     case "gte":
       return renderBinaryExpression("gte", ">=", ast.left, ast.right, state, dialect);
+    case "add":
+      return renderNumericBinaryExpression("add", "+", ast.left, ast.right, state, dialect);
+    case "subtract":
+      return renderNumericBinaryExpression("subtract", "-", ast.left, ast.right, state, dialect);
+    case "multiply":
+      return renderNumericBinaryExpression("multiply", "*", ast.left, ast.right, state, dialect);
+    case "divide":
+      return renderNumericBinaryExpression("divide", "/", ast.left, ast.right, state, dialect);
+    case "modulo":
+      return renderNumericBinaryExpression("modulo", "%", ast.left, ast.right, state, dialect);
     case "like":
       return renderBinaryExpression("like", "like", ast.left, ast.right, state, dialect);
     case "ilike": {
@@ -5840,6 +5909,16 @@ var renderExpression2 = (expression, state, dialect) => {
       return `lower(${renderExpression2(expectValueExpression("lower", ast.value), state, dialect)})`;
     case "count":
       return `count(${renderExpression2(expectValueExpression("count", ast.value), state, dialect)})`;
+    case "sum":
+      return `sum(${renderNumericExpression(expectValueExpression("sum", ast.value), state, dialect)})`;
+    case "avg":
+      return `avg(${renderNumericExpression(expectValueExpression("avg", ast.value), state, dialect)})`;
+    case "abs":
+      return `abs(${renderNumericExpression(expectValueExpression("abs", ast.value), state, dialect)})`;
+    case "round":
+      return `round(${renderNumericExpression(expectValueExpression("round", ast.value), state, dialect)})`;
+    case "negate":
+      return `(-${renderNumericExpression(expectValueExpression("negate", ast.value), state, dialect)})`;
     case "max":
       return `max(${renderExpression2(expectValueExpression("max", ast.value), state, dialect)})`;
     case "min":
@@ -5885,23 +5964,43 @@ var renderExpression2 = (expression, state, dialect) => {
     case "window": {
       const partitionBy = ast.partitionBy;
       const orderBy = ast.orderBy;
-      const clauses = [];
-      if (partitionBy.length > 0) {
-        clauses.push(`partition by ${partitionBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
-      }
-      if (orderBy.length > 0) {
-        clauses.push(`order by ${orderBy.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
-      }
-      const specification = clauses.join(" ");
+      const renderSpecification = () => {
+        const clauses = [];
+        if (partitionBy.length > 0) {
+          clauses.push(`partition by ${partitionBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
+        }
+        if (orderBy.length > 0) {
+          clauses.push(`order by ${orderBy.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
+        }
+        if (ast.frame !== undefined) {
+          clauses.push(renderWindowFrame(ast.frame));
+        }
+        return clauses.join(" ");
+      };
       switch (ast.function) {
         case "rowNumber":
-          return `row_number() over (${specification})`;
+          return `row_number() over (${renderSpecification()})`;
         case "rank":
-          return `rank() over (${specification})`;
+          return `rank() over (${renderSpecification()})`;
         case "denseRank":
-          return `dense_rank() over (${specification})`;
+          return `dense_rank() over (${renderSpecification()})`;
         case "over":
-          return `${renderExpression2(ast.value, state, dialect)} over (${specification})`;
+          return `${renderExpression2(ast.value, state, dialect)} over (${renderSpecification()})`;
+        case "lag":
+        case "lead": {
+          const args = [renderExpression2(ast.value, state, dialect)];
+          if (ast.offset !== undefined) {
+            args.push(renderExpression2(ast.offset, state, dialect));
+          }
+          if (ast.defaultValue !== undefined) {
+            args.push(renderExpression2(ast.defaultValue, state, dialect));
+          }
+          return `${ast.function}(${args.join(", ")}) over (${renderSpecification()})`;
+        }
+        case "firstValue":
+          return `first_value(${renderExpression2(ast.value, state, dialect)}) over (${renderSpecification()})`;
+        case "lastValue":
+          return `last_value(${renderExpression2(ast.value, state, dialect)}) over (${renderSpecification()})`;
       }
       break;
     }