Home - Waterfall Grid T-Grid Console Builders Recent Builds Buildslaves Changesources - JSON API - About

Console View


Categories: connectors experimental galera main
Legend:   Passed Failed Warnings Failed Again Running Exception Offline No data

connectors experimental galera main
fad0aad19c22...
fad0aad19c22ee35894fe987b052454c07734aa0
Alexey Botchkov
MDEV-37262 XMLTYPE: validation.
f2d7462d87b7...
f2d7462d87b76ea9bf72faf655107ab57c81bf31
Yuchen Pei
MDEV-15621 Auto add RANGE COLUMNS partitions by interval

Allow auto partitioning by interval in PARTITION BY RANGE COLUMNS

PARTITION BY RANGE COLUMNS (col_name)
INTERVAL interval [AUTO]
(
  PARTITION partition_name VALUES LESS THAN (value)
  [, PARTITION partition_name VALUES LESS THAN (value) ... ]
)

where

- col_name is the name of one column of type DATE or DATETIME
- at least one partition is supplied
- INTERVAL interval is a time interval

When performing DML on such a table, it will first add partitions
by the specified interval until the partition covers the current time.

Partition addition will not cause an implicit commit like DDL normally
does.

The partitions are named pN.

Otherwise the table behaves exactly the same as a normal RANGE COLUMNS
partitioned table.
f2bfc38efec0...
f2bfc38efec0146c55c553b4f79693ace36e0da8
Hemant Dangi
High priority MDL_BACKUP_COMMIT_HIGH_PRIO and Slave-side BACKUP-COMMIT
tracking to prevent parallel-slave/backup deadlock

A parallel-slave worker holding MDL_BACKUP_COMMIT and waiting on a
prior commit can deadlock with an incoming BACKUP STAGE BLOCK_COMMIT:
the prior commit also needs MDL_BACKUP_COMMIT but fairness denies it
while the backup X-request is in the waiting queue.

Add MDL_BACKUP_COMMIT_HIGH_PRIO — a sibling of MDL_BACKUP_COMMIT
whose only matrix difference is that it is granted past a waiting
backup X. Compatibility with already-granted holders is unchanged.

The slave decides at request time, via per-Relay_log_info state in
Backup_commit_team (every in-flight teammate plus the subset that
picked C but is not yet granted). The atomic join_and_decide() rule:

Pick HIGH_PRIO iff
  (a) some larger-sub_id teammate is registered, AND
  (b) no smaller-sub_id teammate is currently pending-C.
Otherwise pick MDL_BACKUP_COMMIT and mark pending-C.

(a) breaks the deadlock. (b) prevents a larger sub_id from being
granted H while a smaller is queued as C behind X — which would
re-deadlock through wait_for_prior_commit. Atomicity closes the
register/decide race. mark_granted() clears pending-C on grant;
leave() cleans up on release or error.
ed8fe8f10301...
ed8fe8f10301eccbef206f271fc7e3f7e6e0005a
Yuchen Pei
MDEV-15621 [demo] Allow PARTITION BY RANGE COLUMNS of a timestamp column
dc94988f9460...
dc94988f9460b9604e072a58b90d10eabd3b0a2d
Yuchen Pei
MDEV-15621 Auto add RANGE COLUMNS partitions by interval

Allow auto partitioning by interval in PARTITION BY RANGE COLUMNS

PARTITION BY RANGE COLUMNS (col_name)
INTERVAL interval [AUTO]
(
  PARTITION partition_name VALUES LESS THAN (value)
  [, PARTITION partition_name VALUES LESS THAN (value) ... ]
)

where

- col_name is the name of one column of type DATE or DATETIME
- at least one partition is supplied
- INTERVAL interval is a time interval

When performing DML on such a table, it will first add partitions
by the specified interval until the partition covers the current time.

Partition addition will not cause an implicit commit like DDL normally
does.

The partitions are named pN.

Otherwise the table behaves exactly the same as a normal RANGE COLUMNS
partitioned table.
db6a6c60e560...
db6a6c60e560d8815273f52b02d70bdcf3bc0dce
Hemant Dangi
High priority MDL_BACKUP_COMMIT_HIGH_PRIO and Slave-side BACKUP-COMMIT
tracking to prevent parallel-slave/backup deadlock

