1.3.0

This in a minor-version release because it includes breaking changes:

• Some previous releases of Doltgres were discovered to have omitted necessary information related to storing adaptive values (TEXT, JSON, others) in row tuples, with the consequence that some values would not be pushed, cloned, backed up, or retained by garbage collection. This error could result in permanent data loss in some cases. It is fixed in this release.
• This release scans every database for this corruption at startup and refuses to start if any rows are affected. Affected customers can run a new tool in cmd/admin to repair any corruption discovered.
• Affected versions: all release before 0.56.3 (May 2026).
• Additionally, adaptive values used in key columns were also missing the same information. This error affected all versions prior to this one.
• Affected column types:
  ** TEXT
  ** VARCHAR (no length)
  ** JSON
  ** JSONB
  ** []byte

To summarize, customers may be impacted if they use one of the above column types, AND:

• They have rows written by a version prior to 0.56.3, OR
• They use one of the above types in a key column

Impacted customers SHOULD NOT run the dolt_gc() procedure on any prior release of Doltgres, as it could result in permanent data loss. Upgrade to this release as soon as possible.

Merged PRs

dolt

• 11611: Resolve predicates before partial index backfill
  Resolve partial-index predicates against the actual table schema before evaluating them while backfilling an index over existing rows. This prevents planner-relative field ordinals from being evaluated against stored table rows.
  Part of dolthub/doltgresql#3100
• 11610: go/libraries/doltcore/env, sqle: handle duplicate database directories
  Log warning to skip duplicate database folders when scanning for databases to prevent overwriting an existing database.
  • Add shared warning helper that logs duplicate database.
  • Check active databases before clone or create operations.
    Fix dolthub/dolt#10143
    Close dolthub/dolt#10678
• 11607: dbfactory: git remotes with more flexible cache dir name
  Enable DumboDB to use git* remotes, but under a different cache directory, that doesn't include .dolt
• 11606: tracking field so that adaptive encoded keys work with garbage collection, push, etc
  New field in prolly.fbs to account for address values in keys. Doltgres permits this; Dolt does not (always requires prefixes for long keys). This gap would cause any key values stored out of band in Doltgres to be garbage collected inappropriately, as well as fail to be pushed.
• 11604: go: sqle/expranalysis: Have ResolveExpression take a schema-qualified TableName.
  Allows for fixing some partial-index creation failures in doltgres.
• 11598: feat: add orcarouter provider to dolt assist
  The dolt assist command is Dolt's chat assistant for running dolt commands and queries in plain language. This PR adds a named OrcaRouter provider via --provider orcarouter, mirroring the existing OpenAI wiring: it reads ORCAROUTER_API_KEY, targets https://api.orcarouter.ai/v1/chat/completions, and defaults to the orcarouter/auto model. OrcaRouter is an OpenAI-compatible AI gateway built for both models and agents — like OpenRouter it exposes a provider/model namespace across many models, but also combines adaptive routing, automatic failover, zero-markup inference, observability, guardrails, and agent-tool governance behind the same endpoint, so Dolt users can use that stack without treating it as an anonymous base URL. It also runs gateway-level, zero-trust security for AI agents on the same endpoint — screening every prompt/response and governing every tool call on a default-deny basis, with no application code changes. OpenAI stays the default; no behavior change. I also fixed a pre-existing bug in getJsonPrompt that emitted a leading comma (invalid JSON) on the first request.
  Verification: go build + go vet pass, gofmt clean, live-tested --provider orcarouter against OrcaRouter (200). go test ./cmd/dolt/commands/ passes; the only failure is pre-existing TestSignAndVerifyCommit (needs gpg, not installed here).
  Discord: discord.gg/YEubt8enRA · X: https://x.com/OrcaRouter
  I'm an engineer on the OrcaRouter team.
• 11597: Fix duplicate key errors with expression indexes
  Sizes reconstructed rows from mapped SQL ordinals so system-hidden expression-index columns cannot leave out-of-range gaps after schema changes. Covers keyed and keyless tables across duplicate errors, ignored inserts, and duplicate-key updates.
  Supports doltgresql #3082.
