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
f51edd8933e3...
f51edd8933e3b7c9e796864c7e6c61e25828b4b4
Fariha Shaikh
MDEV-39153 Fix sporadic main.change_master_default mismatch

The test used "restart_abort:" in the expect file, which MTR never
recognized. It fell through to the else branch, deleted restart_opts,
and started the server with defaults (heartbeat_period=60 instead of 0).

Replace restart_abort with direct --exec $MYSQLD calls.

All new code of the whole pull request, including one or several files
that are either new files or modified ones, are contributed under the
BSD-new license. I am contributing on behalf of my employer Amazon Web
Services, Inc.
f033f5a9ec56...
f033f5a9ec569742597c36e8ac0cc446de00f1c3
Mohammad Tafzeel Shams
MDEV-35154 : dict_sys_t::load_table() is holding exclusive dict_sys.latch
for unnecessarily long time

Issue:

dict_load_table_one() was invoked with the exclusive dict_sys.latch held
and never released it. The whole load ran inside that one critical
section: reading the SYS_TABLES record, opening the .ibd file, and
reading SYS_COLUMNS, SYS_VIRTUAL, SYS_INDEXES, SYS_FIELDS, the clustered
index root page, and SYS_FOREIGN, as well as loading every table related
by FOREIGN KEY constraints.

Almost all of that is I/O. Because dict_sys.latch is the single latch
that guards every dictionary lookup, one cold table open blocked every
other session from opening any table, including tables that were already
cached. A slow enough load could trigger the fatal semaphore wait check.

Fix:

Split the load into three phases. A short latched phase creates the
table object and publishes it as an incomplete "stub"; the I/O runs with
no latch held; a final latched phase links the FOREIGN KEY constraints.
The stub is marked with the new dict_table_t::loading, which hides it
from dict_sys_t::find_table(), so other threads treat it as not cached.
A thread that needs exactly that table waits on a condition variable and
retries its lookup, while all other tables can be looked up and loaded
concurrently.

dict_table_t::loading has three states. A table remains hidden
(LOADING_FK) until every table related to it by FOREIGN KEY constraints
has been loaded as well, and dict_sys_t::load_table() makes them visible
in one step. The intermediate state is visible to constraint linking via
the new dict_sys_t::find_table_fk(), so that two threads loading tables
that reference each other can still link the constraint between them.

Tables that InnoDB internal SQL can refer to are loaded without ever
releasing the latch. The internal SQL parser is not reentrant and is
serialized only by the exclusive dict_sys.latch, and it opens tables in
the middle of parsing; releasing the latch there let another thread run
the parser concurrently and corrupt its state.

Changes:

-  dict_load_table_one() : publish the table as a LOADING_DEF stub in
  table_non_LRU and release the latch before loading the tablespace,
  the columns and the indexes; reacquire it, move the table to
  table_LRU and mark it LOADING_FK before loading the foreign key
  constraints. Failures now remove the published stub and signal the
  waiting threads instead of only freeing the object. Add the
  hold_latch parameter and the dict_load_table_one_no_latch debug sync
  point.

-  dict_sys_t::load_table() : wait for a concurrent load of the same
  table; allocate the foreign key table names on a local heap, because
  the latch is released while draining them; in the drain loop, wait
  for a table whose definition is still being loaded by another thread
  and skip one that is only waiting for its own related tables; make
  all tables loaded by this invocation visible in one step and signal
  the waiting threads.

-  dict_load_hold_latch() : Whether a table may be referenced by
  InnoDB internal SQL, and therefore must be loaded without releasing
  the latch: InnoDB system tables, FULLTEXT INDEX auxiliary tables and
  the persistent statistics tables.

-  dict_load_table_on_id() : copy the table name and release the
  SYS_TABLES page latch before calling load_table(), which may now
  block. Restore the cursor position only if the scan has to continue.

-  dict_load_foreign(), dict_load_foreigns() : add the fk_heap
  parameter and allocate the names appended to fk_tables on it; the
  heap of the referenced table would not survive the release of the
  latch. Resolve both sides with find_table_fk().

