Initial version of DuckDB engine for MariaDB based on DuckDB 1.5.2.

.gitignore

@@ -218,6 +218,7 @@ sql/yy_mariadb.yy
 sql/yy_oracle.cc
 sql/yy_oracle.hh
 sql/yy_oracle.yy
+storage/duckdb/duckdb-build
 storage/heap/hp_test1
 storage/heap/hp_test2
 storage/maria/aria_chk

.gitmodules

@@ -17,3 +17,6 @@
 [submodule "storage/columnstore/columnstore"]
 	path = storage/columnstore/columnstore
 	url = https://github.com/mariadb-corporation/mariadb-columnstore-engine.git
+[submodule "storage/duckdb/third_parties/duckdb"]
+	path = storage/duckdb/third_parties/duckdb
+	url = https://github.com/duckdb/duckdb.git

cmake/cpack_rpm.cmake

@@ -7,7 +7,6 @@ INCLUDE(check_linker_flag)
 SET(CPACK_GENERATOR "RPM")
 SET(CPACK_RPM_PACKAGE_DEBUG 1)
 SET(CPACK_PACKAGING_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.7)
 
 SET(CPACK_RPM_COMPONENT_INSTALL ON)
 

debian/autobake-deb.sh

@@ -177,6 +177,12 @@ then
   fi
 fi
 
+# Enable DuckDB storage engine plugin packaging
+if grep -q "$architecture" storage/duckdb/debian/control
+then
+  cat storage/duckdb/debian/mariadb-plugin-duckdb.install >> debian/mariadb-server.install
+fi
+
 if [ -n "${AUTOBAKE_PREP_CONTROL_RULES_ONLY:-}" ]
 then
   exit 0

sql/sql_select.cc

@@ -254,19 +254,19 @@ static int join_ft_read_first(JOIN_TAB *tab);
 static int join_ft_read_next(READ_RECORD *info);
 int join_read_always_key_or_null(JOIN_TAB *tab);
 int join_read_next_same_or_null(READ_RECORD *info);