• 11596: Fix macOS-only bats CI failures
  Fixes the long-standing macOS-only bats CI failures (verified: 38 → 0 failures across two full nightly-workflow runs).
  • Skip docker-entrypoint.bats/tzdata.bats for MacOS (no docker available on PATH in MacOS runners)
  • Fix BSD awk/grep incompatibilities in sql-diff.bash and GNU-only sed -i in sql-pull.bats
  • Disable the detached dolt send-metrics process during bats runs (raced with test teardown cleanup)
  • Default DOLT_PAGER=cat (less races with expect scripts typing ahead, dropping keystrokes)
• 11594: Added extended vector index support
  This adds support for extended vector index support for Doltgres. Builds on top of:
  • dolthub/go-mysql-server#3724
• 11593: go: clone: Make clone use the same semantics on srcDB as fetch. Open without caching and close when finished with it.
• 11585: Fix auto-increment tracker init race
  NewSequenceTrackerFromRoots initializes sequence state in a background goroutine but ran it on the caller's request-scoped context, so it could be canceled as soon as the triggering query (e.g. CREATE DATABASE) returned, poisoning the tracker for later callers. Detach that goroutine's context from the caller's cancellation, and add a deterministic regression test.
• 11582: go: Add cleanup of the created directory on some database creation failure paths.
• 11580: Fix FK lookup during table rename
  UpdateForeignKey was looking up the existing foreign key using the new table name passed in the constraint, but go-mysql-server calls it during a rename before the table has actually been renamed. This lookup only matters (and only broke) for schema-qualified engines like Doltgres, since plain Dolt's foreign key lookups ignore table name when schema is empty. Fixed by looking up using the table's current name, and added a regression test that reproduces the mid-rename state directly against WritableDoltTable.UpdateForeignKey.
  Related to: #3114
• 11577: Fix a race in SequenceTracker.InitWithRoots
  Concurrent dolt_reset or dolt_checkout calls from different sessions against the same database could race inside SequenceTracker.InitWithRoots, with two overlapping calls both ending up closing the same completion channel and crashing the whole server process. This PR serializes InitWithRoots with a mutex and has each async init close a captured channel reference instead of the mutable field. Also adds a unit test that reproduces the panic against the old code and passes clean under -race against the fix.
• 11576: dumbo: expose session operations
• 11571: user contribution: s3 remote support
  Original PR: dolthub/dolt#11433
  Fixes: dolthub/dolt#509
  Documentation Change: dolthub/docs-2#174
• 11569: build(deps): upgrade Hibernate to 6.6.55
• 11568: build(deps): bump undici to 6.28.0
• 11567: /.github/workflows: pin add-and-commit
• 11556: archives: parallelize/coalesce chunk fetches
  There are a fair number of unit tests are added, but I've also had this verified by the user that raised the issue initially. Local testing with some added trace further convinced me this works as expected.
• 11537: backup: stop writing the working set on sync
  dolt_backup no longer commits the calling session's open transaction before it copies.
  • Syncing an idle database leaves the backup unchanged.
  • ROLLBACK after sync now works correctly.
    Fix dolthub/dolt#11488
• 11433: Add s3:// remote scheme for generic S3-compatible object stores (#509)
• 11335: Bump google.golang.org/grpc from 1.79.3 to 1.82.1 in /go
• 11271: Bump golang.org/x/image from 0.38.0 to 0.41.0 in /go
• 11022: build(deps): bump fast-xml-builder from 1.1.5 to 1.2.0 in /.github/actions/ses-email-action
  Bumps fast-xml-builder from 1.1.5 to 1.2.0.

doltgresql

• 3220: Support a RECORD variable as the INTO target of a plpgsql statement
  SELECT ... INTO r where r is declared RECORD failed at CREATE FUNCTION time with unhandled datum type: plpgsql.datum: the INTO target arrives as a PLpgSQL_rec, and the three conversion sites (SELECT, EXECUTE, CALL) accepted only PLpgSQL_row and PLpgSQL_var.
  Unlike a row target, a record has no shape of its own — it takes the shape of whatever is assigned to it — so it cannot be expressed as the existing comma-separated list of scalar variables. Two opcodes are added for it:
  • OpCode_DeclareRecord declares a shapeless record when its block is entered. Records previously existed only on the compile-time stack, so a record was never actually present at runtime; the one existing FOR..IN..SELECT test loops over an empty result and so never assigned one.
  • OpCode_ExecuteInto runs a statement and assigns its first result row, with the query's output columns as the record's schema. As in Postgres without STRICT, extra rows are discarded and no rows at all leaves every field NULL.
    Record field lookup gains three fixes this exposed: fields are matched by name rather than by name plus the first column's source (a record's columns can come from different tables), quoted field references such as blocker."id" have their quotes stripped, and non-Doltgres result types (from an aggregate such as count(*)) are converted when the schema is stored.
    Reading a field now reports what Postgres reports — record "r" has no field "x" and record "r" is not assigned yet — instead of the generic "variable could not be found", and the two unhandled datum type: %T messages, which could only ever print plpgsql.datum, now name the arms they handle.
