test(v3): cover 14-block numeric + 12-block timestamptz ORE ordering

Direct comparator tests over generated fixtures: numeric terms are 702 bytes
(N=14) and order across a full 14-value ascending chain spanning sign,
magnitude, and fractional scale (so the left blocks decide ordering — the
regression the missed 9 -> 1+n offset would fail); timestamptz terms are 604
bytes (N=12) and order 1900 < 2099.

Verified end-to-end: numeric + timestamptz ordered matrix suites (211 each,
incl. < <= > >= / ORDER BY / MIN / MAX) green; full SQLx suite 2026 passed;
test:matrix:inventory reconciles both new ordered types; self-contained v3
install green.

Author: tobyhede

tests/sqlx/tests/ore_block_comparator_tests.rs

@@ -50,3 +50,81 @@ async fn comparator_rejects_sixteen_byte_term(pool: PgPool) -> Result<()> {
     );
     Ok(())
 }
+
+/// Width: a numeric ORE term must be 14 blocks => 49*14 + 16 = 702 bytes.
+#[sqlx::test(fixtures(path = "../fixtures", scripts("eql_v2_numeric")))]
+async fn numeric_term_is_14_blocks(pool: PgPool) -> Result<()> {
+    let width: i32 = sqlx::query_scalar(
+        "SELECT octet_length((((eql_v3.ord_term( \
+            (SELECT payload FROM fixtures.eql_v2_numeric WHERE plaintext = (-1000000)::numeric) \
+            ::eql_v3.numeric_ord)).terms)[1]).bytes)",
+    )
+    .fetch_one(&pool)
+    .await?;
+    assert_eq!(width, 702, "numeric ORE term must be 14 blocks (702 bytes)");
+    Ok(())
+}
+
+/// Full ascending chain of 14-block numeric terms: every adjacent pair must
+/// order `-1`. Spans sign, magnitude, and fractional (low-block) scale, so the
+/// left blocks — not just the right blocks — decide ordering. This is the
+/// regression the missed `9 -> 1+n` left-offset would fail; a single pair could
+/// pass against that bug.
+#[sqlx::test(fixtures(path = "../fixtures", scripts("eql_v2_numeric")))]
+async fn numeric_terms_order_in_ascending_chain(pool: PgPool) -> Result<()> {
+    let ascending = [
+        "-1000000000000",
+        "-1000000",
+        "-1.001",
+        "-1",
+        "-0.5",
+        "-0.001",
+        "0",
+        "0.001",
+        "0.5",
+        "0.999999999",
+        "1",
+        "1.001",
+        "1000000",
+        "1000000000000",
+    ];
+    for pair in ascending.windows(2) {
+        let (lo, hi) = (pair[0], pair[1]);
+        let cmp: i32 = sqlx::query_scalar(&format!(
+            "SELECT eql_v3.compare_ore_block_256_terms( \
+                eql_v3.ord_term((SELECT payload FROM fixtures.eql_v2_numeric WHERE plaintext = ({lo})::numeric)::eql_v3.numeric_ord), \
+                eql_v3.ord_term((SELECT payload FROM fixtures.eql_v2_numeric WHERE plaintext = ({hi})::numeric)::eql_v3.numeric_ord))"
+        ))
+        .fetch_one(&pool)
+        .await?;
+        assert_eq!(cmp, -1, "{lo} must order before {hi}");
+    }
+    Ok(())
+}
+
+/// Symmetric 12-block (timestamptz, N=12 => 604 bytes) width + ordering check.
+/// 12 is the only N strictly between the working 8 and the headline 14.
+#[sqlx::test(fixtures(path = "../fixtures", scripts("eql_v2_timestamptz")))]
+async fn timestamptz_term_is_12_blocks_and_orders(pool: PgPool) -> Result<()> {
+    let width: i32 = sqlx::query_scalar(
+        "SELECT octet_length((((eql_v3.ord_term( \
+            (SELECT payload FROM fixtures.eql_v2_timestamptz WHERE plaintext = '1970-01-01T00:00:00Z'::timestamptz) \
+            ::eql_v3.timestamptz_ord)).terms)[1]).bytes)",
+    )
+    .fetch_one(&pool)
+    .await?;
+    assert_eq!(
+        width, 604,
+        "timestamptz ORE term must be 12 blocks (604 bytes)"
+    );
+
+    let cmp: i32 = sqlx::query_scalar(
+        "SELECT eql_v3.compare_ore_block_256_terms( \
+            eql_v3.ord_term((SELECT payload FROM fixtures.eql_v2_timestamptz WHERE plaintext = '1900-01-01T00:00:00Z'::timestamptz)::eql_v3.timestamptz_ord), \
+            eql_v3.ord_term((SELECT payload FROM fixtures.eql_v2_timestamptz WHERE plaintext = '2099-12-31T23:59:59Z'::timestamptz)::eql_v3.timestamptz_ord))",
+    )
+    .fetch_one(&pool)
+    .await?;
+    assert_eq!(cmp, -1, "1900 must order before 2099");
+    Ok(())
+}