A parallel-slave worker that has acquired MDL_BACKUP_COMMIT and is
waiting for a prior commit can be deadlocked by an incoming
BACKUP STAGE BLOCK_COMMIT: the prior commit needs MDL_BACKUP_COMMIT too
but the standard fairness rule denies it while the backup X-request is
in the waiting queue.

Design
------
Add MDL_BACKUP_COMMIT_HIGH_PRIO, a sibling lock mode of
MDL_BACKUP_COMMIT. The only matrix difference is one cell of
m_waiting_incompatible: HIGH_PRIO is granted even when a BACKUP
X-request is waiting.

A committing parallel-slave worker:
1. registers its sub_id in backup_team,
2. queries has_higher() — true iff a teammate in the same domain has
a strictly greater sub_id,
3. requests MDL_BACKUP_COMMIT_HIGH_PRIO if true, otherwise
MDL_BACKUP_COMMIT,
4. unregisters after release_lock().

Register-before-decide ordering ensures that any teammate arriving
later observes our sub_id, and we observe at least our own back.

How it solves the problem
-------------------------
When backup's X-request is in the waiting queue and a worker that is
needed to unblock a prior commit arrives, that worker observes a
later-numbered teammate already holding the BACKUP lock, requests
HIGH_PRIO, and is granted past the X-request via the matrix. The
prior-commit chain drains; the backup X-request is then granted.
d5d1a2ee6cd4...
d5d1a2ee6cd4286851ba926498c5ca0aafe63b72
Yuchen Pei
MDEV-15621 [refactor] Partitioning cleanup

change p_column_list_val::fixed to a bool
remove redundant end label in partition_info::fix_column_value_functions
ce6a7587f5c8...
ce6a7587f5c87fe0ef06504cf6e74808c8316d99
sjaakola
MDEV-38260 applier hang due to sequence table access

Avoiding to mark sequence table write as a DDL transaction
for galera applying.

Skipping commit for DDL marked GTID log event in applying as this
would lead to double commit, if the transaction has also a real
transaction. Such scnenario could happen if transaction has sequence
table writes together with other innodb table writes.
cdd860782bcb...
cdd860782bcb68614de9465983f7d902aab1a2a3
Rex Johnston
MDEV-39492 Parallel Query: Study how to create worker threads

Introduces parallel_worker_threads variable to control the number
of worker threads created by a parallel execution query.

2 new files, sql_parallel_workers.h sql_parallel_workers.cc which
contain structures for the creation, management and deletion of
parallel worker threads (pwt_ in the name).  Main management
class created in the stack in JOIN::exec, implemented for the
top level select.

Current parallel_worker_thread_func sleeps for 10 seconds, generates
a warning, signals the main thread, sleeps 10 seconds, signals the
main thread again, sets it's finished flag and cleans it's THD.

The main thread loops through worker threads, looking for finished
thread and cleans them up if they have finished.
It then waits for a signal, then processes it's message queue.

Threads are registed in server_threads, so are visible in
information_schema.processlist and the show processlist command.

We check that a kill query on a parallel worker is passed onto it's
manager and the query is properly aborted, and that a kill connection
is handled properly in parallel_worker.test.

Review input 1: cleanup earlier

Do cleanup before we've finished sending the result to the client.
This way, one can see the errors (and eventually warnings) marshalled
back to the main thread and returned to the user:

MariaDB [test]> set parallel_worker_threads=10;
Query OK, 0 rows affected (0.001 sec)

MariaDB [test]> select seq from seq_1_to_10;
ERROR 4103 (HY000): Argument to the worker_busted_function() function does not belong to the range [0,1]

Assisted by Sergei Petrunia and Claude Code.
c2bed2dbdc93...
c2bed2dbdc93fc0fb5fedb2715a5a3de87b83025
Marko Mäkelä
Re-enable 3 tests
ac3a4ab419d7...
ac3a4ab419d7ae2ffcf59b8a67b231822a57ce22
Marko Mäkelä
Fix regressions in some innodb_log_archive=OFF tests
aaea1faaa191...
aaea1faaa191e13641cdc3a52ea083ae6f95217b
Rex Johnston
MDEV-39492 Parallel Query: Study how to create worker threads