• 3219: Preserve the comparison operator when serializing ANY/SOME/ALL
  AnyExpr.String() hardcoded = instead of using the operator the user wrote. Check constraints are persisted as this serialized text and re-parsed on every write, so v <> ALL (ARRAY[...]) was stored and then enforced as v = ALL (ARRAY[...]) — inverting the constraint so it rejected every row. <> ANY was corrupted the same way.
  String() (both the resolved and unresolved branches) and DebugString now render the operator, canonicalized through the operator framework so the parser's != is written as Postgres' <>.
• 3211: Prevent partial indexes from dropping join rows
  Add end-to-end regression coverage for joins that previously treated a partial index as a complete table input, causing silent row loss and incorrect anti-join results. Coverage includes inner, outer, semi, anti, and range predicates plus legitimate predicate-constrained use.
  Also cover partial-index creation after rows already exist and pin the Dolt fix that resolves the predicate against the actual table schema before backfilling the index.
  Fixes #3100
  Depends on:
  • Dolt #11611
  • go-mysql-server #3731
• 3202: Generalize array constructor casts to vector types
  Generalizes PostgreSQL-compatible direct ARRAY[...] constructor casts across oidvector and int2vector, using each vector’s element type and explicit cast context.
  Preserves PostgreSQL’s rejection of general array-expression-to-vector casts and applies domain constraints after vector construction.
  Follow-up to #3177
• 3201: Implement json_agg
  Adds PostgreSQL-compatible json_agg(anyelement) support for scalar, array, composite, JSON, and JSONB values, including window aggregation and DISTINCT with SQL NULLs.
  Part of #3099
  Depends on: dolthub/go-mysql-server#3728
• 3198: Implement jsonb/json inspection functions: typeof, array_length, object_keys, strip_nulls, to_jsonb.
  These all had OIDs registered in the built-in function catalog but no implementation, so calls failed resolution. jsonb_typeof in particular is how Postgres schemas pin the shape of a jsonb column in a CHECK constraint, so a pg_dump carrying one could not be restored, and to_jsonb(OLD)/to_jsonb(NEW) is the standard way to write a generic trigger in plpgsql.
  json_object_keys and jsonb_object_keys are set-returning. Keys come back in jsonb order (shortest first, then bytewise), which is the order our json and jsonb output functions already print them in; Postgres returns json keys in document order, but we parse json into a map, so that ordering is not recoverable.
  The non-array and non-object errors carry SQLSTATE 22023 to match Postgres, and reproduce its distinct wording for the object and scalar cases.
• 3197: Add octet_length, length and bit_length for bytea
  Postgres has octet_length(bytea), length(bytea) and bit_length(bytea); Doltgres implemented only the text and bit string overloads.
  All three return the byte count (times eight for bit_length), obtained through a new framework.UnwrapByteLength helper that takes the length from an out-of-band wrapper when the wrapper knows it exactly, and only materializes the value otherwise. octet_length(text) now uses the same helper. bitStringLength is replaced by the shared lengthToInt32.
  Some large-value integration tests worked around the missing functions by checking lengths client-side; those checks now run in SQL.
• 3196: Implement num_nonnulls and num_nulls.
• 3195: Fix resolving partial index expressions to take table schema into account, instead of current search path.
• 3193: Persist column defaults with schema-qualified type names in explicit casts.
  Storing the name without the schema makes for ambiguous lookups in the future and causes errors in inserts and alter tables.
• 3189: Implement convert_to
  Adds PostgreSQL-compatible convert_to for a curated set of common encodings and aliases. Centralizes encoding names, IDs, aliases, and conversion support so convert_to and pg_char_to_encoding remain consistent.
  Distinguishes invalid encoding names, recognized but unsupported encodings, and untranslatable characters with the appropriate SQLSTATEs and actionable errors.
  Part of #3099.