-  dict_table_t : add NOT_LOADING, LOADING_DEF, LOADING_FK and the
  Atomic_relaxed<byte> loading member, plus debug load_thread and
  is_loader(). loading is a separate atomic and not a bit-field,
  because the loader modifies the neighbouring bit-fields without
  holding any latch.

-  dict_sys_t : add load_mutex, load_cond, find_table_any(),
  find_table_fk(), load_wait(), load_done(), allow_eviction(), and
  document that load_table() may release and reacquire the latch.

-  dict_load_foreigns() : add a fk_heap parameter for the names appended
  to fk_tables.

-  dict_sys_t::find_table_any() : the previous body of find_table(),
  returning tables that are being loaded. Only the name is read.

-  dict_sys_t::find_table() : hide tables that are being loaded, both in
  the by-name and the by-id variant. In the by-id variant, loading is
  checked before any bit-field, to avoid a torn read.

-  dict_sys_t::find_table_fk() : like find_table(), but LOADING_FK
  tables are returned, so that constraints can be linked into them
  while holding the exclusive latch.

-  dict_sys_t::load_wait(), dict_sys_t::load_done() : wait for and
  signal the completion of a load. load_wait() acquires load_mutex
  before releasing the latch, so that the wakeup cannot be lost.

-  dict_sys_t::create(), dict_sys_t::close() : initialise and destroy
  load_mutex and load_cond.

-  dict_table_can_be_evicted() : a table that is being loaded may only
  be freed by the thread that is loading it.

-  dict_foreign_add_to_cache() : resolve both sides with
  find_table_fk().

-  btr_search_disable() : skip tables that are being loaded. Walking
  their indexes would race with the loading thread, which appends to
  that list without holding the latch. Such tables cannot have any
  adaptive hash index references.

-  create_table_info_t::create_foreign_keys() : prevent the eviction of
  a referenced table as soon as it is resolved. The pointer is stored
  in a dict_foreign_t that is not in any referenced_set yet, so
  dict_sys_t::remove() would not clear it.

-  create_table_info_t::create_table() : acquire a reference to the
  created table around the foreign key handling, and use a local heap
  for the names of the foreign key related tables.

-  assertion fix : The load path may now run without dict_sys.latch, but only in the
  thread that is loading the table, and a cached table is no longer
  necessarily fully loaded. dict_sys.locked() is relaxed to
  "dict_sys.locked() || table->is_loader()" in dict_load_columns(),
  dict_load_virtual_col(), dict_load_fields(), dict_load_indexes(),
  dict_index_add_to_cache(), dict_index_find_cols(),
  dict_index_build_internal_clust(),
  dict_index_build_internal_non_clust() and
  dict_index_build_internal_fts(). Checks of dict_table_t::cached are
  relaxed and reordered after the atomic loading in
  dict_table_add_system_columns(), dict_sys_t::add(),
  dict_table_rename_in_cache() and hash_insert().

-  innodb.dict_load_concurrent
  A load is parked at dict_load_table_one_no_latch while
  holding no latch; another table can be loaded meanwhile, and a
  second opener of the same table waits. A second case checks that a
  table is not made visible while a table related to it by a FOREIGN
  KEY constraint is still being loaded by another thread.
e56f1666152f...
e56f1666152fc7e0ff08fd2685dbbb274c488117
Rex Johnston
PQ introduce transport API, batch transport, tmp table transport
e2b15641ecbb...
e2b15641ecbbad3a827fb9aeaa793e9a99aa5d57
Oleksandr Byelkin
Merge branch '10.6' into 10.11
cbaec9b89fb1...
cbaec9b89fb1ea88b2e7f6f77ab1a981827dd21f
Sergei Petrunia
Make sql_parallel_thread self-contained