Introduces parallel_worker_threads variable to control the number
of worker threads created by a parallel execution query.

2 new files, sql_parallel_workers.h sql_parallel_workers.cc which
contain structures for the creation, management and deletion of
parallel worker threads (pwt_ in the name).  Main management
class created in the stack in JOIN::exec, implemented for the
top level select.

Current parallel_worker_thread_func sleeps for 10 seconds, generates
a warning, signals the main thread, sleeps 10 seconds, signals the
main thread again, sets it's finished flag and cleans it's THD.

The main thread loops through worker threads, looking for finished
thread and cleans them up if they have finished.
It then waits for a signal, then processes it's message queue.

Threads are registed in server_threads, so are visible in
information_schema.processlist and the show processlist command.

We check that a kill query on a parallel worker is passed onto it's
manager and the query is properly aborted, and that a kill connection
is handled properly in parallel_worker.test.

Review input 1: cleanup earlier

Do cleanup before we've finished sending the result to the client.
This way, one can see the errors (and eventually warnings) marshalled
back to the main thread and returned to the user:

MariaDB [test]> set parallel_worker_threads=10;
Query OK, 0 rows affected (0.001 sec)

MariaDB [test]> select seq from seq_1_to_10;
ERROR 4103 (HY000): Argument to the worker_busted_function() function does not belong to the range [0,1]

Assisted by Sergei Petrunia and Claude Code.
a948794df818...
a948794df8184336e922e306a1383dc750d497b2
Rex Johnston
MDEV-39492 Parallel Query: Study how to create worker threads

Introduces parallel_worker_threads variable to control the number
of worker threads created by a parallel execution query.

2 new files, sql_parallel_workers.h sql_parallel_workers.cc which
contain structures for the creation, management and deletion of
parallel worker threads (pwt_ in the name).  Main management
class created in the stack in JOIN::exec, implemented for the
top level select.

Current parallel_worker_thread_func sleeps for 10 seconds, generates
a warning, signals the main thread, sleeps 10 seconds, signals the
main thread again, sets it's finished flag and cleans it's THD.

The main thread loops through worker threads, looking for finished
thread and cleans them up if they have finished.
It then waits for a signal, then processes it's message queue.

Threads are registed in server_threads, so are visible in
information_schema.processlist and the show processlist command.

We check that a kill query on a parallel worker is passed onto it's
manager and the query is properly aborted, and that a kill connection
is handled properly in parallel_worker.test.

Review input 1: cleanup earlier

Do cleanup before we've finished sending the result to the client.
This way, one can see the errors (and eventually warnings) marshalled
back to the main thread and returned to the user:

MariaDB [test]> set parallel_worker_threads=10;
Query OK, 0 rows affected (0.001 sec)

MariaDB [test]> select seq from seq_1_to_10;
ERROR 4103 (HY000): Argument to the worker_busted_function() function does not belong to the range [0,1]

Assisted by Sergei Petrunia and Claude Code.
a670a9ffc53f...
a670a9ffc53feb94d0e5b177eefd00c66f363da9
Yuchen Pei
MDEV-15621 Auto add RANGE COLUMNS partitions by interval

Allow auto partitioning by interval in PARTITION BY RANGE COLUMNS

PARTITION BY RANGE COLUMNS (col_name)
INTERVAL interval [AUTO]
(
  PARTITION partition_name VALUES LESS THAN (value)
  [, PARTITION partition_name VALUES LESS THAN (value) ... ]
)

where

- col_name is the name of one column of type DATE or DATETIME or
  TIMESTAMP
- at least one partition is supplied
- INTERVAL interval is a time interval

When performing DML on such a table, it will first add partitions
by the specified interval until the partition covers the current time.

Partition addition will not cause an implicit commit like DDL normally
does.

The partitions are named pN.

Otherwise the table behaves exactly the same as a normal RANGE COLUMNS
partitioned table.

Note that TIMESTAMP is not allowed as a type for PARTITION BY RANGE
COLUMNS otherwise.
a4993c3dce5f...
a4993c3dce5f47e2999ae787e421b146c5dc45e6
Monty
Set blob pointer to null with bzero()