• 3188: Implement hashtext
  Adds PostgreSQL-compatible hashtext using PostgreSQL's 32-bit hash_bytes algorithm, including signed int4 results and storage-backed text values.
  Adds regression coverage for all tail lengths, block boundaries, UTF-8 crossing a block boundary, long values, and NULL behavior.
  Part of #3099.
• 3187: Bug fixes for adaptive-encoded values
  This PR addresses a couple gaps related to adaptive values in Doltgres databases.
  • Releases prior to 0.56.3 wrote rows that lacked necessary bookkeeping metadata for their adaptive values stored out of band. As a result, such chunks would not be pushed on a clone or backup, and would be inappropriately garbage collected. Databases are scanned for this kind of corruption at startup and the server refuses to start if present.
  • A new reporting and repair tool for this corruption in cmd/admin.
  • The current release of Doltgres has the same corruption potential for adaptive key columns stored out of band. This PR fixes the problem.
    Companion Dolt PR:
    dolthub/dolt#11606
• 3184: Implement to_json
  Implements PostgreSQL-compatible to_json(anyelement) support.
  Uses PostgreSQL type output semantics across scalar, domain, array, composite, JSON, temporal, numeric, and extended types, while aligning array_to_json and row_to_json conversion behavior.
  Part of #3099
• 3182: Support COUNT(DISTINCT uuid)
  Adds PostgreSQL regression coverage for COUNT(DISTINCT ...) over UUID values and pins the GMS implementation that hashes extended types using their canonical serialized representation.
  Part of #3099
  Depends on: dolthub/go-mysql-server#3727
• 3179: Fix duplicate key handling after expression index alters
  Adds PostgreSQL regression coverage for duplicate-key errors and ON CONFLICT operations after adding a column to a table with an expression index. The underlying Dolt writer fix is now present on main.
  Fixes #3082
• 3178: Support scalar function aliases in FROM
  Enable PostgreSQL scalar-function aliases in FROM to name the function output column, including generate_subscripts(...) AS k. Record-returning functions retain their declared OUT column names.
  Pin go-mysql-server to the supporting planner and strict-SRF wrapper changes. Regression coverage includes alias references, NULL arguments, empty arrays, explicit column aliases, direct SRF calls, table-sourced NULL arrays, two scalar SRFs, and mixed scalar/record-returning functions in both orders. Assertions were verified against PostgreSQL 15.17 and with GOWORK=off go test ./testing/go -run TestSetReturningFunctions -count=1.
  Fixes #3173
  Depends on: go-mysql-server #3726
• 3177: Support ARRAY constructor casts to oidvector
  Support direct ARRAY[...]::oidvector expressions for OID-compatible PostgreSQL identifier types, including regtype, regclass, and regproc. The coercion is limited to array constructors and does not add a global array-to-oidvector cast or alter pg_cast.
  Fixes #3172
• 3175: Fix bit string length functions
  Adds PostgreSQL-compatible length(bit) and bit_length(bit) overloads, including implicit varbit-to-bit function resolution that preserves the input width for unconstrained bit parameters.
  Regression coverage includes varbit and bit(n) literals, stored values, empty bit strings, and NULLs. Expected SQL results were verified against PostgreSQL 15.17.
  Tests:
  • go test ./testing/go -run '^TestBitStringLengthFunctions$' -count=1
  • go test ./server/functions ./server/cast -count=1
  • go test ./testing/generation/function_coverage/output -run '^(Test_BitLength|Test_Length)$' -count=1
  • go test ./testing/go -run '^TestTypes$' -count=1
  • git diff --check
    Fixes #3174.
• 3168: Fix bind parameter type inference and array literal whitespace handling
  Fixes two bugs found while investigating issue #3093: an explicitly-cast bind parameter (e.g. $1::timestamptz) had its wire-protocol type collapsed to a generic type that discarded timezone offsets, and the array-literal parser dropped all whitespace in unquoted elements, rejecting any array of timestamps, intervals, or other space-containing values. Both are fixed at their root cause with regression tests covering the original failures plus surrounding edge cases (reversed comparisons, mixed cast/raw placeholders, quoted elements, whitespace-only arrays).
  Fixes: #3093
• 3166: Add regression tests for renaming tables with foreign keys
  Fixes: #3114
  Depends on: dolthub/dolt#11580
• 3162: Fix timestamp/timestamptz minus interval incorrect results
  timestamp - interval and timestamptz - interval only subtracted the interval's fractional-nanosecond component, silently ignoring its days and months fields, so day-scale shifts like now() - interval '90 days' evaluated to now() unchanged. Fixed by routing both operators through the existing helper with the interval negated, and added a regression test covering day and hour-scale subtraction on both types.
  Also fixes interval arithmetic to honor the correct calendar month lengths, instead of approximating all months at 30 days.
  Fixes: #3090
  Fixes: #3163
• 3161: Fix coalesce to properly compute nullability
• 3157: Implement string_to_array() function
  Adds the PostgreSQL string_to_array(string, delimiter [, null_string]) function.
  Fixes #3122.
• 3156: Support ALTER INDEX ... RENAME TO
  Adds support for ALTER INDEX ... RENAME TO.
  Fixes #3121.
• 3149: Infer bind-variable parameter types from typed siblings.
  Paremters in expressions like IS DISTINCT FROM $1 were being reported to clients as the unknown pseudo-type (OID 705) instead of the correct type, causing strict drivers such as pgx to fail to encode the parameter. Auditing for the same class of bug turned up four more affected constructs (ANY/SOME with an array or subquery, array subscripts, and COALESCE/GREATEST/LEAST), each confirmed broken via a wire-protocol reproduction and now fixed. New functional and wire-level regression tests cover all five cases.
  Fixes: #3097
• 3146: Fix WITH ORDINALITY use in nested derived tables
  A go-mysql-server fix for correlated-column resolution through nested derived tables (needed to fix WITH ORDINALITY inside a correlated subquery, #3138) exposed a latent bug in the OptimizeFunctions analyzer rule, which relied on the old buggy scope behavior as a signal for when to mark set-returning-function projections for row expansion. This removes that incorrect early-return (the rule's transform is idempotent, so it's safe to just always run it) and adds a regression test covering the original issue.
  Fixes: #3138
• 3142: Fix functional index expressions not being type-sanitized
  Fix functional index expressions (e.g. coalesce()) not being type-sanitized, which froze a GMS type onto the index's hidden column and broke all subsequent writes.
  Fixes: #3094
• 3140: COPY TO support
  Also adds support for the BINARY format of COPY FROM.
  COPY TO FILE is not supported in light of security concerns. We will need to do some product design work to make this safe, similar to what's supported on the Dolt side.
  Fixes #3086
  Fixes #3085
• 3137: audited string and []byte function params for wrapped args
  All casts to string and []byte now correctly unwrap their arguments first, as necessary.
  Fixes #3095
• 3131: Fix nil pointer panic in IsDistinctFrom/IsNotDistinctFrom
  IsDistinctFrom/IsNotDistinctFrom are wired in as vitess.InjectedExpr templates with nil children that get filled in later via WithResolvedChildren, but Vitess can call String() on the template beforehand (e.g. while building an EXISTS subquery's SQL text), and their String() methods dereferenced the nil children directly, causing a panic.
  Fixes: #3096 by guarding both String() implementations against nil children (matching the existing pattern in Not and BinaryOperator) and adds a regression test reproducing the reported EXISTS subquery panic.
• 3126: Added the pgvector extension
  This emulates a majority of the pgvector extension, with the major missing pieces being the special index types which we cannot support at this moment (HNSW and IVFFlat). This also includes a port of most of the tests from the actual pgvector repository. Implementing and testing this uncovered additional bugs which were fixed as well.
• 3061: Native support for stddev and variance related window functions
  Fixed a bug where STDDEV_POP, STDDEV_SAMP, VAR_POP, VAR_SAMP, and their variance and stddev aliases would crash the server when used as window functions over integer columns. They now return correct, Postgres-compatible numeric/double precision results instead of panicking.
  Fixes: #3038

go-mysql-server

• 3733: Evaluate sort key expressions once per row instead of once per comparison
  Sort comparators previously re-evaluated ORDER BY expressions on every comparison. For non-deterministic expressions (e.g. ORDER BY RAND()), this biased the result heavily toward rows late in the scan: with ORDER BY RAND() LIMIT 1 each comparison was a fresh coin flip, so the last row won ~50% of the time instead of 1/N. It was also wasteful for expensive sort keys, evaluating them O(n log n) times instead of O(n).
  Sort keys are now evaluated at most once per row and cached, in the full sort, Top-N heap, and top-1 paths. The top-1 path also now surfaces sort expression evaluation errors instead of swallowing them.
• 3731: Reject unsafe partial index join scans
  Prevent partial indexes from being used as complete sorted inputs for merge and range-heap joins unless the source filters include the index predicate.
  Adds optimizer coverage for predicate-absent rejection and predicate-present eligibility in both join paths.
  Part of dolthub/doltgresql#3100
• 3728: Expose DISTINCT aggregate retention
  Expose whether a DISTINCT aggregate argument was retained separately from its evaluated value. This lets aggregates distinguish a retained SQL NULL from a duplicate that should be skipped while preserving existing Eval behavior.
  Part of #3099
• 3727: Support extended types in COUNT DISTINCT
  Hash single-expression extended values using their canonical serialized representation in COUNT(DISTINCT ...). This allows PostgreSQL UUID values to participate in distinct aggregates without changing ordinary or multi-expression aggregate behavior.
  Part of #3099
• 3726: Handle empty set results in table function wrappers
  Handle strict set-returning functions used in FROM without fabricating a NULL row, while preserving ordinary scalar NULL behavior and multi-column SRF row shapes.
  Restrict PostgreSQL scalar alias-as-column behavior to one-column function results. Regular functions with multiple named OUT parameters retain those output names instead of being misclassified as scalar. MySQL-compatible callers remain unchanged because the alias behavior is opt-in.
  Added focused wrapper and planbuilder coverage for empty strict SRFs, scalar NULLs, multi-column rows, scalar aliases, native table functions, and record-returning regular functions. Verified with go test ./sql/expression/tablefunction -count=1 and go test ./sql/planbuilder -count=1.
• 3725: Support PostgreSQL scalar function aliases in FROM
  Add an opt-in plan-builder override for PostgreSQL scalar-function alias semantics in FROM clauses. The default remains disabled so MySQL-compatible callers retain existing behavior.
  Native table functions continue to preserve their named output columns. Added planbuilder coverage for PostgreSQL mode, default MySQL mode, and native table functions.
  Verified with go test ./sql/planbuilder -count=1.
• 3724: Added extended vector support
  This adds support for extended vector operations, to primarily be used by integrators
• 3719: fix panic on date type in Round()
  fixes the panic here: dolthub/dolt#11495
  converts that issue into just a datetime conversion problem
• 3718: Fix functional index display in SHOW INDEX and information_schema.statistics
SHOW INDEX and information_schema.statistics were exposing the internal !hidden!... system-column name in Column_name and leaving Expression NULL for functional index key parts, instead of matching MySQL's Column_name=NULL / Expression= convention. Chasing this down also surfaced a bug in Coalesce.IsNullable() that only checked its first argument, causing wrong NULL reporting for expressions like COALESCE(b, a) where a is NOT NULL.
• 3717: bug fix: outer scope visibility in multiple levels of nested derived tables
  Fixes a bug where a derived table nested inside another derived table (both within a correlated subquery expression) failed to inherit outer-scope visibility past the first nesting level, causing correlated references two-plus levels deep to resolve to the wrong field index or silently return wrong results. OuterScopeVisibility now propagates transitively through nested derived tables instead of only being granted to the outermost one.
• 3716: fix panic for UNION, INTERSECT and EXCEPT with unequal schema lengths
  fixes: dolthub/dolt#11491
• 3714: fix panic on invalid N argument to NTILE
  Depends on: dolthub/vitess#480
  Fixes: dolthub/dolt#11467
• 3710: fix panic in TRIM functions
  Added a conversion for TimeSpan type to LongText and updated errors to not panic.
  fixes: dolthub/dolt#11455
• 3705: Actually resolve column DEFAULT expression when building scalar expressions
  fixes dolthub/dolt#11453
  Also removes DefaultColumn placeholder expression type and add more guards for updating with default values.
  Doltgres updated in #3205
• 3703: Fix panic for LIKE expression with empty ESCAPE character
  Despite what MySQL documentation says, empty ESCAPE character actually escapes the NUL character (\0).
  fixes: dolthub/dolt#11518
• 3699: Correctly parse and compare JSON docs with numbers that are too large to fit in a float64 without losing precision.
  Previously we would parse all numbers in serialized JSON as 64-bit floats, and all comparisons between numbers in JSON would be coerced to 64-bit floats.
  This was causing problems for inputs that can't be represented precisely as a float, but can be represented precisely as an int64 or uint64.
  This PR enhances the logic for both parsing and comparing JSON documents to correctly handle float64, int64, and uint64 without any loss of precision.

vitess

• 480: parse N as integer only for window functions
• 479: README,SECURITY: Slightly update some security messaging.
  Clarify that recoverable panics are not currently covered as security issues.
• 478: go: sqlparser: Fix some panics on inputs with strange quotes, like SELECT''A.
  In a context where sqlparser.Parse is called into without a recover(), this could cause a process crash and thus be an availability concern.
  Thanks to Daniel Birtwhistle for the report.
• 477: Adding Columns field to TableFuncExpr
  Allows aliasing columns from a table function.
  Needed primarily for Doltgres, which supports more expressive table functions than MySQL.
• 475: go/netutil: Fix tests to be determinsitic even with Go > 1.24, GODEBUG=randseednop.

Closed Issues

• 3100: Inner join intermittently returns an empty result (no error) under concurrent load — same predicate as a subquery returns the rows
• 3121: ALTER INDEX ... RENAME TO support
• 3173: generate_subscripts(...) AS alias inside a correlated ARRAY(SELECT ...) subquery: "column could not be found in any table in scope"
• 3082: Duplicate-key handling panics (index out of range) after ALTER TABLE ADD COLUMN on a table with an expression index
• 3172: CAST(ARRAY[...]::regtype[] AS oidvector) fails
• 3114: ALTER TABLE RENAME fails in the presence of foreign keys
• 3174: Compatibility: function length(varbit) should exist
• 2099: [RFC] Exploring feasibility of Dolt or Doltgres as backend fo Matrix homeserver
• 3093: timestamptz scan → bind roundtrip loses equality (binary and text parameters alike)
• 3163: Doltgres approximates months as 30 days
• 3090: now() - interval '90 days' silently evaluates to now() unchanged
• 3138: WITH ORDINALITY inside a correlated subquery raises an internal error
• 3122: string_to_array() support
• 3085: Comma-omitted transaction_mode list in BEGIN/START TRANSACTION is rejected (BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY)
• 3086: COPY ... TO STDOUT is not implemented (all forms are syntax errors); COPY FROM STDIN works
• 3097: bool bind-parameter in IS DISTINCT FROM $1 is described as OID 705 (unknown) — pgx cannot encode it
• 3094: Expression index on coalesce() is accepted, then permanently write-bricks the table
• 3038: Window functions panic due to interface conversion error
• 3096: IS NOT DISTINCT FROM inside an EXISTS subquery panics: nil pointer in IsNotDistinctFrom.String
• 3095: replace() on out-of-line TEXT storage panics: interface {} is *val.TextStorage, not string
• 3117: ON CONFLICT DO NOTHING suppresses foreign key violations
• 3098: Write-write conflicts report SQLSTATE XX000 instead of 40001 — breaks standard retry middleware
• 11453: DEFAULT(column) reaches an unresolved placeholder during SELECT analysis
• 10143: Reused database name should be an error or warning
• 11455: TRIM panics on a native TIME value
• 509: Ensure ability to use AWS S3 compatible data stores
• 11495: Dolt panics on ROUND on a date-valued window result
• 11467: Dolt panics on a non-numeric NTILE bucket expression
• 11491: Dolt panics on recursive CTE column-arity error.
• 11540: prolly/tree: DiffOp stringer is stale — entry 12 unlabelled, one label transposed, one -linecomment wrong
• 11488: Make CALL DOLT_BACKUP('sync', ...) a no-op when nothing has changed
• 3707: SHOW INDEX FROM table WHERE key_name = ? ignores the WHERE filter
• 3706: Constraint-violation errors return SQLSTATE HY000 instead of 23000 (MySQL parity gap)
• 3708: Unmodified Drupal core install fails with "already an active transaction" against Dolt (works against MySQL)