- Move 'reaped' and 'kill_signal' OUT to sql_parallel_workers
- Move 'workers' and 'nworkers' OUT to sql_parallel_workers
- Move server_threads update logic IN.
c62d7895c35c...
c62d7895c35cafe00a0d516778ddfbd2ab66028e
Daniel Black
sql_test: mallinfo2 msan exclusion no longer needed

MSAN interceptor was added in clang-18.1.
bc3939b84b71...
bc3939b84b71baa816cf9011fd04f7bbbf43dffd
Daniel Black
MDEV-17846 Wrong result with grouping select (fix)

Prevent unused variable 'ref_type'  warnings on non-debug builds.
bb0ac437015d...
bb0ac437015dec04fbee226745a8eb2bb4825917
Yuchen Pei
MDEV-40486 Length check for vector fields in CREATE TABLE ... SELECT

The changes of MDEV-39558 2b6529426a7e7c65d286e093d84138be9dcc34a3
added length check assertion in Field_varstring constructors, and
length check in type inference for SELECT set operations, to emit
errors before reaching the assertions.

That change caused an error to turn into an assertion failure in a
separate path, when the length limit violation is not detected before
tripping the assertion. So in this patch we fix it by adding an
earlier length check in that path.

The reason that we place this check inside
Item_func_vec_fromtext::fix_length_and_dec rather than say
`create_field_for_create_select is for consistency:

If

create table t1 as select
vec_fromtext(concat('[',group_concat(1),']')) as c1 from seq_1_to_64;

fails due to length limit violation, then so should

create table t1 (v vector(64) not null);
insert into t1 select vec_fromtext(concat('[',group_concat(1),']'))
from seq_1_to_64;

Also use max_char_length() instead of max_length. This is a more
accurate length of characters. And add handling of empty string edge
case. Added testcases accordingly.

The change that uses max_char_length() causes side effects where
creating a table using a VEC_FROMTEXT(CHAR(1)) would result in a
0-dimensional vector field. This is accurate but 0-dim vector table
fields should not be allowed. So we make cases like this result in
a one-dimensional field.

Also fixed the underflow in (args[0]->max_length - 1) * 2 when the
arg's max length is 0. Previously this underflow would cause

create table t1 select vec_fromtext(NULL)

to fail with ER_TOO_BIG_FIELDLENGTH. Now it will be a VECTOR(1) field
afc7105ae8db...
afc7105ae8db8a9d1bab089a89755ae9fdceeb7b
bsrikanth-mariadb
MDEV-39226: Push whole multi-table update/delete down into engines

Give storage engines a way to take over an entire multi-table
UPDATE/DELETE, the way they can already take over a SELECT. Without it the
join, the row matching and every modification run in the SQL layer even
when an engine could do the whole statement itself in one step; a
single-table UPDATE/DELETE already avoids this via
direct_update_rows()/direct_delete_rows(), but a multi-table statement has
no primary handler object to drive that path.

This adds a generic, engine-agnostic pushdown interface: the SQL layer
offers the statement to the engine, and if the engine accepts it, it
performs the whole thing and reports only the row counts.

- Split select_handler into a pushdown_handler base with select_handler
  (result set) and a new multi_upddel_handler (runs a whole UPDATE/DELETE,
  reports row counts, reported as PUSHED UPDATE/PUSHED DELETE); add
  handlerton::create_multi_upddel, looked up in Sql_cmd_dml::execute_inner().
- multi_update/multi_delete gain direct_update_delete_done(), which records
  the engine's counts so send_eof() binlogs and replies without the
  SQL-layer loop; it forces statement-format binlogging so the change still
  replicates under binlog_format=ROW, and errors out instead of silently
  dropping counts for an unsupported result object.
- FederatedX implements the interface as the reference engine used to test
  correctness: it prints the statement back and runs it remotely, passes
  the engine's error code/SQLSTATE through, reads the matched count from the
  remote info string, executes IGNORE locally, and only pushes down when all
  tables share one remote server (same as SELECT/derived/unit pushdown).

Test: federated.federatedx_pushdown_upd_del.
add639919887...
add63991988734383c5e942de2a19c6c45f511f7
Alexander Barkov
MDEV-40790 SELECT INTO row_type_of.field crashes the server

The server crashed on DBUG_ASSERT on a SELECT into:
- a `ROW TYPE OF table1` field variable
- a `ROW TYPE OF cursor1` field variable

Fix:

- Adding a class my_var_sp_row_field_by_name
- Adding a method sp_rcontext::set_variable_row_field_by_name()
- Fixing the DBUG_ASSERT
a1d102cf3372...
a1d102cf33722eed4dd500a405231994a7305499
Sergei Petrunia
Move all thread creation/cleanup into sql_parallel_thread.*

The cleanup API is not yet very pretty.
9da8bfff1662...
9da8bfff16626f7fa01aeacdc60974c0f6678a06
Yuchen Pei
MDEV-40168 wip

works:

SET SESSION debug = '+d,test_invisible_index,test_completely_invisible';
create table t1 (c int, j json, key idx ((CAST(j->'$.tags' AS CHAR(6) ARRAY))))engine=innodb;
SHOW CREATE TABLE t1;
Table Create Table
t1 CREATE TABLE `t1` (
  `c` int(11) DEFAULT NULL,
  `j` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL CHECK (json_valid(`j`))
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_uca1400_ai_ci
show index from t1;
Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Ignored
t1 1 invisible1 1 invisible1 A 0 NULL NULL YES BTREE NO
t1 1 idx 1 DB_MVI_1 NULL NULL NULL NULL YES FULLTEXT NO
set @old_innodb_ft_aux_table=@@global.innodb_ft_aux_table;
set global innodb_ft_aux_table='test/t1';
insert into t1 values (1, '{"tags": ["1", "abcde", "34567"]}');
SELECT * FROM INFORMATION_SCHEMA.INNODB_FT_INDEX_CACHE;
WORD FIRST_DOC_ID LAST_DOC_ID DOC_COUNT DOC_ID POSITION
34567 1 1 1 1 2
abcde 1 1 1 1 1
DROP TABLE t1;
set global innodb_ft_aux_table=@old_innodb_ft_aux_table;
select mvi_encode('[1, 42, 3]', int);
mvi_encode('[1, 42, 3]', int)
8000000000000001 800000000000002a 8000000000000003
9760800bd042...
9760800bd042381325745c41642547c065de05e7
Sergei Petrunia
Make sql_parallel_thread module isolated.

This required adding
virtual pwt_worker_base::on_fatal_error()

which pwt_worker overrides.

pwt_manager_base doesn't track if fatal_error has occurred
Should it? fatal_error is in sql_parallel_workers...
970492062d91...
970492062d91cd606dd3f6f8a52bd51cf746ab4f
drrtuy
chore: remove jemalloc extension from DuckDB CMake b/c since 1.5.4 is is a part of DuckDB core.
93e051860a9c...
93e051860a9c7e87ee8cee6ed38b640d491f7170
Daniel Black
MDEV-40801 ppc64le ro_after_init isn't pagesize aligned

Align ro_after_init using MAXPAGESIZE instead of COMMONPAGESIZE.

COMMONPAGESIZE may be smaller than the actual page size supported by
the target ABI. This can leave ro_after_init sharing an OS page with
adjacent sections, causing mprotect() to change permissions on data
outside ro_after_init.

Use MAXPAGESIZE so the section boundaries are aligned to the maximum
page size required by the target linker/ABI.

This is particularly important on architectures such as ppc64le and
aarch64, where the runtime page size can differ from COMMONPAGESIZE.

Before:
  .data          0x...1b80000
  ro_after_init  0x...1c70000
  .bss          0x...1c72000

After:
  ro_after_init starts and ends on MAXPAGESIZE boundaries, ensuring
  mprotect() only affects pages belonging to ro_after_init.

Co-authored-by: ChatGPT GPT-5.6 Luna <[email protected]>
9247d4d2589b...
9247d4d2589b144c904b36ab18d707ab931f764d
bsrikanth-mariadb
MDEV-39226: Push whole multi-table update/delete down into engines

Give storage engines a way to take over an entire multi-table
UPDATE/DELETE, the way they can already take over a SELECT. Without it the
join, the row matching and every modification run in the SQL layer even
when an engine could do the whole statement itself in one step; a
single-table UPDATE/DELETE already avoids this via
direct_update_rows()/direct_delete_rows(), but a multi-table statement has
no primary handler object to drive that path.

This adds a generic, engine-agnostic pushdown interface: the SQL layer
offers the statement to the engine, and if the engine accepts it, it
performs the whole thing and reports only the row counts.

- Split select_handler into a pushdown_handler base with select_handler
  (result set) and a new multi_upddel_handler (runs a whole UPDATE/DELETE,
  reports row counts, reported as PUSHED UPDATE/PUSHED DELETE); add
  handlerton::create_multi_upddel, looked up in Sql_cmd_dml::execute_inner().
- multi_update/multi_delete gain direct_update_delete_done(), which records
  the engine's counts so send_eof() binlogs and replies without the
  SQL-layer loop; it forces statement-format binlogging so the change still
  replicates under binlog_format=ROW, and errors out instead of silently
  dropping counts for an unsupported result object.
- FederatedX implements the interface as the reference engine used to test
  correctness: it prints the statement back and runs it remotely, passes
  the engine's error code/SQLSTATE through, reads the matched count from the
  remote info string, executes IGNORE locally, and only pushes down when all
  tables share one remote server (same as SELECT/derived/unit pushdown).

Test: federated.federatedx_pushdown_upd_del.
91156c3de587...
91156c3de58762196605150ab3f756fe952592d1
Alexander Barkov
MDEV-40639 Open SYS_REFCURSOR crash, if many cursors inside a function

Problem:

If:
- A routine A() opened a SYS_REFCURSOR with a function B() in the SELECT list
- The function B() also opened some SYS_REFCURSORs

Then reallocation of the cursor array THD::m_statement_cursors could happen
during the execution of B(), so all sp_cursor_array_element pointers inside
sp_instr_copen_by_ref::exec_core() of routine A() became invalid.

Fix:

Chaging the data type of sp_cursor_array:
- from Dynamic_array<sp_cursor_array_element>
- to Dynamic_array<sp_cursor_array_element*>

So now only reallocations of the array of cursor pointers happen,
while sp_cursor_array_element instances always stay on their originally
allocated memory positions.

Note:
sp_cursor_array_element instances are allocated using the standart C++ "new"
and deleted using the standard C++ "delete". Using a MEM_ROOT does not
seem to be relevant here.
84695e9c0b76...
84695e9c0b762db7ce7e23fc4ac51717b3a77efc
Daniel Black
MDEV-40243 Fix MEMORY_LEAK_C leaks in mariadb-dump  (rockdb tests)

With memory leaks fixed in the rocksdb.mysqldump/mysqldump2 no
longer need to run with leak detection disabled.

There tests are still disabled as there's no --rockdb arg to
mariadb-dump, but removing so there's no precidence to ignoring
leaks.

ref: 2217477fb8fc82f4921d9d13afcd24b1d86b34d6
81bb68ba63b5...
81bb68ba63b59ec5999afea7b1182350761d4de9
drrtuy
chore: add DuckDB version info function.
80f148702140...
80f148702140af15eb384ea51b6b618a10b39ddf
Yuchen Pei
MDEV-40168 wip

works:

SET SESSION debug = '+d,test_invisible_index,test_completely_invisible';
create table t1 (c int, j json, key idx ((CAST(j->'$.tags' AS CHAR(6) ARRAY))))engine=innodb;
SHOW CREATE TABLE t1;
Table Create Table
t1 CREATE TABLE `t1` (
  `c` int(11) DEFAULT NULL,
  `j` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL CHECK (json_valid(`j`))
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_uca1400_ai_ci
show index from t1;
Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Ignored
t1 1 invisible1 1 invisible1 A 0 NULL NULL YES BTREE NO
t1 1 idx 1 DB_MVI_1 NULL NULL NULL NULL YES FULLTEXT NO
set @old_innodb_ft_aux_table=@@global.innodb_ft_aux_table;
set global innodb_ft_aux_table='test/t1';
insert into t1 values (1, '{"tags": ["1", "abcde", "34567"]}');
SELECT * FROM INFORMATION_SCHEMA.INNODB_FT_INDEX_CACHE;
WORD FIRST_DOC_ID LAST_DOC_ID DOC_COUNT DOC_ID POSITION
34567 1 1 1 1 2
abcde 1 1 1 1 1
DROP TABLE t1;
set global innodb_ft_aux_table=@old_innodb_ft_aux_table;
select mvi_encode('[1, 42, 3]', int);
mvi_encode('[1, 42, 3]', int)
8000000000000001 800000000000002a 8000000000000003
select mvi_encode('[1, 42, 3]', unsigned);
mvi_encode('[1, 42, 3]', unsigned)
0000000000000001 000000000000002a 0000000000000003
79520ba4e5b1...
79520ba4e5b17ac69f69a980615ad81f26f6b975
Daniel Black
RocksDB: compile fix std::replace requires algorithm header

Otherwise it compile fails.

Found in clang-24.
77c8f7916181...
77c8f791618136002e5724ca81f365134b583a29
Daniel Black
MDEV-40749 period.create test leaks/faults in asan

Selecting from the information_schema.plugins causes the loading
of all plugins. Because rockdb leaks, and duckdb triggers an
address sanitizer warning on shutdown avoid this table.

Use the information_schema.ENGINES to validate that InnoDB is
disabled per the original request in the review of MDEV-32205.
71fe571600d2...
71fe571600d20d27ed9d91bd9a194f732b98f209
PranavKTiwari
MDEV-38633: Row events in statement based binlog: optimization possible?
A failing multi-table UPDATE or DELETE marked every target temporary table as not up to date in the binary log, even when nothing had been changed.
Any later statement reading such a table was then forced to use row logging.
Only mark the tables when something was actually changed—that is, when rows were updated/deleted or a non-transactional table was modified.
If nothing changed, set THD::tmp_table_binlog_handled so that mark_tmp_table_as_free_for_reuse() does not mark them either.
718dc0812ebb...
718dc0812ebb19d72f823809c1ad0a3eea9c7644
Daniel Black
deb: add Ubuntu stonking as next release
5992b3d00bec...
5992b3d00bec6bdaee4c7dcd3efd9bb8e39e4911
bsrikanth-mariadb
MDEV-39226: Push whole multi-table update/delete down into engines

Give storage engines a way to take over an entire multi-table
UPDATE/DELETE, the way they can already take over a SELECT. Without it the
join, the row matching and every modification run in the SQL layer even
when an engine could do the whole statement itself in one step; a
single-table UPDATE/DELETE already avoids this via
direct_update_rows()/direct_delete_rows(), but a multi-table statement has
no primary handler object to drive that path.

This adds a generic, engine-agnostic pushdown interface: the SQL layer
offers the statement to the engine, and if the engine accepts it, it
performs the whole thing and reports only the row counts.

- Split select_handler into a pushdown_handler base with select_handler
  (result set) and a new multi_upddel_handler (runs a whole UPDATE/DELETE,
  reports row counts, reported as PUSHED UPDATE/PUSHED DELETE); add
  handlerton::create_multi_upddel, looked up in Sql_cmd_dml::execute_inner().
- multi_update/multi_delete gain direct_update_delete_done(), which records
  the engine's counts so send_eof() binlogs and replies without the
  SQL-layer loop; it forces statement-format binlogging so the change still
  replicates under binlog_format=ROW, and errors out instead of silently
  dropping counts for an unsupported result object.
- FederatedX implements the interface as the reference engine used to test
  correctness: it prints the statement back and runs it remotely, passes
  the engine's error code/SQLSTATE through, reads the matched count from the
  remote info string, executes IGNORE locally, and only pushes down when all
  tables share one remote server (same as SELECT/derived/unit pushdown).

Test: federated.federatedx_pushdown_upd_del.
53b1cc014932...
53b1cc0149328c7d3857d9d0d6efbbbc779ac2c2
Alexander Barkov
MDEV-28498 Incorrect information in file: './test/t0.frm' on CREATE TABLE

Applying HEX encoding write writting an ENUM/SET TYPELIB to FRM
if the TYPELIB has 0x00 bytes in the value.

This HEX encoding was earlier used only to write UCS2/UTF16/UTF32 TYPELIBs.

A new flag FIELDFLAG_FRM_HEX_ENCODED_TYPELIB was added to indicate
that the TYPELIB is hex encoded. It's used only inside FRM.
Note, it's mangled with FIELDFLAG_TREAT_BIT_AS_CHAR.
This should not be harmful:
- BIT and ENUM/SET columns are handled by two separate code branches
  when opening an FRM
- The flag is unset immediately after decoding TYPELIB, so the rest
  of the code does not se an unexpected flag combination.
3deb33d367dc...
3deb33d367dcd0f5af038621d728f20e45361053
bsrikanth-mariadb
MDEV-39226: Push whole multi-table update/delete down into engines

Give storage engines a way to take over an entire multi-table
UPDATE/DELETE, the way they can already take over a SELECT. Without it the
join, the row matching and every modification run in the SQL layer even
when an engine could do the whole statement itself in one step; a
single-table UPDATE/DELETE already avoids this via
direct_update_rows()/direct_delete_rows(), but a multi-table statement has
no primary handler object to drive that path.

This adds a generic, engine-agnostic pushdown interface: the SQL layer
offers the statement to the engine, and if the engine accepts it, it
performs the whole thing and reports only the row counts.

- Split select_handler into a pushdown_handler base with select_handler
  (result set) and a new multi_upddel_handler (runs a whole UPDATE/DELETE,
  reports row counts, reported as PUSHED UPDATE/PUSHED DELETE); add
  handlerton::create_multi_upddel, looked up in Sql_cmd_dml::execute_inner().
- multi_update/multi_delete gain direct_update_delete_done(), which records
  the engine's counts so send_eof() binlogs and replies without the
  SQL-layer loop; it forces statement-format binlogging so the change still
  replicates under binlog_format=ROW, and errors out instead of silently
  dropping counts for an unsupported result object.
- FederatedX implements the interface as the reference engine used to test
  correctness: it prints the statement back and runs it remotely, passes
  the engine's error code/SQLSTATE through, reads the matched count from the
  remote info string, executes IGNORE locally, and only pushes down when all
  tables share one remote server (same as SELECT/derived/unit pushdown).

Test: federated.federatedx_pushdown_upd_del.
3b8db4540386...
3b8db4540386791bb0fd2fbf53f397f9ad8c19a0
Oleksandr Byelkin
Merge branch '11.4' into 11.8
3ad0455a2651...
3ad0455a2651a993b3cd8dfceeb893bfb1218a0e
Georgi (Joro) Kodinov
MDEV-40661: mysql_upgrade.test not stable on a busy server

The cleanup of the old connection goes on in the background.
It can take longer on a busy server and this triggers the active sessions
warning in DROP user.
Stablizied the test by disabling the warnings.
282a10a4a795...
282a10a4a7958fd11dcf98a6575664a3aa57ea21
Daniel Black
MDEV-38405 Assertion `tbl->trn == 0' failed in _ma_set_trn_for_table