This is to avoid storing a pointer into an unaligned address.
a20023bd57d8...
a20023bd57d810a6bfea92a62f4ee9e95022ac48
Hemant Dangi
High priority MDL_BACKUP_COMMIT_HIGH_PRIO and Slave-side BACKUP-COMMIT
tracking to prevent parallel-slave/backup deadlock

A parallel-slave worker that has acquired MDL_BACKUP_COMMIT and is
waiting for a prior commit can be deadlocked by an incoming
BACKUP STAGE BLOCK_COMMIT: the prior commit needs MDL_BACKUP_COMMIT too
but the standard fairness rule denies it while the backup X-request is
in the waiting queue.

Design
------
Add MDL_BACKUP_COMMIT_HIGH_PRIO, a sibling lock mode of
MDL_BACKUP_COMMIT. The only matrix difference is one cell of
m_waiting_incompatible: HIGH_PRIO is granted even when a BACKUP
X-request is waiting.

A committing parallel-slave worker:
1. registers its sub_id in backup_team,
2. queries has_higher() — true iff a teammate in the same domain has
a strictly greater sub_id,
3. requests MDL_BACKUP_COMMIT_HIGH_PRIO if true, otherwise
MDL_BACKUP_COMMIT,
4. unregisters after release_lock().

Register-before-decide ordering ensures that any teammate arriving
later observes our sub_id, and we observe at least our own back.

How it solves the problem
-------------------------
When backup's X-request is in the waiting queue and a worker that is
needed to unblock a prior commit arrives, that worker observes a
later-numbered teammate already holding the BACKUP lock, requests
HIGH_PRIO, and is granted past the X-request via the matrix. The
prior-commit chain drains; the backup X-request is then granted.
9447598c37bb...
9447598c37bb357f3865fd1cf50400131ee667fc
Vladislav Vaintroub
MDEV-39719 Fix memory allocation errors on Windows ARM64 CI

Do not overload the machine. Huge reservation seem to stress
Windows on ARM64 memory management, so that random OOM can appear
when multiple processes are constantly allocating/deallocating
memory. Reduce number of parallel threads to 2. The  bottleneck
on this machine is disk IO, so it does not reduce total test time.
93db1d0891cb...
93db1d0891cbe556d55cb68a6d8dc976ab02d864
Vladislav Vaintroub
improve MTR bootstrap performance on slow disk

use --debug-no-sync to workaround slow disk flush.
On Github actions Windows ARM64, this alone cuts the test time from
ca 55 min to ca 45 min.
90b029f2c9f6...
90b029f2c9f6d065267a825eac087d8cde20b618
ParadoxV5
MDEV-6589: Remove `have_debug_sync` requirement

The test for `rpl.rpl_parallel_mdev6589` required
`include/have_debug_sync.inc` but did not use `@@debug_sync`
(besides RESETting it during cleanup). It uses `MASTER_GTID_WAIT()`.
8963f828d520...
8963f828d52098ccdb2a37af797402d7d05841a1
Vladislav Vaintroub
x
87399cbcf9d7...
87399cbcf9d709af37eb5a76ada3ec3847d59f9f
Andrei Elkin
MDEV-36025 Parallel slave concurrent BACKUP MDL locking with ongoing backup..

The problem the patch tackles is that the binlogging parallel slave
can expose prepared state of transactions to the backup process.
That is the latter can enroll such transactions, typically waiting for
prior commits - in other words *undecided* (of whether they are going
to commit at all - sic!), into backup image.

The technical possibility of that owes to earlier deadlocks fixes in this area
that made the parallel slave worker to re-acquire its BACKUP MDL within
the wait-for-prior commit phase (which is post- engine prepare) one.

Note the --skip-log-bin or --log-slave-update=OFF parallel slave is
not vulnerable to the exposure of its prepared transactions.

The fixes this patch provides make sure the backup image contains only
transactions that are (binlog-order) committed, while
parallel slave does not deadlock (MDEV-23586).

The principal part of the fixes implements leapfrogging of a waiting
"high-priority" BACKUP MDL by a slave parallel worker which is
exemplified in the following. First mind about notations:

  here (as elsewhere in the patch) `Fn` group commit followers
  indexed by the gtid seq-no `n`; `F|xyz` indicates the execution
  status (timing) of the MDL request.  `B` - stands for backup
  thread; `Si,Xk` are BACKUP share and exclusive MDL sequenced by
  `i,k` that are logical times of the MDL acquisition; The
  semi-column separates the granted head of the lock queue from the
  waiters.

