fix: MySQL introspection failing on MariaDB servers (#1547)

* Fix MySQL introspection failing on MariaDB servers

Studio's tables introspection aggregated column metadata with
json_arrayagg, which does not exist before MariaDB 10.5 (#1511)
and returns LONGTEXT rather than native JSON on any MariaDB version, while
cast(... as json) is invalid syntax there (#1367).

The MySQL adapter now detects the server flavor once per adapter via
select version() and, on MariaDB, aggregates columns with
coalesce(concat('[', group_concat(json_object(...) separator ','), ']'), '[]')
instead. String-aggregated columns payloads are parsed back into arrays on
the client, which also hardens introspection against MySQL transports that
return json_arrayagg results as strings. Version detection failures fall
back to the existing MySQL SQL.

Verified end-to-end against MariaDB 10.4 and 10.11 containers and the
Vitess-backed MySQL integration suite.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Make MariaDB introspection independent of group_concat_max_len

Addresses PR review feedback: the group_concat-based aggregation was capped
by the session's group_concat_max_len (1MB default on MariaDB, sometimes
configured much lower), which could silently truncate the JSON payload on
very wide tables.

The MariaDB flavor now uses a dedicated tables query
(getMariaDBTablesQuery) that returns one row per column with no JSON
functions and no aggregation at all, and groupMariaDBTablesQueryResult
groups the rows into the aggregated shape on the client. This is immune to
any aggregation size cap and works on every MariaDB version. The MySQL
tables query is restored to its original json_arrayagg form.

Includes a regression test grouping over 1MB of column metadata, and was
verified against MariaDB 10.4/10.11 containers including with
group_concat_max_len lowered to 128 bytes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: sorenbs

.changeset/mariadb-introspection-compat.md

@@ -0,0 +1,5 @@
+---
+"@prisma/studio-core": patch
+---
+
+Fix MySQL introspection failing on MariaDB. The adapter now detects MariaDB via `select version()` and uses a dedicated tables query that returns one row per column and groups the result on the client, avoiding `json_arrayagg` (missing before MariaDB 10.5), JSON casts (invalid syntax on MariaDB), and any server-side string aggregation that would be truncated at `group_concat_max_len`. Introspection also parses string-encoded `json_arrayagg` payloads returned by some MySQL transports.

FEATURES.md

@@ -16,6 +16,7 @@ A standalone `sslmode` without SSL file parameters is left in the connection str
 Studio introspects connected databases to build schemas, tables, columns, relationships, filter operators, and timezone metadata.
 This gives users an accurate live model of the database and keeps table navigation grounded in current structure.
 A fresh Studio mount performs this discovery once, while actual adapter or database-availability changes invalidate cached metadata and load it again.
+The MySQL adapter detects MariaDB servers via `select version()` and switches to a MariaDB-compatible tables query that returns one row per column and groups the result on the client, so introspection works on all supported MariaDB versions where `json_arrayagg` or JSON casts are unavailable and cannot be truncated by `group_concat_max_len`.
 
 ## Deployable Prisma Postgres Demo
 

data/mysql-core/adapter.ts

@@ -40,10 +40,16 @@ import {
   getUpdateRefetchQuery,
 } from "./dml";
 import {
+  detectMySQLServerFlavor,
+  getMariaDBTablesQuery,
+  getServerVersionQuery,
   getTablesQuery,
   getTimezoneQuery,
+  groupMariaDBTablesQueryResult,
   mockTablesQuery,
   mockTimezoneQuery,
+  type MySQLServerFlavor,
+  normalizeTablesQueryResult,
 } from "./introspection";
 import { lintMySQLWithExplainFallback } from "./sql-lint";
 
@@ -148,18 +154,82 @@ export function createMySQLAdapter(
     }
   }
 
+  let cachedServerFlavor: MySQLServerFlavor | null = null;
+
+  async function detectServerFlavor(
+    options: Parameters<Adapter["introspect"]>[0],
+  ): Promise<MySQLServerFlavor> {
+    if (cachedServerFlavor) {
+      return cachedServerFlavor;
+    }
+
+    try {
+      const [error, versions] = await executor.execute(
+        getServerVersionQuery(otherRequirements),
+        options,
+      );
+
+      if (error) {
+        // fall back to the MySQL introspection SQL without caching, so the
+        // next introspection retries the detection.
+        return "mysql";
+      }
+
+      cachedServerFlavor = detectMySQLServerFlavor(versions[0]?.version);
+
+      return cachedServerFlavor;
+    } catch {
+      return "mysql";
+    }
+  }
+
+  /**
+   * Fetches table metadata using the tables query that matches the server
+   * flavor. MariaDB gets a one-row-per-column query grouped on the client, so
+   * results can never be truncated by `group_concat_max_len`.
+   */
+  async function fetchTables(
+    serverFlavor: MySQLServerFlavor,
+    options: Parameters<Adapter["introspect"]>[0],
+  ): Promise<{
+    query: Query;
+    result: Either<Error, QueryResult<typeof getTablesQuery>>;
+  }> {
+    if (serverFlavor === "mariadb") {
+      const query = getMariaDBTablesQuery(otherRequirements);
+      const [error, rows] = await executor.execute(query, options);
+
+      return {
+        query,
+        result: error ? [error] : [null, groupMariaDBTablesQueryResult(rows)],
+      };
+    }
+
+    const query = getTablesQuery(otherRequirements);
+    const [error, rows] = await executor.execute(query, options);
+
+    return {
+      query,
+      result: error ? [error] : [null, normalizeTablesQueryResult(rows)],
+    };
+  }
+
   async function introspectDatabase(
     options: Parameters<Adapter["introspect"]>[0],
   ): Promise<Either<AdapterError, AdapterIntrospectResult>> {
     try {
-      const tablesQuery = getTablesQuery(otherRequirements);
+      const serverFlavor = await detectServerFlavor(options);
       const timezoneQuery = getTimezoneQuery(otherRequirements);
 
-      const [[tablesError, tables], [timezoneError, timezones]] =
-        await Promise.all([
-          executor.execute(tablesQuery, options),
-          executor.execute(timezoneQuery, options),
-        ]);
+      const [tablesFetch, [timezoneError, timezones]] = await Promise.all([
+        fetchTables(serverFlavor, options),
+        executor.execute(timezoneQuery, options),
+      ]);
+
+      const {
+        query: tablesQuery,
+        result: [tablesError, tables],
+      } = tablesFetch;
 
       if (tablesError) {
         return createMySQLAdapterError({