Aria bulk insert operations disables share->now_transaction meaning
a concurrent open of the stable table will have
trn == &dummy_transaction_object for its MARIA_HA object during opening.

As the _ma_set_trn_for_table is setting the trn, its harmless if the
current trn is the dummy_transaction_object.

Relax the assert to allow for this state.
27508f7a9fb3...
27508f7a9fb35e3114b51930654dbdd8528714e0
Rex Johnston
PQ  optional, TODO: simpler cleanup

... not actually simpler, but tidier.
23b74f8bf663...
23b74f8bf6632a1bded3b14b6949227d1e459d40
Rex Johnston
PQ  optional, TODO: simpler cleanup

... not actually simpler, but tidier.
1a052f27e374...
1a052f27e374fc9b4cb5b1fd098cf10f0e1381cc
Sergei Golubchik
rocksdb: don't abort early in submodule update

Fix for 1fb075512a7aeab8646a163cbb6f265c49f4c075 to allow
the ADD_SUBMODULE to perform updates.
18fce8e1e76a...
18fce8e1e76a5798ac9bf0a9a615b97175e8351a
Sergei Petrunia
MDEV-40738: main.cte_update_delete missing DROP VIEW v1, refers to wrong MDEVs.

Fix the testcase.
171ad9f0d140...
171ad9f0d14019b000aa2c643dbcbc756107952c
Rex Johnston
PQ  tidy up message queue processing, add in missing tests, fix...