The queue below is the BACKUP MDL queue.

| which initially is
|
| [Initial Queue State]
| GRANTED            ; WAITING QUEUE
| ----------------------------------
| S1(F2)            ; X2(B)
|
| Next it receives
|                    <- Incoming Request: S3(L1)
| the scheduler having the following context
| [Scheduler Evaluation]
| Requestor: L1 (gtid_sub_id = 1)
| Holder  : F2 (gtid_sub_id = 2)
| Condition: holder->gtid_sub_id > requestor->gtid_sub_id  (2 > 1) -> TRUE!
|  Action  : ignore_mdl_priority = true. L1 bypasses the waiting X2 lock.
|
| decides where to place it
|
| [Final Queue State]
| GRANTED            ; WAITING QUEUE
| ----------------------------------
| S1(F2), S3(L1)    ; X2(B)

| so it chooses to team up L1,F2 correctly. Any next S4(F_n), where n > 2
| won't be granted which means F_n will wait for the backup completion.
| Like this
|
| [Final Queue State]
| GRANTED            ; WAITING QUEUE
| ----------------------------------
| S1(F2), S3(L1)    ; X2(B),S4(F3)

The decision to allow S3 leapfrog X2 requires the current lock holder
F2 to have a greater gtid_sub_id (2 > 1).

To implement this scheduling policy requires the following modifications.

P1 sql/mdl.h
    The new method determines whether a BACKUP lock requester is a teammate
    of a group that can share the MDL lock and that there exists at least
    on granted member of the group.

    +MDL_request::bool (*is_teammate_callback)(const THD*, const THD*);

P2. sql/log.cc
    dismantling of mdl_context.{release,acquire}_lock() in the parallel worker
    wait-for-prior commit

P3. sql/handler.cc

    setting the P1 MDL_request::is_teammate_callback to the slave parallel worker
    as hint to try acquiring the MDL lock by team membership.

P4. sql/rpl_rli.cc
    defines the teammate callback for the parallel slave.

    +rpl_group_info::ignore_mdl_priority

P5. sql/handler.cc
    Logics of "careful" release of the MDL lock could not be streamlined.
    The failed parallel slave worker still has to abide with the former policy of
    ``` as there is extra replication
    book-keeping to be done before rolling back and allowing a conflicting
    transaction to continue (MDEV-7458).``` [ha_commit_trans].

    For that reason of MDEV-7458 the BACKUP MDL request's memory is now allocated
    for the worker in THD::st_transaction::mem_root. Also guards are deployed to not let
    the mem-root be be cleaned too early, before the lock gets released. It can be
    released fast to follow with transaction->cleanup() for
    not failing trx:s.
    Failing to commit parallel workers defer that to Relay_log_info::cleanup_context()
    from where now ha_rollback_trans() will make it.

Aslo necessary changes are caused by to the gtid implicit statement's design.

1. sql/sql_class.cc
  Removed earlier backup-on-parallel-slave bugfixes of MDEV-23586.
  The parallel worker does not release anymore BACKUP MDL at its wait-for-prior
  commit stage.

2. sql/sql_lex.h, sql/sql_base.cc, sql/rpl_gtid.cc
  Has to be introduced
    +#define TL_OPTION_GTID_TABLE_SLAVE      64

  as a part of a method to find out (see open_table() hunk) at
  executing record_gtid() by implicit GTID statement that its
  BACKUP MDL lock (however it is necessary - it is not challenged
  here) needs the ignore-priority hint. Note this hint applies for granting
  a "special" S' share locked not yet the commit time  ha_commit_trans()'s
  MDL_BACKUP_COMMIT (denoted as S) lock, which is going to be requested later.

  Let's exemplify it on the following diagrams, calling S' a sort of
  shared lock, compatible with with S of the commit time.

  *Without* the teammate hint the request for S'3(F2) at record_gtid() time

        S1(F3|wait_for_prior_commit); X2(B) <- S'3(F2|record_gtid)

  would end up to wait behind X2

        S1; /* waiting */ X2, S'3

  and we'd be regress back to hang/deadlock of earlier bugs: F3 would not be
  awaken by F2 who is blocked by B.