-static COND *make_cond_for_table(THD *thd, Item *cond,table_map table,
-                                 table_map used_table,
-                                 int join_tab_idx_arg,
-                                 bool exclude_expensive_cond,
-                                 bool retain_ref_cond);
-static COND *make_cond_for_table_from_pred(THD *thd, Item *root_cond,
-                                           Item *cond,
-                                           table_map tables,
-                                           table_map used_table,
-                                           int join_tab_idx_arg,
-                                           bool exclude_expensive_cond,
-                                           bool retain_ref_cond,
-                                           bool is_top_and_level);
+COND *make_cond_for_table(THD *thd, Item *cond,table_map table,
+                         table_map used_table,
+                         int join_tab_idx_arg,
+                         bool exclude_expensive_cond,
+                         bool retain_ref_cond);
+COND *make_cond_for_table_from_pred(THD *thd, Item *root_cond,
+                                    Item *cond,
+                                    table_map tables,
+                                    table_map used_table,
+                                    int join_tab_idx_arg,
+                                    bool exclude_expensive_cond,
+                                    bool retain_ref_cond,
+                                    bool is_top_and_level);
 
 static Item* part_of_refkey(TABLE *form,Field *field);
 static bool test_if_cheaper_ordering(bool in_join_optimizer,
@@ -26377,7 +26377,7 @@ bool test_if_ref(Item *root_cond, Item_field *left_item,Item *right_item)
      make_cond_for_info_schema() uses similar algorithm as well.
 */ 
 
-static Item *
+Item *
 make_cond_for_table(THD *thd, Item *cond, table_map tables,
                     table_map used_table,
                     int join_tab_idx_arg,
@@ -26391,7 +26391,7 @@ make_cond_for_table(THD *thd, Item *cond, table_map tables,
 }
 
 
-static Item *
+Item *
 make_cond_for_table_from_pred(THD *thd, Item *root_cond, Item *cond,
                               table_map tables, table_map used_table,
                               int join_tab_idx_arg,

sql/sql_select.h

@@ -2285,6 +2285,20 @@ void free_underlaid_joins(THD *thd, SELECT_LEX *select);
 bool mysql_explain_union(THD *thd, SELECT_LEX_UNIT *unit,
                          select_result *result);
 
+COND *make_cond_for_table(THD *thd, Item *cond, table_map tables,
+                          table_map used_table,
+                          int join_tab_idx_arg,
+                          bool exclude_expensive_cond,
+                          bool retain_ref_cond);
+COND *make_cond_for_table_from_pred(THD *thd, Item *root_cond,
+                                    Item *cond,
+                                    table_map tables,
+                                    table_map used_table,
+                                    int join_tab_idx_arg,
+                                    bool exclude_expensive_cond,
+                                    bool retain_ref_cond,
+                                    bool is_top_and_level);
+
 /*
   General routine to change field->ptr of a NULL-terminated array of Field
   objects. Useful when needed to call val_int, val_str or similar and the

storage/duckdb/CLAUDE.md

@@ -0,0 +1,77 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What This Is
+
+DuckDB storage engine plugin for MariaDB. Creates tables with `ENGINE=DuckDB` that store data in DuckDB's columnar format and execute analytical queries through DuckDB's vectorized engine. Lives under `storage/duckdb/` in the MariaDB server tree.
+
+## Build
+
+```bash
+# Build + install + start MariaDB (most common during development)
+./build.sh -S -t Debug
+
+# CI mode (build only, no install)
+./build.sh -c -t Debug
+
+# Build with packages
+./build.sh -p -t RelWithDebInfo
+```
+
+The build directory is created as a sibling: `../DuckdbBuildOf_<source_dir_name>/`. DuckDB itself is built from source at `third_parties/duckdb/` via `ExternalProject_Add` and merged into a single `libduckdb_bundle.a`.
+
+## Tests (MTR)
+
+Tests use MariaDB's MTR (MySQL Test Runner) framework. Test files live in `mysql-test/duckdb/t/` with expected results in `mysql-test/duckdb/r/`.
+
+```bash
+# Run a single test
+./run_mtr.sh create_table_column
+
+# Run and record new expected output
+./run_mtr.sh -r create_table_column
+
+# Run all tests
+./run_mtr.sh -a
+
+# Run against an externally running MariaDB
+./run_mtr.sh -e create_table_column
+
+# Run all against extern server
+./run_mtr.sh -a -e
+```
+
+## Architecture
+
+All engine code is in the `myduck` namespace (except `ha_duckdb` which is in global scope per MariaDB handler convention).
+
+### Key components
+
+- **`ha_duckdb`** (`ha_duckdb.cc/h`) — MariaDB `handler` subclass. Entry point for all storage engine operations (open, close, read, write, DDL). Implements row-at-a-time interface for MariaDB, translating to DuckDB batch operations.
+
+- **`DuckdbManager`** (`duckdb_manager.cc/h`) — Singleton owning the `duckdb::DuckDB` instance. Created once at plugin init, creates connections for each thread. Database file stored as `duckdb.db` in MariaDB data directory.
+
+- **`DuckdbThdContext`** (`duckdb_context.cc/h`) — Per-thread context holding a `duckdb::Connection`, transaction state, and appenders. Attached to MariaDB's THD. Manages BEGIN/COMMIT/ROLLBACK lifecycle and session variable propagation (timezone, optimizer flags, collation).
+
+- **DDL/DML Convertors** (`ddl_convertor.cc/h`, `dml_convertor.cc/h`) — Translate MariaDB SQL structures (TABLE, Field, Alter_info) into DuckDB-compatible SQL strings. Handle identifier quoting differences (MariaDB backticks → DuckDB double quotes) and type mapping.
+
+- **`DeltaAppender`** (`delta_appender.cc/h`) — Batched write path. Accumulates INSERT/UPDATE/DELETE rows using DuckDB's Appender API into a temporary buffer table, then flushes as a single DuckDB DML statement at commit time. `DeltaAppenders` manages per-table appender instances.
+
+- **Select handler / Query pushdown** (`ha_duckdb_pushdown.cc/h`) — Implements MariaDB's `select_handler` interface to push entire SELECT queries down to DuckDB. Registered via `hton->create_select` and `hton->create_unit`. Supports pure-DuckDB queries and cross-engine joins.
+
+- **Cross-engine scan** (`cross_engine_scan.cc/h`) — Enables DuckDB to read from non-DuckDB tables (e.g. InnoDB) during cross-engine joins. Registers a `_mdb_scan` table function and a replacement scan callback in DuckDB. Uses a thread-local registry of external tables.
+
+- **Type mapping** (`duckdb_types.cc/h`) — Converts between MariaDB field types and DuckDB types. `store_duckdb_field_in_mysql_format()` reads DuckDB values back into MariaDB row format.
+
+### SQL generation conventions
+
+All generated SQL must use **double quotes** for identifiers (DuckDB follows SQL standard), not backticks. The `SELECT_LEX::print()` output from MariaDB uses backticks and must be post-processed. See `docs/mariadb-duckdb-incompatibilities.md` for known function name rewrites and type mapping issues.
+
+### DuckDB source and patches
+
+DuckDB source is at `third_parties/duckdb/` (git submodule). No patches are applied — all compatibility is handled at runtime via `duckdb_mysql_compat.cc`. The build produces a static library; `_GLIBCXX_DEBUG` is explicitly undefined in CMakeLists.txt to avoid ABI mismatch with MariaDB's debug build.
+
+### Configuration
+
+`duckdb.cnf` — MariaDB config snippet that loads `ha_duckdb.so`. Installed to `/etc/my.cnf.d/`.

storage/duckdb/CMakeLists.txt

@@ -0,0 +1,66 @@
+IF("NO" STREQUAL "${PLUGIN_DUCKDB}")
+  return()
+ENDIF()
+
+IF(NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  MESSAGE_ONCE(duckdb "DuckDB: not Linux, skipping")
+  return()
+ENDIF()
+
+IF(NOT (CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" OR
+        CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64"))
+  MESSAGE_ONCE(duckdb "DuckDB: not x86_64 or aarch64, skipping")
+  return()
+ENDIF()
+
+# Check C++17 compiler support
+MY_CHECK_CXX_COMPILER_FLAG("-std=c++17")
+IF(NOT have_CXX__std_c__17)
+  MESSAGE_ONCE(duckdb "DuckDB: C++ compiler does not support -std=c++17, skipping")
+  RETURN()
+ENDIF()
+
+# libduckdb_bundle.a is built without debug STL wrappers.
+# Mismatched _GLIBCXX_DEBUG changes sizeof(std::vector) → SIGSEGV.
+SET(CMAKE_CXX_FLAGS_DEBUG
+    "${CMAKE_CXX_FLAGS_DEBUG} -U_GLIBCXX_DEBUG -U_GLIBCXX_ASSERTIONS")
+
+INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/cmake/duckdb.cmake)
+INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/cmake/duckdb_target_setup.cmake)
+
+# Provide MariaDB server include paths to sub-libraries.
+# MYSQL_ADD_PLUGIN normally does this, but it runs after ADD_SUBDIRECTORY.
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include
+                    ${CMAKE_SOURCE_DIR}/sql
+                    ${CMAKE_BINARY_DIR}/include
+                    ${PCRE_INCLUDE_DIRS}
+                    ${SSL_INCLUDE_DIRS}
+                    ${ZLIB_INCLUDE_DIRS})
+
+# Build sub-libraries.
+ADD_SUBDIRECTORY(common)
+ADD_SUBDIRECTORY(convertor)
+ADD_SUBDIRECTORY(runtime)
+
+# Plugin sources (handler layer + UDFs whose extern "C" symbols must be
+# in the final .so for dlsym() loading).
+SET(DUCKDB_PLUGIN_SOURCES
+  ha_duckdb.cc
+  ha_duckdb_pushdown.cc
+  duckdb_udf.cc
+)
+
+MYSQL_ADD_PLUGIN(duckdb ${DUCKDB_PLUGIN_SOURCES}
+  STORAGE_ENGINE
+  MODULE_ONLY
+  LINK_LIBRARIES duckdb_runtime duckdb_convertor duckdb_common ${DUCKDB_LIBRARY}
+)
+
+IF(TARGET duckdb)
+  duckdb_setup_target(duckdb)
+  TARGET_INCLUDE_DIRECTORIES(duckdb PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/common
+    ${CMAKE_CURRENT_SOURCE_DIR}/convertor
+    ${CMAKE_CURRENT_SOURCE_DIR}/runtime
+  )
+ENDIF()