in pwt_worker_base::init_worker_thd()
170b1d70737b...
170b1d70737be6f134448f51713cdc1ae215b420
Oleksandr Byelkin
Merge branch '10.11' into 11.4
15fed8d04b1d...
15fed8d04b1dd2fb0baba8d981bf993de0d699aa
Yuchen Pei
MDEV-40168 wip

works:

SET SESSION debug = '+d,test_invisible_index,test_completely_invisible';
create table t1 (c int, j json, key idx ((CAST(j->'$.tags' AS CHAR(6) ARRAY))))engine=innodb;
SHOW CREATE TABLE t1;
Table Create Table
t1 CREATE TABLE `t1` (
  `c` int(11) DEFAULT NULL,
  `j` longtext CHARACTER SET utf8mb4 COLLATE utf8mb4_bin DEFAULT NULL CHECK (json_valid(`j`))
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_uca1400_ai_ci
show index from t1;
Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Sub_part Packed Null Index_type Comment Index_comment Ignored
t1 1 invisible1 1 invisible1 A 0 NULL NULL YES BTREE NO
t1 1 idx 1 DB_MVI_1 NULL NULL NULL NULL YES FULLTEXT NO
set @old_innodb_ft_aux_table=@@global.innodb_ft_aux_table;
set global innodb_ft_aux_table='test/t1';
insert into t1 values (1, '{"tags": ["1", "abcde", "34567"]}');
SELECT * FROM INFORMATION_SCHEMA.INNODB_FT_INDEX_CACHE;
WORD FIRST_DOC_ID LAST_DOC_ID DOC_COUNT DOC_ID POSITION
34567 1 1 1 1 2
abcde 1 1 1 1 1
DROP TABLE t1;
set global innodb_ft_aux_table=@old_innodb_ft_aux_table;
select mvi_encode('[1, 42, 3]', int);
mvi_encode('[1, 42, 3]', int)
8000000000000001 800000000000002a 8000000000000003
select mvi_encode('[1, 42, 3]', unsigned);
mvi_encode('[1, 42, 3]', unsigned)
0000000000000001 000000000000002a 0000000000000003
13f67c0b786e...
13f67c0b786e08ce6d5fd7819412eea7470534af
Rex Johnston
PQ  tidy up message queue processing, add in missing tests, fix...

in pwt_worker_base::init_worker_thd()
12ceb4d6aac1...
12ceb4d6aac1c287f4e2bf8d0412795f4e539020
Daniel Black
MDEV-34482 main.events_processlist test fix

As the test result is dependent of SHOW PROCESSLIST output,
adjust the wait condition to ensure the state is in sleeping
rather than "init" or another state.
107b5df017f6...
107b5df017f6eb5a55ab6ec104259b97bc881c3b
Daniel Bartholomew
bump the VERSION
BuildBot (0.8.9) working for the MariaDB project.
Page built: Thu 27 Aug 2026 05:29:26 (UTC)