Tested with extended set of parallel slave with backup scenarios.

This commit must require more and extensive testing and may cause
followup amendments, through review comments as well.

Co-authored-with: [email protected].
8116dc911504...
8116dc91150459413375e1f7c7787465e95c3bad
Daniel Black
MDEV-37664: main.lotofstack fails with MSAN+Debug

Under MSAN+Debug this test case exceeds the stack
early without the stack detection mechanism to
identify that it passed its limit.
6b1093c5fa61...
6b1093c5fa61b5dc50e9c6f28af9ba29dbaa26ea
Raghunandan Bhat
MDEV-39227: Schema Versioning - Server-side

- SQL layer infrastructure for multiple versions of a table definition.
- No storage engine changes; any DDLs that depends on the engine or .frm
  re-write for persistance is not yet supported.
- binlog/replication, DDL log for crash recovery are not supported yet.
5b073aa2fc10...
5b073aa2fc10be536ad6a452da1b2e049030d067
Rex Johnston
MDEV-39492 Parallel Query: Study how to create worker threads

Introduces parallel_worker_threads variable to control the number
of worker threads created by a parallel execution query.

2 new files, sql_parallel_workers.h sql_parallel_workers.cc which
contain structures for the creation, management and deletion of
parallel worker threads (pwt_ in the name).  Main management
class created in the stack in JOIN::exec, implemented for the
top level select.

Current parallel_worker_thread_func sleeps for 10 seconds, generates
a warning, signals the main thread, sleeps 10 seconds, signals the
main thread again, sets it's finished flag and cleans it's THD.

The main thread loops through worker threads, looking for finished
thread and cleans them up if they have finished.
It then waits for a signal, then processes it's message queue.

Threads are registed in server_threads, so are visible in
information_schema.processlist and the show processlist command.

We check that a kill query on a parallel worker is passed onto it's
manager and the query is properly aborted, and that a kill connection
is handled properly in parallel_worker.test.

Review input 1: cleanup earlier

Do cleanup before we've finished sending the result to the client.
This way, one can see the errors (and eventually warnings) marshalled
back to the main thread and returned to the user:

MariaDB [test]> set parallel_worker_threads=10;
Query OK, 0 rows affected (0.001 sec)

MariaDB [test]> select seq from seq_1_to_10;
ERROR 4103 (HY000): Argument to the worker_busted_function() function does not belong to the range [0,1]
4b75caf71326...
4b75caf71326a6bf910ce1618065e0c3e9f6fa0f
ParadoxV5
Fix operator typo in `||` chain

There is a `,` breaking the chain; it will make the sub-chain
after it ignore any failure from the sub-chain before it.

This change was originally **unsolicitedly** suggested by Gemini;
that is, I did not activate Gemini nor provide any prompt,
but rather the CI-triggered Gemini comment came to me like junk mail.
By verifying the bot output and creating this patch independently
*without AI assistance*, I confirm I understand the change and
can claim its authorship and responsibility,
and *I remain have never provided AI-generated code*.

Co-authored-by: gemini-code-assist <[email protected]>
4ae2e2c1fdf6...
4ae2e2c1fdf62956274b41d1bf8220262a487596
Vladislav Vaintroub
1
497aa5506c39...
497aa5506c39c27f03fbd281daff5a14892de253
Pekka Lampio
MDEV-37990: redundant Table map events in binlog

This patch modifies how a Galera slave node writes Table map events to
binary log. Now a Galera slave does not write duplicate Table Map
events to binary log.
42f038a925a4...
42f038a925a42caeaa080a183b2f0976409adc97
Andrei Elkin
High priority MDL_BACKUP_BLOCK_COMMIT_RPL

When the standard request of MDL_BACKUP_COMMIT is not granted to a worker
it first searches for a possible grantee that is a parallel slave
worker and if there exist one with greater commit order the request
type is escalate to the highest which is re-submitted.

To the changes in sql_base.cc,
note there also exist a request of the highest (new) type at time of
Xid_apply_log_event::do_record_gtid which is a committing phase of
slave transaction when it is executing an implicit statement.
It must be able to bypass any waiting lock by backup process even
without yet knowing whether the transaction is going to be enrolled
into a pending to commit slave group. When later it turns out
not the case the strong MDL_STATEMENT requested lock would've been
already relinquished.

Tested with previous commit's  refined and extended BASE's
  rpl.parallel_backup, rpl.rpl_parallel_backup_worker_retry
and new added
  rpl.rpl_parallel_backup_waits_worker_retry

Todo:
According to Svoj's review, this patch still needs
removing the slave specific code from the MDL.
That is changes in MDL_context::acquire_lock().

Probably
ha_commit_trans() would call first
    try_acquire_lock_impl()
when it returns empty ticket a part of the added to acquire_lock
Teammate-Aware Escalation Check would be invoked just to compute
`has_teammate` and when that is true to call the whole BASE version
of MDL_context::acquire_lock() having the highest type of request.
391353b4aad5...
391353b4aad5aeb8d09246f391140c8290135b4f
Yuchen Pei
MDEV-15621 [refactor] Partitioning cleanup

change p_column_list_val::fixed to a bool
remove redundant end label in partition_info::fix_column_value_functions
2bcbb17197c0...
2bcbb17197c0416083f9005a1e7eafed29357fab
Arcadiy Ivanov
MDEV-39723, MDEV-39724: fix `hp_key_cmp()` blob packlength

`hp_key_cmp()` hardcoded `packlength=4` for the record side of blob
segment comparison. This is wrong when `Field_blob_key` preserves
the original blob subtype's packlength (1-4) via
`set_pack_length(blob_handler->length_bytes())`.

Use `seg->bit_start` (the actual packlength) instead. Update comments
in `hp_key_cmp()` and `hp_make_key()` to document the asymmetry
between record-side format (packlength-byte length prefix) and
key-side format (always 4-byte normalized length from `hp_make_key()`).
2892a1a5d269...
2892a1a5d269d7108e267a3c5334e0d798a754a7
PranavKTiwari
Added logic for virtual column.
24fb862c51f3...
24fb862c51f3a54bf29685f035392ade9ddffa77
Pekka Lampio
MDEV-37990: redundant Table map events in binlog

This patch modifies how a Galera slave node writes Table map events to
binary log. Now a Galera slave does not write duplicate Table Map
events to binary log.
23a650b40a03...
23a650b40a03d4dc8f0742bfeb52657c0c4124ab
ParadoxV5
Fix operator typo in `||` chain

There is a `,` breaking `Table_map_log_event::write_data_body()`’s
`||` chain.
This “comma operator” still connects the expressions,
but if a step in the first sub-chain fails,
the code will disregard the failure and continue with the second half-chain.

This change was originally **unsolicitedly** suggested by Gemini;
that is, I did not activate Gemini nor provide any prompt,
but rather the CI-triggered Gemini comment came to me like junk mail.
By verifying the bot output and creating this patch independently
*without AI assistance*, I confirm I understand the change and
can claim its authorship and responsibility,
and *I remain have never provided AI-generated code*.

Co-authored-by: gemini-code-assist <[email protected]>
1dbde772e68a...
1dbde772e68a96b4b689693ef21cd9506388f8e1
Alexander Barkov
MDEV-39518 Allow prepared statements in stored functions in assignment right hand

In progress
1d64dd410164...
1d64dd4101640bf09d5063651d89566b73590bdc
Vladislav Vaintroub
Revert "MDEV-39719 Fix memory allocation errors on Windows ARM64 CI"

This reverts commit 9a52192c0b518b0b5455bafe3906606ff8a73514.
0ee340c9747e...
0ee340c9747ec692af53fde2e45e45f0e8fb511b
Yuchen Pei
MDEV-15621 Auto add RANGE COLUMNS partitions by interval

Allow auto partitioning by interval in PARTITION BY RANGE COLUMNS

PARTITION BY RANGE COLUMNS (col_name)
INTERVAL interval [AUTO]
(
  PARTITION partition_name VALUES LESS THAN (value)
  [, PARTITION partition_name VALUES LESS THAN (value) ... ]
)

where

- col_name is the name of one column of type DATE or DATETIME
- at least one partition is supplied
- INTERVAL interval is a time interval

When performing DML on such a table, it will first add partitions
by the specified interval until the partition covers the current time.

Partition addition will not cause an implicit commit like DDL normally
does.

The partitions are named pN.

Otherwise the table behaves exactly the same as a normal RANGE COLUMNS
partitioned table.
0caa09104a21...
0caa09104a21dd3497285c8baa182102f3007465
Rex Johnston
MDEV-39492 Parallel Query: Study how to create worker threads

Introduces parallel_worker_threads variable to control the number
of worker threads created by a parallel execution query.

2 new files, sql_parallel_workers.h sql_parallel_workers.cc which
contain structures for the creation, management and deletion of
parallel worker threads (pwt_ in the name).  Main management
class created in the stack in JOIN::exec, implemented for the
top level select.

Current parallel_worker_thread_func sleeps for 10 seconds, generates
a warning, signals the main thread, sleeps 10 seconds, signals the
main thread again, sets it's finished flag and cleans it's THD.

The main thread loops through worker threads, looking for finished
thread and cleans them up if they have finished.
It then waits for a signal, then processes it's message queue.

Threads are registed in server_threads, so are visible in
information_schema.processlist and the show processlist command.

We check that a kill query on a parallel worker is passed onto it's
manager and the query is properly aborted, and that a kill connection
is handled properly in parallel_worker.test.

Review input 1: cleanup earlier

Do cleanup before we've finished sending the result to the client.
This way, one can see the errors (and eventually warnings) marshalled
back to the main thread and returned to the user:

MariaDB [test]> set parallel_worker_threads=10;
Query OK, 0 rows affected (0.001 sec)

MariaDB [test]> select seq from seq_1_to_10;
ERROR 4103 (HY000): Argument to the worker_busted_function() function does not belong to the range [0,1]

Assisted by Sergei Petrunia and Claude Code.
0afea08565c6...
0afea08565c60007c595d3c602a9158a4931ce61
Yuchen Pei
MDEV-15621 Auto add RANGE COLUMNS partitions by interval

Allow auto partitioning by interval in PARTITION BY RANGE COLUMNS

PARTITION BY RANGE COLUMNS (col_name)
INTERVAL interval [AUTO]
(
  PARTITION partition_name VALUES LESS THAN (value)
  [, PARTITION partition_name VALUES LESS THAN (value) ... ]
)

where

- col_name is the name of one column of type DATE or DATETIME
- at least one partition is supplied
- INTERVAL interval is a time interval

When performing DML on such a table, it will first add partitions
by the specified interval until the partition covers the current time.

Partition addition will not cause an implicit commit like DDL normally
does.

The partitions are named pN.

Otherwise the table behaves exactly the same as a normal RANGE COLUMNS
partitioned table.
0809eac52ef5...
0809eac52ef52a0cb64aff674f771b28a2eca898
PranavKTiwari
Modified logic.
04dd82c41efc...
04dd82c41efc00f4a9eefe5a3e1862322e5c80e9
Arcadiy Ivanov
MDEV-39732: fix row-based replication of DELETE on HEAP blob tables

`handler::ha_delete_row()` calls `binlog_log_row()` AFTER
`delete_row()` returns. For HEAP blob tables, `heap_delete()` was
freeing continuation chains immediately, overwriting chain records
with free-list `del_link` pointers. The zero-copy pointers in the
record buffer (used by the binlog to read blob data) became dangling,
causing corrupted replication events.

**Fix**: split the blob free path by table type:

- **Internal temporary tables** (`share->internal`): free chains
  immediately via `hp_free_blobs()` — these are never binlogged.

- **User-created MEMORY tables**: defer the free by saving chain
  head pointers into `HP_INFO::pending_blob_chains` (one per blob
  column, allocated once at `heap_open_from_share()`). The flush
  runs on the next mutating operation (`heap_write`, `heap_update`,
  `heap_delete`) or on `heap_reset`/`heap_close`.

`heap_clear()` (TRUNCATE) invalidates `has_pending_blob_free`
without flushing, since the HP_BLOCK tree is already destroyed.

Also fixes `hp_free_blobs()` to skip zero-length blobs (avoids
chasing a NULL chain pointer) and `heap_update()` to NULL the
chain pointer slot for unchanged zero-length blobs (prevents
stale SQL-layer pointers from being misread as chain heads).
BuildBot (0.8.9) working for the MariaDB project.
Page built: Tue 26 May 2026 08:42:34 (UTC)