Merge pull request #34 from sphildreth/sph-2026-02-21.02

Sph 2026 02 21.02

Author: sphildreth

benchmarks/embedded_compare/assets/decentdb-benchmarks.png

@@ -1,16 +1,16 @@
 {
   "engines": {
     "DecentDB": {
-      "commit_p95_ms": 3.021554,
-      "insert_rows_per_sec": 1108156.028368794,
-      "join_p95_ms": 0.486754,
-      "read_p95_ms": 0.001663
+      "commit_p95_ms": 3.01407,
+      "insert_rows_per_sec": 1109262.340543539,
+      "join_p95_ms": 0.366649,
+      "read_p95_ms": 0.001212
     },
     "DuckDB": {
-      "commit_p95_ms": 11.964168,
-      "insert_rows_per_sec": 10717.36695728593,
-      "join_p95_ms": 1.28361,
-      "read_p95_ms": 0.197822
+      "commit_p95_ms": 11.938741,
+      "insert_rows_per_sec": 10514.98174599169,
+      "join_p95_ms": 1.805541,
+      "read_p95_ms": 0.204874
     },
     "H2": {
       "read_p95_ms": 0.01785111746
@@ -20,17 +20,17 @@
       "read_p95_ms": 0.018636946209999998
     },
     "SQLite": {
-      "commit_p95_ms": 3.021293,
-      "insert_rows_per_sec": 1108893.324462187,
-      "join_p95_ms": 0.383901,
-      "read_p95_ms": 0.001974
+      "commit_p95_ms": 3.017577,
+      "insert_rows_per_sec": 1110987.668036885,
+      "join_p95_ms": 0.39961,
+      "read_p95_ms": 0.002304
     }
   },
   "metadata": {
     "durability_profile": "safe",
     "machine": "batman (AMD Ryzen 9 3900X 12-Core Processor)",
     "notes": "Generated from raw benchmark outputs in benchmarks/embedded_compare/raw/sample; merged extra engines from benchmarks/python_embedded_compare/out/results_merged.json",
-    "run_id": "20260215_230240",
+    "run_id": "20260221_202357",
     "units": {
       "commit_p95_ms": "ms (lower is better)",
       "insert_rows_per_sec": "rows/sec (higher is better)",

benchmarks/embedded_compare/assets/decentdb-benchmarks.svg

@@ -25,7 +25,7 @@ public DecentDBNodaTimeTypeMappingSource(
         var longMapping = new LongTypeMapping("INTEGER", DbType.Int64);
         var floatMapping = new FloatTypeMapping("REAL", DbType.Single);
         var doubleMapping = new DoubleTypeMapping("REAL", DbType.Double);
-        var decimalMapping = new DecimalTypeMapping("DECIMAL", DbType.Decimal, precision: null, scale: null);
+        var decimalMapping = new DecimalTypeMapping("DECIMAL(18,4)", DbType.Decimal, precision: 18, scale: 4);
         var stringMapping = new StringTypeMapping("TEXT", DbType.String);
         var blobMapping = new ByteArrayTypeMapping("BLOB", DbType.Binary);
 
@@ -155,6 +155,11 @@ public DecentDBNodaTimeTypeMappingSource(
         var clrType = Nullable.GetUnderlyingType(mappingInfo.ClrType ?? typeof(object)) ?? mappingInfo.ClrType;
         if (clrType != null && _clrMappings.TryGetValue(clrType, out var clrMapping))
         {
+            if (clrType == typeof(decimal))
+            {
+                return CreateDecimalMapping(mappingInfo, mappingInfo.StoreTypeName);
+            }
+
             return clrMapping;
         }
 
@@ -164,13 +169,66 @@ public DecentDBNodaTimeTypeMappingSource(
             var normalized = NormalizeStoreTypeName(storeType);
             if (_storeMappings.TryGetValue(normalized, out var storeMapping))
             {
+                if (normalized is "DECIMAL" or "NUMERIC")
+                {
+                    return CreateDecimalMapping(mappingInfo, mappingInfo.StoreTypeName ?? storeType);
+                }
+
                 return storeMapping;
             }
         }
 
         return null;
     }
 
+    private static DecimalTypeMapping CreateDecimalMapping(
+        in RelationalTypeMappingInfo mappingInfo,
+        string? storeTypeName)
+    {
+        const int defaultPrecision = 18;
+        const int defaultScale = 4;
+
+        var precision = mappingInfo.Precision;
+        var scale = mappingInfo.Scale;
+
+        if (!precision.HasValue && !scale.HasValue && !string.IsNullOrWhiteSpace(storeTypeName))
+        {
+            (precision, scale) = ParsePrecisionScale(storeTypeName);
+        }
+
+        var p = precision ?? defaultPrecision;
+        var s = scale ?? defaultScale;
+
+        return new DecimalTypeMapping($"DECIMAL({p},{s})", DbType.Decimal, precision: p, scale: s);
+    }
+
+    private static (int? precision, int? scale) ParsePrecisionScale(string storeTypeName)
+    {
+        var openParen = storeTypeName.IndexOf('(');
+        var closeParen = storeTypeName.IndexOf(')');
+        if (openParen < 0 || closeParen <= openParen)
+        {
+            return (null, null);
+        }
+
+        var inner = storeTypeName.AsSpan()[(openParen + 1)..closeParen];
+        var commaIdx = inner.IndexOf(',');
+
+        if (commaIdx >= 0
+            && int.TryParse(inner[..commaIdx].Trim(), out var p)
+            && int.TryParse(inner[(commaIdx + 1)..].Trim(), out var s))
+        {
+            return (p, s);
+        }
+
+        if (int.TryParse(inner.Trim(), out var pOnly))
+        {
+            return (pOnly, null);
+        }
+
+        return (null, null);
+    }
+
     private static string NormalizeStoreTypeName(string storeTypeName)
     {
         var idx = storeTypeName.IndexOf('(');

benchmarks/embedded_compare/data/bench_summary.json

@@ -1,4 +1,4 @@
-version       = "1.2.0"
+version       = "1.3.0"
 author        = "DecentDB contributors"
 description   = "DecentDB engine"
 license       = "Apache-2.0"

bindings/dotnet/src/DecentDB.EntityFrameworkCore.NodaTime/Storage/Internal/DecentDBNodaTimeTypeMappingSource.cs

@@ -5,6 +5,16 @@ All notable changes to DecentDB will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2026-02-21
+
+### Added
+- **SQL Engine**: Hex blob literal (`X'DEADBEEF'`) syntax support — new `svBlob` value kind parsed from libpg_query `bsval` nodes, with full support across parser, binder, executor, EXPLAIN output, and storage predicate evaluator.
+
+### Fixed
+- **SQL Engine**: Self-referencing foreign keys — `CREATE TABLE` with a foreign key referencing the same table (e.g., `parent_id REFERENCES self(id)`) now validates against the columns being defined instead of failing with "Table not found".
+- **SQL Engine**: UUID ↔ Blob type coercion — blob literals (e.g., `X'...'` with 16 bytes) are now accepted for UUID columns in INSERT/UPDATE, and vice versa. Previously the binder rejected these with "Type mismatch" despite the runtime already supporting 16-byte blobs as UUIDs.
+- .NET: `DecentDB.EntityFrameworkCore.NodaTime` DECIMAL type mapping now respects precision and scale from EF Core model configuration (e.g., `HasPrecision(18, 6)`). Previously ignored model-specified precision/scale and always emitted `DECIMAL(18,4)`.
+
 ## [1.2.0] - 2026-02-21
 
 ### Added

decentdb.nimble

@@ -1406,6 +1406,8 @@ proc evalLiteral(value: SqlValue): Value =
     for ch in value.strVal:
       bytes.add(byte(ch))
     Value(kind: vkText, bytes: bytes)
+  of svBlob:
+    Value(kind: vkBlob, bytes: value.blobVal)
   of svParam: Value(kind: vkNull)
 
 proc textValue(text: string): Value =
@@ -1633,7 +1635,7 @@ proc valueToSqlLiteral(v: Value): SqlValue =
   of vkText, vkTextOverflow, vkTextCompressed, vkTextCompressedOverflow:
     SqlValue(kind: svString, strVal: valueToString(v))
   of vkBlob, vkBlobOverflow, vkBlobCompressed, vkBlobCompressedOverflow:
-    SqlValue(kind: svString, strVal: valueToString(v))
+    SqlValue(kind: svBlob, blobVal: v.bytes)
 
 proc collectInnerTables(stmt: Statement): seq[string] =
   ## Collect all table names/aliases from a SELECT's FROM clause.

docs/about/changelog.md

@@ -36,6 +36,7 @@ proc renderExpr*(expr: Expr): string =
     of svFloat: $expr.value.floatVal
     of svBool: $expr.value.boolVal
     of svString: "'" & expr.value.strVal.replace("'", "''") & "'"
+    of svBlob: "X'" & expr.value.blobVal.mapIt(it.toHex(2)).join("") & "'"
     of svParam: "$" & $expr.value.paramIndex
   of ekColumn:
     if expr.table.len > 0:

src/exec/exec.nim

@@ -33,6 +33,8 @@ proc literalType(expr: Expr): Option[ColumnType] =
     return some(ctFloat64)
   of svString:
     return some(ctText)
+  of svBlob:
+    return some(ctBlob)
   of svParam:
     return none(ColumnType)
 
@@ -45,7 +47,9 @@ proc checkLiteralType(expr: Expr, expected: ColumnType, columnName: string): Res
       (expected == ctInt64 and actual in {ctBool, ctFloat64}) or
       (expected == ctFloat64 and actual in {ctInt64, ctDecimal}) or
       (expected == ctDecimal and actual in {ctFloat64, ctInt64}) or
-      (expected == ctBool and actual == ctInt64)
+      (expected == ctBool and actual == ctInt64) or
+      (expected == ctUuid and actual == ctBlob) or
+      (expected == ctBlob and actual == ctUuid)
     if not compatible:
       return err[Void](ERR_SQL, "Type mismatch for column", columnName)
   okVoid()
@@ -438,6 +442,7 @@ proc inferExprType(catalog: Catalog, map: Table[string, TableMeta], expr: Expr):
     of svFloat: return ctFloat64
     of svBool: return ctBool
     of svString: return ctText
+    of svBlob: return ctBlob
     else: return ctText
   of ekColumn:
     let res = resolveColumn(map, expr.table, expr.name)
@@ -1796,24 +1801,29 @@ proc bindCreateTable(catalog: Catalog, stmt: Statement): Result[Statement] =
         return err[Statement](ERR_SQL, "ON DELETE SET NULL requires nullable child column", col.name)
       if onUpdate == "SET NULL" and col.notNull:
         return err[Statement](ERR_SQL, "ON UPDATE SET NULL requires nullable child column", col.name)
-      let parentRes = catalog.getTable(col.refTable)
-      if not parentRes.ok:
-        return err[Statement](parentRes.err.code, parentRes.err.message, col.refTable)
+      # Self-referencing FK: validate against the columns being created
+      let isSelfRef = col.refTable == stmt.createTableName
+      let parentColumns = if isSelfRef: tableColumns
+        else:
+          let parentRes = catalog.getTable(col.refTable)
+          if not parentRes.ok:
+            return err[Statement](parentRes.err.code, parentRes.err.message, col.refTable)
+          parentRes.value.columns
       var parentHasColumn = false
-      for parentCol in parentRes.value.columns:
+      for parentCol in parentColumns:
         if parentCol.name == col.refColumn:
           parentHasColumn = true
           break
       if not parentHasColumn:
         return err[Statement](ERR_SQL, "Referenced column not found", col.refTable & "." & col.refColumn)
-      let parentIdx = catalog.getIndexForColumn(col.refTable, col.refColumn, ikBtree, requireUnique = true)
       var isInt64Pk = false
-      for parentCol in parentRes.value.columns:
+      for parentCol in parentColumns:
         if parentCol.name == col.refColumn and parentCol.primaryKey and parentCol.kind == ctInt64:
           isInt64Pk = true
           break
 
-      if not isInt64Pk:
+      if not isInt64Pk and not isSelfRef:
+        let parentIdx = catalog.getIndexForColumn(col.refTable, col.refColumn, ikBtree, requireUnique = true)
         if isNone(parentIdx):
           return err[Statement](ERR_SQL, "Referenced column must be indexed uniquely", col.refTable & "." & col.refColumn)
   if primaryCount > 1:

src/planner/explain.nim

@@ -1,6 +1,7 @@
 import tables
 import json
 import strutils
+import sequtils
 import ../errors
 import ./pg_query_ffi
 
@@ -11,6 +12,7 @@ type SqlValueKind* = enum
   svString
   svBool
   svParam
+  svBlob
 
 type SqlValue* = object
   kind*: SqlValueKind
@@ -19,6 +21,7 @@ type SqlValue* = object
   strVal*: string
   boolVal*: bool
   paramIndex*: int
+  blobVal*: seq[byte]
 
 type ExprKind* = enum
   ekLiteral
@@ -358,6 +361,18 @@ proc parseAConst*(node: JsonNode): Result[Expr] =
       return ok(Expr(kind: ekLiteral, value: SqlValue(kind: svBool, boolVal: boolNode["boolval"].getBool)))
     # pg_query omits boolval field when false (protobuf default); empty object means false.
     return ok(Expr(kind: ekLiteral, value: SqlValue(kind: svBool, boolVal: false)))
+  if nodeHas(node, "bsval"):
+    # Hex blob literal: X'DEADBEEF' → bsval: "xDEADBEEF"
+    let bsNode = node["bsval"]
+    let hexStr = if nodeHas(bsNode, "bsval"): bsNode["bsval"].getStr else: bsNode.getStr
+    var hex = hexStr
+    if hex.len > 0 and (hex[0] == 'x' or hex[0] == 'X'):
+      hex = hex[1..^1]
+    var bytes: seq[byte] = @[]
+    for i in countup(0, hex.len - 1, 2):
+      let pair = if i + 1 < hex.len: hex[i..i+1] else: hex[i..i]
+      bytes.add(byte(parseHexInt(pair)))
+    return ok(Expr(kind: ekLiteral, value: SqlValue(kind: svBlob, blobVal: bytes)))
   err[Expr](ERR_SQL, "Unsupported A_Const")
 
 proc parseColumnRef(node: JsonNode): Result[Expr] =
@@ -1228,6 +1243,8 @@ proc exprToCanonicalSql*(expr: Expr): string =
       quoteSqlString(expr.value.strVal)
     of svBool:
       if expr.value.boolVal: "TRUE" else: "FALSE"
+    of svBlob:
+      "X'" & expr.value.blobVal.mapIt(it.toHex(2)).join("") & "'"
     of svParam:
       "$" & $expr.value.paramIndex
   of ekColumn: