Merged PRs

dolt

• 11993: /go/{cmd,libraries,store}: allow configuring git remotes
  Add git-remote.max-history-commits and git-remote.reset-history-on-prune settings so users can trade disk usage for faster incremental transfers. Support local/global dolt config, environment overrides, and typed options for embedders.
  Defaults remain unchanged. A history limit of 0 means unlimited; disabling prune-triggered resets allows obsolete data to remain reachable until the history limit is reached.
• 11991: /go/store/blobstore: use fetch anchor ref
  Preserve a persistent Git fetch anchor during teardown so subsequent pulls can negotiate incremental transfers instead of re-downloading the database. Compare-and-swap protects the anchor from overlapping sessions while allowing private refs to be cleaned up.
• 11990: significantly faster implementation of dolt log
  With these optimizations, dolt log is now an O(N) operation rather than an O(N^2).
  Optimizations:
  • Only query dolt_branches, dolt_tags, dolt_log() once instead of for every commit
  • CommitInfo is passed as a pointer
    Potential improvements:
  • There are places where we can now add concurrency for long running queryist calls
  • Pagination can now be properly implemented, but it is left as a TODO
    Before:

  james@macbook beads_sample % time dolt log -n 5000 > out.txt
  dolt log -n 5000 > out.txt  97.62s user 2.81s system 157% cpu 1:03.60 total
  

  After:

  james@macbook beads_sample % time dolt log -n 5000 > out.txt
  dolt log -n 5000 > out.txt  0.09s user 0.13s system 15% cpu 1.422 total
  

  About a 1000x improvement, which scales exponentially as number of commits increase.
  Fixes: dolthub/dolt#9315
• 11989: /go/store/nbs: cover missing spooling paths
  Newly persisted Git-backed tables and conjoin input reads bypassed NBS spooling, causing redundant Git reads and decompression. This change spools persisted tables from bytes already in memory and makes conjoin reuse existing source readers.
  Adds regression coverage for chunk correctness, blob read counts, and spool cleanup. Full NBS tests and focused race tests pass.
  Fixes #11916.
• 11985: Fix License Link
• 11956: Fix upsert authorization and add protocol regression coverage
  Upserts could rewrite rows without UPDATE privileges. Update GMS to require UPDATE authorization and add protocol regression coverage for denied and permitted upserts.
• 11935: Replace github.com/dolthub/fslock with github.com/dolthub/file-locks
  The new library keeps the interface - New, Lock, TryLock, LockWithTimeout, Unlock, Close, ErrLocked and ErrTimeout - so nothing here changes but the import line. The package is still named fslock, imported under that name from a path that no longer matches it.
• 11933: Allow DoltgreSQL to override effective user in search path $user substitution.
• 11921: Allow DoltgreSQL to provide branch-control principal
• 11920: Add DoltgreSQL transaction lifecycle hooks
  These allow Doltgres to see transaction start, why a transaction ended (rollback, commit) and interact with savepoints as well.
• 11896: Limit CI deferral comments to label and draft state changes
  Limits CI deferral and release comments to relevant label changes and draft/ready transitions, preventing duplicate notifications on commit pushes.
• 11893: go/store/nbs: Fix two nil-ghostGen bugs in GenerationalNBS
  Two pre-existing bugs on the ghostGen == nil path, both only reachable outside the Dolt server (dbfactory always supplies a ghost store):
  • HasMany returned nil instead of the absent set, hiding missing hashes. Regression test included.
  • PersistGhostHashes had its nil check inverted.
• 11892: go/store/nbs: Fix generation ordering on reads to avoid missing a chunk which is being moved from new to old gen.
  When GC moves chunks from new to old gen, it publishes them into old gen and then, eventually, drops them from new gen. If the Reads check old gen first, and then fall back to new gen, they can miss a chunk which is actually retained --- the entire GC can run in between the return from the old gen Read and before the new gen Read.
  Reading new gen first is the fix. If the chunk isn't in new gen and it does exist, it has guaranteed already been published to old gen by the time we ask for it.
• 11891: go/store/nbs: Drain outstanding reads before a GC installs its keeper.
  An unlocked read samples |nbs.keeperFunc| under |nbs.mu| and then runs
  against a table set with the lock released, so a read already in flight
  when BeginGC installed its keeper could return chunks having taken no
  read dependency on them, leaving the GC free to collect them. BeginGC now
  sets |gcInstallPending| and waits for |outstandingReads| to drain before
  installing, and every read path parks on that flag at the top of its
  locked section. Parking there, rather than in |beginRead|, keeps a read
  which spans the memtable and the table files from being split across the
  barrier. A BeginGC whose context is cancelled during the drain clears the
  flag and restores conjoin, so it leaves no reads parked and no conjoin
  disabled.
• 11889: go/store/nbs: Sample the keeper in |beginRead|, and register every unlocked read.
  |beginRead| now samples |nbs.keeperFunc| and |nbs.gcCycleCounter| itself
  and registers every unlocked read, rather than each call site sampling
  them separately and only reads which started during a GC being
  registered. A read's keeper and cycle therefore come from the same
  locked section which registers it, |nbs.outstandingReads| counts every
  read running against a table set, and |endRead| is never nil. This is
  the plumbing for making a keeper installation a barrier: the follow-up
  drains those registrations before it installs a keeper. The costs are
  that a read with no GC running reacquires |nbs.mu| once at completion,
  where before it did not, and that EndGC now also waits out reads which
  started before its GC began.
• 11888: go/store/nbs: Fix a lost cancellation wakeup in |waitForGC|.
  Now take nbs.mu when we broadcast gcCond, so that our waiter is definitely already parked if they need to see our wakeup.
• 11887: go: NodeStore, ValueStore: Avoid caching things that might have been read before an incoming Purge request.
  The NodeStore and the ValueStore cache have the structure where they are queried and, if there is a miss, a fetch is made the underlying ChunkStore. They are then populated with the result. GC runs a Purge operation on these caches. This makes all future read operations reach the ChunkStore layer during the GC operation, so that proper dependencies can be taken on them.
  This change fixes a race where Get -> Read -> Purge -> Put could result in the cache carrying data throughout and after the GC which might have been read before the Purge operation itself. The caches now carry a purge count and they refuse to populate with values which were fetched based on a Get at a previous purge count.
• 11872: integration-tests/go-sql-server-driver: Add machinery to run dolt fsck on the database directories anytime these tests fail.
• 11854: Print SQL boolean results as numeric values
  Prints boolean SQL results as 1 and 0 in text and CSV output to match MySQL.
  Fixes dolthub/dolt#6044
• 11852: Validate destination branch names before pushing
  Rejects invalid destination branch names before pushing to remotes.
  Fixes dolthub/dolt#5341
• 11851: Enable Dolt executable comments in SQL scripts
  Enables DOLT executable comments with the parser support in dolthub/vitess#494.
  Fixes dolthub/dolt#3096
• 11849: Support JSON Lines output for SQL queries
  Adds jsonl SQL result formatting with one JSON object per row.
  Fixes dolthub/dolt#1844
• 11844: Show ON UPDATE CURRENT_TIMESTAMP across schemas and table alterations in EXTRA column
  Fix dolthub/dolt#11774
  Blocked by dolthub/go-mysql-server#3862
• 11842: Support wildcard table filters for binlog replication
  Adds REPLICATE_WILD_DO_TABLE and REPLICATE_WILD_IGNORE_TABLE support for MySQL-to-Dolt binlog replication, including MySQL wildcard matching, precedence, case handling, validation, and SHOW REPLICA STATUS output.
  Filter updates are applied atomically and synchronized with replica lifecycle operations.
  Part of #11787
  Depends on: dolthub/go-mysql-server#3885
• 11802: Fix legacy table name unmarshalling receiver
• 11773: go/store/nbs: Add validation and sanity checks on the index data when a NomsBlockStore opens a table file.
  Two types of checks are added. Simple checks are run on every index parse. They assert that prefixes are in sorted order, that ordinals are within range, that offsets (dervied from the lengths) are not too small. The more expensive checks only run when we add new table files to the store, typically as part of GC, a pull or receiving a push. These further assert that recorded ordinals are unique and that the hash of the suffixes table matches the file name, which is how the table file name is derived on all write paths.
  These sanity checks are added to make Dolt more robust in the face of bugs in Dolt or unexpected behavior from I/O interactions. If these validation checks fail, Dolt has a chance to fail a write operation which is attempting to take a new dependency on the corrupted data.
• 11756: Bump google.golang.org/grpc from 1.83.1 to 1.83.2 in /go
  Bumps google.golang.org/grpc from 1.83.1 to 1.83.2. Release notes

  Sourced from google.golang.org/grpc's releases.

  Release 1.83.2

  Security

  • server: Reject requests missing both :authority and Host headers with HTTP 400 and status Internal. (grpc/grpc-go#9365)
    • Special Thanks: @​winklemad

  Commits
  • 030ee8b Update version to 1.83.2 (#9375)
  • 8668b69 cherry-pick #9365 to v1.83.x (#9366)
  • a3e952d cherry-pick #9346 to v1.83.x and update x/net dependency (#9369)
  • 58f8fd9 Change version to 1.83.2-dev (#9337)
  • See full diff in compare view
  
  
• 11643: dynamic merge conflict handling
  This change allows for more flexible row merge behavior, in particular the ability to detect conflict on matching values and create rows dynamically based on the callers requirements.
  DumboDB is the direct consumer of this change. This allows us to match Dumbo's standard compare-and-set query pattern, and to also enable collection specific merge modes.
  There may be cleaner ways to implement this, but I opted to touch the common (dolt) code path as little as possible since this could have significant perf impacts. nil rowMergePolicy is the dolt way as a result.
• 11618: {proto,go/serial}/.bazelversion: Bump to 9.2.0. Bump some module versions.

doltgresql

• 3468: Report PostgreSQL UPDATE row counts
  Enable PostgreSQL UPDATE row counts through GMS, including unchanged rows and ON CONFLICT DO UPDATE. Add regression coverage for command tags, PL/pgSQL FOUND, RETURNING, triggers, and mixed conflict statements.
  Depends on: dolthub/go-mysql-server#3970
  Fixes #3113
• 3451: Fixed relation privilege checks
  Fixes:
  • #3448
    Lets all roles read from the public system tables, and corrects table and view permissions. Some tests are skipped due to pre-existing issues that are outside the scope of this PR.
    Builds on:
  • dolthub/go-mysql-server#3941
  • dolthub/vitess#498
• 3449: Added SET CONSTRAINTS support
  Fixes:
  • #3365
    This doesn't add full support for constraints since that's a much larger change (requires deferrability), but it at least unblocks the non-deferring cases in the issue. We still block on deferring since it's a fundamental feature that we'd be incorrectly throwing away, causing divergent behavior versus the expectation (generally you only want deferring so certain queries would work, so we should fail before we can get to that point).
• 3437: Fixed column_default rendering for literal and cast defaults
  Fixes
  • #3432
    Renders literals and cast column defaults in information_schema.columns correctly. Also fixes negative literals inside casts being persisted as -5::TEXT, which re-parsed as -('5'::text) and broke inserts using that default.
• 3431: Added JSON_TABLE
  This implements JSON_TABLE, which is required for:
  • #3331
• 3429: Implement missing array functions and array parser support
  Implements missing array functions, slicing, subscript updates, FOREACH SLICE, and PostgreSQL-compatible array error codes while deferring custom bounds that require serialization changes.
• 3425: Fixed row comparisons against subqueries, CHECK constraints, and single evaluation
  Row constructors compared against subqueries now follow Postgres' NULL rules, <-style row comparisons evaluate each field only once, and CHECK constraints containing ROW(...) no longer fail on every insert. These were issues found in #3424 that are being fixed in a separate PR.
• 3424: Fixed context-dependent record comparisons
  Fixes:
  • #2936
    Record comparisons are now context-dependent, which is a special case that is detailed specifically within the documentation. This also removes an analyzer rule that was previously added and is no longer necessary.
• 3423: Added UPDATE OF for CREATE TRIGGER
  Fixes:
  • #3415
    This adds UPDATE OF column lists to CREATE TRIGGER. These triggers only fire when an UPDATE sets one of the listed columns, and pg_trigger.tgattr now reports those columns. Also, renaming a listed column updates the trigger, and dropping one requires CASCADE, which also drops the trigger, which were found while fixing this issue.
• 3419: Added XML
  Fixes:
  • #3337
    This adds most of the XML surface. The most notable exclusions are the *_to_xml family of functions, since those would require a bit more work.
• 3418: plpgsql: Support defaults in record declarations.
  Fixes #3386.
• 3410: Multidimensional arrays
  This implements multidimensional arrays. They're serialized by writing a flattened array with the dimensions appended at the end, so that existing array data can be read as-is. Array types use the new serialized version (1) while all other non-array types use the old version (0), since the new version is primarily geared for array types, and creating new non-array types should retain their backwards compatibility. Deserialized types also carry their version, so reading an array type made on an older version simply restricts writing multidimensional data.
  Other fixes are present for regressions and test failures found along the way, with their relevant tests included in the test files.
• 3405: Permit configured unsupported locking statements
  Adds an opt-in server setting to accept and ignore unsupported locking statements.
  This provides a partial workaround for the limitations in #2600
• 3402: server/plpgsql: Support FOREACH IN ARRAY.
  The loop's expression is evaluated once into a record, which unnest then visits in order, assigning each element to the loop variable. An expression that does not yield an array, or that yields a null array, raises as PostgreSQL does. SLICE is not yet supported.
• 3401: Fixed multi-array unnest
  Fixes
  • #3366
• 3397: Support explicit default NULL ordering
  Allow ORDER BY clauses to explicitly specify PostgreSQL's default NULL placement with ASC NULLS LAST and DESC NULLS FIRST. Regenerate the parser and add coverage for implicit and explicit NULL ordering, multi-column sorts, window ordering, and ordered aggregates.
  Resolve common-type inference for VALUES rows that combine an unknown NULL literal with a typed value, with coverage for all ASC/DESC and NULLS FIRST/NULLS LAST combinations.
  Fixes #3388
  Depends on: go-mysql-server #3898
• 3385: server/analyzer: Give an INSERT's BEFORE triggers a full row.
  AssignTriggers runs long before GMS pads an INSERT's rows out to the table's schema, so it could only attach the triggers below that projection. NEW then held just the columns the INSERT named, in the order it named them, and reading a later one panicked on a short row. A new rule lifts the triggers above the projection once it exists.
• 3375: server/plpgsql: Report the SQLSTATE a RAISE names.
  An EXCEPTION reported P0001 whatever its USING ERRCODE clause said, and a notice reported that clause's source text, quotes and all. Both now resolve it to the SQLSTATE it names, and a generated RAISE can carry one through the same option.
• 3374: server/functions: Report the type of a null value from pg_typeof.
  The function was declared strict, so it returned null for a null argument. Its type is known regardless of its value, which is what PostgreSQL reports.
• 3373: server/plpgsql: Type a CASE statement's variable from its expression.
  pg_query_go declares it int4 whatever the expression yields, so a CASE over any other type failed to assign.
• 3372: server/plpgsql: Treat a NULL condition as false instead of panicking.
  A PL/pgSQL IF, WHILE, EXIT WHEN, or CASE whose condition evaluated to NULL crashed the query handler on a failed type assertion.
• 3371: Support referencing a plpgsql record as a whole.
  Referencing a RECORD variable, or a trigger's OLD or NEW, without accessing a field panicked. ApplyBindings now recognizes such a reference and renders the record from its fields. When the binding is interpolated into a statement, the record is modeled as a single-row derived table selected by its whole-row reference, so a function such as to_jsonb() sees its field names; RAISE interpolates the record's text representation instead.
  Referencing a record that has never been assigned reports an error. IoOutput now returns an error for pseudo-types instead of reaching the registry with their placeholder I/O function.
• 3370: pl/pgsql: Support arbitrary expressions in DECLARE defaults.
  A declaration's default was previously either a bare parameter name or the source text itself, which was parsed through the declared type's input function when evaluated. We now compile defaults to a query at CREATE time, like the right-hand side of an assignment. They are then evaluated when the declaration runs. We continue storing the source text for the default definition. Older releases still read and apply the defaults which they previously supported.
• 3357: Fixed Issue #3336
  Whole-row comparisons now work in triggers, and other bare whole-row references report PostgreSQL's column-count errors.
  • #3336
• 3356: Fixed Issue #3334
  Adds the regnamespace type with its casts and to_regnamespace.
  • #3334
• 3355: Fixed Issue #3333
  CHECK constraints that call functions no longer reject every row.
  • #3333
• 3354: Fixed Issue #3332
  Named NOT NULL, DEFAULT, and UNIQUE column constraints are now accepted.
  • #3332
• 3353: Fixed Issue #3330
  Implements information_schema.triggers.
  • #3330
• 3352: Fixed Issue #3328
  information_schema.columns now reports generation_expression for generated columns.
  • #3328
• 3351: Fixed Issue #3327
  Built-in functions are executable without an explicit EXECUTE grant.
  • #3327
• 3350: Fixed Issue #3326
  Implements convert_from and decode.
  • #3326
• 3349: Fixed Issue #3325
  Casting a bpchar to text, varchar, or name now trims trailing spaces.
  • #3325
• 3348: Fixed Issue #3324
  Default, generated column, and CHECK expressions now keep the parentheses that change their meaning.
  • #3324
• 3347: Fixed Issue #3323
  Generated column expressions now survive ALTER TABLE ADD PRIMARY KEY.
  • #3323
• 3321: Support compound COPY FROM STDIN queries
  Compound simple-query messages containing COPY FROM STDIN stopped executing after the COPY operation completed, so later statements were skipped and the server sent ReadyForQuery too early. COPY data was also committed independently instead of remaining within the compound query’s implicit or explicit transaction.
  This change retains the active simple-query execution while COPY waits for client data, resumes the remaining statements after CopyDone, and preserves the enclosing transaction’s commit and rollback behavior. CopyFail now aborts the suspended query, rolls back implicit work, and marks explicit transactions failed with SQLSTATE 57014.
  The regression replayer also incorrectly combined all recorded COPY data into one stream and resent it for every CopyInResponse. It now preserves COPY stream boundaries and sends each recorded input exactly once, in statement order.

go-mysql-server

• 3973: Preserve literal defaults during ALTER table rewrites
  ALTER rewrites starting from persisted schema could reclassify literal defaults as expressions, causing datetime COLUMN_DEFAULT values to gain quotes after subsequent column changes. Resolve defaults in the current schema before rewriting, preserving literal metadata and existing multi-column ALTER behavior.
  Adds shared engine coverage for metadata, SHOW CREATE, and default insertion. All 50 Dolt default-value BATS cases, Dolt MODIFY tests, and relevant GMS suites pass; expectations were checked against MySQL 8.4.11.
  Addresses the Lambda BATS failure in Dolt #11994.
• 3970: Support PostgreSQL UPDATE row counts
  Add an engine override to support PostgreSQL UPDATE row count behavior, where all matched rows are counted. Also simplifies INSERT ON DUPLICATE UPDATE handling.
  Addresses #3113.
  Doltgres PR: #3468.
• 3965: Reject out-of-range INET_NTOA arguments
  Returns NULL with a warning for INET_NTOA arguments outside the IPv4 range.
  Fixes dolthub/dolt#11510
• 3964: Validate twelve-hour STR_TO_DATE inputs
  Validates twelve-hour STR_TO_DATE inputs and normalizes midnight and noon consistently with MySQL.
  Fixes dolthub/dolt#11544
• 3963: Reset regular expressions between window partitions
  Reinitializes disposed regular expressions when they are reused across window partitions.
  Fixes dolthub/dolt#11550
• 3962: Clamp unsigned MEDIUMINT serialization to its maximum value
  Clamps unsigned MEDIUMINT serialization to 16777215.
• 3961: Store binary collation metadata explicitly
  Stores binary collation metadata explicitly instead of deriving it from collation names.
  Fixes dolthub/go-mysql-server#3838
• 3959: Recompute stored generated columns after definition changes
  Recomputes stored generated columns and their dependents when MODIFY or CHANGE alters their definitions.
  Fixes dolthub/dolt#11781
• 3958: Reject malformed UTF-8 in CONVERT USING utf8mb4
  Returns NULL with a warning when CONVERT USING utf8mb4 receives malformed UTF-8.
  Fixes dolthub/go-mysql-server#3837
• 3957: Preserve unsigned bits when casting to SIGNED
  Reinterprets BIGINT UNSIGNED values as signed integers when evaluating CAST AS SIGNED.
  Fixes dolthub/dolt#11906
• 3956: Preserve NOT IN predicates that cannot be unnested
  Preserves negation on residual NOT IN predicates when sibling subqueries become anti joins.
  Fixes dolthub/dolt#11913
• 3955: Convert STR_TO_DATE arguments to strings
  Accepts binary and numeric arguments to STR_TO_DATE using MySQL-compatible string conversion.
  Fixes dolthub/dolt#11919
• 3954: Respect context cancellation errors during group by aggregation
  Cancels blocked grouping producers when the grouping consumer returns an error.
• 3953: Allow grouped expressions without column dependencies
  Allows column-free expressions and correlated subqueries that reference only grouped columns under ONLY_FULL_GROUP_BY.
• 3952: Account for COUNT DISTINCT memory usage
  Tracks COUNT DISTINCT allocations through the session memory manager after the grouping cancellation fix in #3954.
• 3951: Validate temporal cast precision
  Validates temporal cast precision before constructing the target type.
• 3950: Fix correlated subquery dependencies in grouped joins
  Preserves correlated subquery column dependencies when grouping over joins.
• 3949: Fix column statistics queries without initialized privileges
  Returns an empty iterator when column statistics are queried without initialized session privileges.
• 3948: Implement numeric converts to TIME with precision
  Implement conversion for numeric types to TIME including precision parameters.
  Also includes conversion logic for boolean types and small fixes for string conversions.
• 3946: Default to InternalDecimalType for CONVERT with decimal arguments
  Fix regression from dolthub/go-mysql-server#3939
  dolt bump in dolthub/dolt#11915
  doltgres bump in #3421
• 3941: Resolved table and CTE authorization
  Fixes a bug where subqueries could bypass permissions in some instances (test cases are now returning errors), and also adds an interface for:
  • #3451
• 3940: Require UPDATE privileges for duplicate-key inserts
  INSERT ... ON DUPLICATE KEY UPDATE could rewrite rows without UPDATE privileges. Require UPDATE authorization and return the MySQL-compatible error code when access is denied.
• 3939: fix panic for CAST and CONVERT to types with invalid precision/scale
  Ideally, CAST/CONVERT should only require the destination sql.Type to make the proper conversion.
  However, a significant portion of our conversion and comparison logic is so dependent on existing hackiness that it would require an entire rewrite to properly implement.
  As a result, this is a minimal change that fixes the panic and leaves the logic in a slightly better place.
• 3924: Fix panic on nil decimal values in VALUES derived tables
  Fix dolthub/dolt#11942
• 3923: Resolve untyped NULL columns in CTAS to VARBINARY(0)
  Fix dolthub/dolt#11941
• 3921: Fix non-literal evaluation in unix_timestamp
  Fix dolthub/dolt#11917
• 3920: Fix panic converting strings with a dangling exponent
  Fix dolthub/dolt#11918
• 3919: implement precision for TIME types
  Add support for precision parameter for TIME types.
  Implements proper rounding and string output according to the precision.
  fixes: dolthub/dolt#10661
• 3918: Support escaped LIKE wildcard in analyzer prefix extraction and pattern matching
  Fix dolthub/dolt#11903
  Fix dolthub/dolt#11910
  Blocked by dolthub/vitess#497
  Block dolthub/dolt#11937
  Close dolthub/go-mysql-server#3972
• 3911: Add delimited time regex
  Fixes a regression from #3901 that breaks the dolt bats test import-create-tables: table import -c infers types from data (dolthub/dolt#11922).
• 3908: Unwrap ANY_VALUE for aggregates and window functions
  Fix dolthub/dolt#11912
• 3907: Optimize aggregate functions and remove sort nodes on multi-column indexes provided that any columns before the aggregated/sorted column are constant
  Dolt attempts to remove ORDER BY nodes from the plan when the chosen index is guaranteed to already produce rows in the desired order. But currently, it's limited to cases where the sort expressions are a prefix of the index. This means that we don't currently remove the sort in examples like this one:

  CREATE TABLE test (pk1 int, pk2 int);
  SELECT pk2 FROM test WHERE pk1 = 64 ORDER BY pk2 LIMIT 1;
  

  We can optimize this by using the primary index, because even thought we're not ordering by pk1, the value of pk1 is constant for all results.
  Additionally, Dolt tries to optimize MIN and MAX functions into the above. This also currently requires that that the column being aggregated is the first column in the index, meaning that we can't optimize the following:

  CREATE TABLE test (pk1 int, pk2 int);
  SELECT MIN(pk2) FROM test WHERE pk1 = 64;
  SELECT MIN(pk2) FROM test WHERE pk1 = 64 GROUP BY pk1;
  

  The second SELECT is unlikely to be written by hand but could be produced procedurally or as the result of other optimizations.
• 3904: Fix ONLY_FULL_GROUP_BY validation for window functions
• 3901: handle no delimiter datetime string parsing
  Fix support for parsing non-delimited datetime strings to DATE, DATETIME, and TIMESTAMPS.
  Additionally, fixes parsing for weirdly delimited datetime strings.
  Fixes: dolthub/dolt#10278
• 3900: Fixed duplicate window columns
  Fix required for:
  • #3401
• 3899: Fix dropped residual filters and false branch matching in concat lookup join
  Fix dolthub/dolt#11886
• 3898: Use common extended type for VALUES rows
  Delegate VALUES common-type selection to the extended-type hook when both row expressions use extended types. This lets dialect integrations resolve unknown NULL literals against typed VALUES rows while preserving existing built-in type handling.
  Includes focused schema inference coverage.
  Part of #3388
• 3897: Optimize SPACE with strings.Repeat
  Fix dolthub/dolt#11408
• 3889: Filled generation_expression and extra for generated columns in information_schema.columns
  information_schema.columns now reports the generation expression and STORED/VIRTUAL GENERATED extra for generated columns instead of leaving them empty. Although this was found and fixed in the Doltgres integrator, GMS requires a different fix as Doltgres uses its own information_schema table implementation.
  • #3328
• 3888: Fix LOAD_FILE directory handle leaks
  Avoids leaking directory handles during LOAD_FILE checks, with the regression exercised by Dolt #11838.
  Fixes dolthub/dolt#8785
• 3886: Simplify partial join parent for window functions in exists subqueries
  fixes dolthub/dolt#11421
• 3885: Support wildcard replication filter values
  Adds native string-list values for REPLICATE_WILD_DO_TABLE and REPLICATE_WILD_IGNORE_TABLE, including MySQL-compatible format validation and SHOW REPLICA STATUS formatting.
  Simplifies replication option handling to use native Go values instead of exported wrapper types.
  Companion Dolt PR: github.com/

Note truncated.