@saltcorn/mysql-tables 0.1.0

package/.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "WebFetch(domain:github.com)",
+      "WebSearch",
+      "WebFetch(domain:saltcorn.github.io)",
+      "WebFetch(domain:wiki.saltcorn.com)",
+      "Bash(npx eslint:*)"
+    ]
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Saltcorn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# mysql-tables
+Table provider for remote MySQL and MariaDB tables
+
+This module contains a Saltcorn table provider for remote MySQL and MariaDB tables. Use this to access a table on a different database as if it were a normal Saltcorn table.
+
+There are two ways of setting up a remote table:
+
+* The standard way is to create a table and select the "MySQL remote table" as the table provider. In the configuration, you will on the first screen select the database connection parameters (host URL, port, username, password, database name, and table name). On the second page you can adjust the fields that have been guessed from connecting to the database. This way works fine if you are only importing a single table.
+
+* If you are importing multiple tables and there are relations between them, it is easier to run the "MySQL Database Explorer" view, which is only available to the administrator and will be in your list of views. Here you also enter the database connection parameters, but not the table name. When you have entered the other connection parameters, press "Look up tables" and a list of the tables will appear. Here, select all of the tables you would like to import and then click "Import tables". This means you don't have to enter the connection parameters multiple times, and it will also correctly set up any relations as foreign key fields between the imported tables.
+
+If you have added fields to the remote table after doing an import, simply use the "MySQL Database Explorer" to import these tables again. The list of fields will be updated.
+
+If you would prefer not to have your database connection password stored in the database you can set this up as an environment variable, as indicated on the sublabel for the password connection parameter. You should set the `SC_EXTMYSQL_PASS_{database name}` environment variable. For instance, if your database is called `testdb1` then set the `SC_EXTMYSQL_PASS_testdb1` environment variable.
+
+## Query function
+
+This module also provides the `extMySqlQuery` function for use in code actions. It takes a connection object, an SQL query string, and optionally an array of parameters. Queries are executed in a read-only transaction for safety. Example usage:
+
+```javascript
+const result = await extMySqlQuery(
+  { host: "db.example.com", port: 3306, user: "reader", password: "secret", database: "mydb" },
+  "SELECT * FROM orders WHERE status = ?",
+  ["pending"]
+);
+// result.rows contains the query results
+```

package/connections.js

@@ -0,0 +1,24 @@
+const mysql = require("mysql2/promise");
+
+const pools = {};
+
+const getConnection = async (connObj) => {
+  if (!connObj) return null;
+  const key = `${connObj.host}:${connObj.port || 3306}:${connObj.database}:${connObj.user}`;
+  if (!pools[key]) {
+    const password =
+      connObj.password || process.env[`SC_EXTMYSQL_PASS_${connObj.database}`];
+    pools[key] = mysql.createPool({
+      host: connObj.host,
+      port: connObj.port || 3306,
+      user: connObj.user,
+      password,
+      database: connObj.database,
+      waitForConnections: true,
+      connectionLimit: 10,
+    });
+  }
+  return pools[key];
+};
+
+module.exports = { getConnection };

package/database-browser.js

@@ -0,0 +1,204 @@
+const Table = require("@saltcorn/data/models/table");
+const Form = require("@saltcorn/data/models/form");
+const Workflow = require("@saltcorn/data/models/workflow");
+const { renderForm } = require("@saltcorn/markup");
+const { script } = require("@saltcorn/markup/tags");
+
+const { getConnection } = require("./connections");
+const { discover_tables, discoverable_tables } = require("./discovery");
+
+const configuration_workflow = () =>
+  new Workflow({
+    steps: [],
+  });
+
+const getForm = async ({ viewname }) => {
+  const fields = [
+    {
+      name: "host",
+      label: "Database host",
+      type: "String",
+      required: true,
+      attributes: { asideNext: true },
+    },
+    {
+      name: "port",
+      label: "Port",
+      type: "Integer",
+      required: true,
+      default: 3306,
+    },
+    {
+      name: "user",
+      label: "User",
+      type: "String",
+      required: true,
+      attributes: { asideNext: true },
+    },
+    {
+      name: "password",
+      label: "Password",
+      type: "String",
+      fieldview: "password",
+      sublabel:
+        "If blank, use environment variable <code>SC_EXTMYSQL_PASS_{database name}</code>",
+      required: true,
+    },
+    {
+      name: "database",
+      label: "Database",
+      type: "String",
+      required: true,
+    },
+    {
+      name: "tables",
+      label: "Tables",
+      type: "String",
+      class: "table-selector",
+      attributes: { options: [] },
+    },
+  ];
+
+  const form = new Form({
+    action: `/view/${viewname}`,
+    fields,
+    noSubmitButton: true,
+    additionalButtons: [
+      {
+        label: "Look up tables",
+        onclick: "look_up_tables(this)",
+        class: "btn btn-primary",
+      },
+      {
+        label: "Import tables",
+        onclick: "import_tables(this)",
+        class: "btn btn-primary",
+      },
+    ],
+  });
+  return form;
+};
+
+const js = (viewname) =>
+  script(`
+function look_up_tables(that) {
+  const form = $(that).closest('form');
+  view_post("${viewname}", "lookup_tables", $(form).serialize(), (r)=>{
+    $(".table-selector").attr("multiple", true).html(r.tables.map(t=>'<option>'+t+'</option>').join(""))
+  })
+}
+function import_tables(that) {
+  const form = $(that).closest('form');
+  view_post("${viewname}", "import_tables", $(form).serialize())
+}
+`);
+
+const run = async (table_id, viewname, cfg, state, { res, req }) => {
+  const form = await getForm({ viewname });
+  return renderForm(form, req.csrfToken()) + js(viewname);
+};
+
+const runPost = async (
+  table_id,
+  viewname,
+  config,
+  state,
+  body,
+  { req, res },
+) => {
+  const form = await getForm({ viewname, body });
+  form.validate(body);
+  let plot = "";
+  if (!form.hasErrors) {
+    const table = await Table.findOne({ name: form.values.table });
+  }
+  form.hasErrors = false;
+  form.errors = {};
+  res.sendWrap("Data explorer", [
+    renderForm(form, req.csrfToken()),
+    js(viewname),
+    plot,
+  ]);
+};
+
+const lookup_tables = async (table_id, viewname, config, body, { req }) => {
+  const form = await getForm({ viewname, body });
+  form.validate(body);
+  if (!form.hasErrors) {
+    const cfg = form.values;
+    const pool = await getConnection(cfg);
+    const tbls = await discoverable_tables(cfg.database, pool);
+
+    return { json: { success: "ok", tables: tbls.map((t) => t.table_name) } };
+  }
+  return { json: { error: "Form incomplete" } };
+};
+
+const import_tables = async (table_id, viewname, config, body, { req }) => {
+  const form = await getForm({ viewname, body });
+  form.validate(body);
+  if (!form.hasErrors) {
+    const { _csrf, tables, ...cfg } = form.values;
+
+    const pool = await getConnection(cfg);
+    const pack = await discover_tables(
+      Array.isArray(body.tables) ? body.tables : [body.tables],
+      cfg.database,
+      pool,
+    );
+    const imported = [],
+      updated = [],
+      skipped = [];
+    for (const tableCfg of pack.tables) {
+      const existing = Table.findOne({ name: tableCfg.name });
+      if (existing?.provider_name === "MySQL remote table") {
+        updated.push(tableCfg.name);
+        await existing.update({
+          provider_cfg: {
+            ...cfg,
+            table_name: tableCfg.name,
+            fields: tableCfg.fields,
+          },
+        });
+      } else if (existing) {
+        skipped.push(tableCfg.name);
+      } else {
+        imported.push(tableCfg.name);
+        await Table.create(tableCfg.name, {
+          provider_name: "MySQL remote table",
+          provider_cfg: {
+            ...cfg,
+            table_name: tableCfg.name,
+            fields: tableCfg.fields,
+          },
+        });
+      }
+    }
+    return {
+      json: {
+        success: "ok",
+        notify: `${
+          imported.length ? `Imported tables: ${imported.join(",")}. ` : ""
+        }${updated.length ? `Updated tables: ${updated.join(",")}. ` : ""}${
+          skipped.length
+            ? `Skipped tables (name clash): ${skipped.join(",")}. `
+            : ""
+        }`,
+      },
+    };
+  }
+  return { json: { error: "Form incomplete" } };
+};
+
+module.exports = {
+  name: "MySQL Database Explorer",
+  display_state_form: false,
+  tableless: true,
+  singleton: true,
+  description: "Explore and import MySQL/MariaDB databases",
+  get_state_fields: () => [],
+  configuration_workflow,
+  run,
+  runPost,
+  routes: { lookup_tables, import_tables },
+};

package/discovery.js

@@ -0,0 +1,138 @@
+const findType = (dataType, columnType) => {
+  const dt = dataType.toLowerCase();
+
+  if (
+    dt === "tinyint" &&
+    columnType &&
+    columnType.toLowerCase() === "tinyint(1)"
+  ) {
+    return "Bool";
+  }
+
+  if (
+    [
+      "int",
+      "integer",
+      "smallint",
+      "mediumint",
+      "bigint",
+      "tinyint",
+    ].includes(dt)
+  ) {
+    return "Integer";
+  }
+
+  if (["float", "double", "decimal", "numeric", "real"].includes(dt)) {
+    return "Float";
+  }
+
+  if (
+    [
+      "varchar",
+      "char",
+      "text",
+      "tinytext",
+      "mediumtext",
+      "longtext",
+      "enum",
+      "set",
+    ].includes(dt)
+  ) {
+    return "String";
+  }
+
+  if (["date", "datetime", "timestamp"].includes(dt)) {
+    return "Date";
+  }
+
+  if (dt === "json") {
+    return "String";
+  }
+
+  return null;
+};
+
+const discoverable_tables = async (database, pool) => {
+  const [rows] = await pool.query(
+    `SELECT TABLE_NAME as table_name
+     FROM INFORMATION_SCHEMA.TABLES
+     WHERE TABLE_SCHEMA = ? AND TABLE_TYPE = 'BASE TABLE'
+     ORDER BY TABLE_NAME`,
+    [database],
+  );
+  return rows;
+};
+
+const discover_tables = async (tableNames, database, pool) => {
+  const packTables = [];
+
+  for (const tnm of tableNames) {
+    const [columns] = await pool.query(
+      `SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_TYPE, EXTRA
+       FROM INFORMATION_SCHEMA.COLUMNS
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+       ORDER BY ORDINAL_POSITION`,
+      [database, tnm],
+    );
+
+    const [primaryKeys] = await pool.query(
+      `SELECT COLUMN_NAME
+       FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND CONSTRAINT_NAME = 'PRIMARY'`,
+      [database, tnm],
+    );
+    const pkColumns = primaryKeys.map((r) => r.COLUMN_NAME);
+
+    const [foreignKeys] = await pool.query(
+      `SELECT COLUMN_NAME, REFERENCED_TABLE_NAME
+       FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+       WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+         AND REFERENCED_TABLE_SCHEMA IS NOT NULL`,
+      [database, tnm],
+    );
+    const fkMap = {};
+    foreignKeys.forEach((fk) => {
+      fkMap[fk.COLUMN_NAME] = fk.REFERENCED_TABLE_NAME;
+    });
+
+    const fields = columns
+      .map((c) => {
+        const isAutoIncrement =
+          c.EXTRA && c.EXTRA.includes("auto_increment");
+        const fkTable = fkMap[c.COLUMN_NAME];
+
+        const field = {
+          name: c.COLUMN_NAME,
+          label: c.COLUMN_NAME,
+          required: c.IS_NULLABLE === "NO" && !isAutoIncrement,
+        };
+
+        if (pkColumns.includes(c.COLUMN_NAME)) {
+          field.primary_key = true;
+        }
+
+        if (fkTable) {
+          field.type = "Key";
+          field.reftable_name = fkTable;
+        } else {
+          const type = findType(c.DATA_TYPE, c.COLUMN_TYPE);
+          if (!type) return null;
+          field.type = type;
+        }
+
+        return field;
+      })
+      .filter((f) => f !== null);
+
+    packTables.push({
+      name: tnm,
+      fields,
+      min_role_read: 1,
+      min_role_write: 1,
+    });
+  }
+
+  return { tables: packTables };
+};
+
+module.exports = { discover_tables, discoverable_tables, findType };

package/index.js

@@ -0,0 +1,45 @@
+const { getConnection } = require("./connections");
+
+module.exports = {
+  sc_plugin_api_version: 1,
+  table_providers: require("./table-provider"),
+  viewtemplates: [require("./database-browser")],
+  functions: {
+    extMySqlQuery: {
+      run: async (connection, query, parameters) => {
+        const sql_log = (...args) => {
+          console.log(...args);
+        };
+        const pool = await getConnection(connection);
+        const conn = await pool.getConnection();
+        try {
+          sql_log("START TRANSACTION READ ONLY;");
+          await conn.query("START TRANSACTION READ ONLY;");
+
+          sql_log(query, parameters || []);
+          const [rows, fields] = await conn.query(query, parameters || []);
+
+          sql_log("ROLLBACK;");
+          await conn.query("ROLLBACK");
+          return { rows, fields };
+        } finally {
+          conn.release();
+        }
+      },
+      isAsync: true,
+      description:
+        "Run a read-only SQL query on an external MySQL/MariaDB database",
+      arguments: [
+        {
+          name: "connection",
+          type: "JSON",
+          tstype:
+            "{host: string, port: number, user: string, password: string, database: string}",
+          required: true,
+        },
+        { name: "sql_query", type: "String", required: true },
+        { name: "parameters", type: "JSON", tstype: "any[]" },
+      ],
+    },
+  },
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@saltcorn/mysql-tables",
+  "version": "0.1.0",
+  "description": "Table provider for remote MySQL and MariaDB tables",
+  "main": "index.js",
+  "dependencies": {
+    "@saltcorn/data": "^1.3.0",
+    "@saltcorn/markup": "^1.3.0",
+    "mysql2": "^3.11.0"
+  },
+  "author": "Tom Nielsen",
+  "license": "MIT",
+  "repository": "github:saltcorn/mysql-tables",
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "parserOptions": {
+      "ecmaVersion": 2020
+    },
+    "env": {
+      "node": true,
+      "es6": true
+    },
+    "rules": {
+      "no-unused-vars": "off",
+      "no-case-declarations": "off",
+      "no-empty": "warn",
+      "no-fallthrough": "warn"
+    }
+  }
+}

package/table-provider.js

@@ -0,0 +1,366 @@
+const db = require("@saltcorn/data/db");
+const Workflow = require("@saltcorn/data/models/workflow");
+const Form = require("@saltcorn/data/models/form");
+const FieldRepeat = require("@saltcorn/data/models/fieldrepeat");
+const Field = require("@saltcorn/data/models/field");
+const Table = require("@saltcorn/data/models/table");
+const {
+  aggregation_query_fields,
+  joinfield_renamer,
+} = require("@saltcorn/data/models/internal/query");
+const { getState } = require("@saltcorn/data/db/state");
+const {
+  sqlsanitize,
+  mkWhere,
+  mkSelectOptions,
+} = require("@saltcorn/db-common/internal");
+
+const { getConnection } = require("./connections");
+const { discover_tables } = require("./discovery");
+
+const pgToMysql = (sql, values) => {
+  if (!sql) return { sql: "", values: values || [] };
+
+  const newValues = [];
+  let converted = sql;
+
+  if (/\$\d+/.test(sql) && values && values.length > 0) {
+    converted = converted.replace(/\$(\d+)/g, (_, num) => {
+      newValues.push(values[parseInt(num) - 1]);
+      return "?";
+    });
+  } else if (values) {
+    newValues.push(...values);
+  }
+
+  converted = converted
+    .replace(/"/g, "`")
+    .replace(/\bILIKE\b/gi, "LIKE")
+    .replace(/::([\w]+(\[\])?)/g, "")
+    .replace(/\bNULLS\s+(FIRST|LAST)\b/gi, "")
+    .replace(/\bLIMIT\s+ALL\b/gi, "");
+
+  return { sql: converted, values: newValues };
+};
+
+const configuration_workflow = (req) =>
+  new Workflow({
+    onDone: (ctx) => {
+      (ctx.fields || []).forEach((f) => {
+        if (f.summary_field) {
+          if (!f.attributes) f.attributes = {};
+          f.attributes.summary_field = f.summary_field;
+        }
+      });
+      return ctx;
+    },
+    steps: [
+      {
+        name: "table",
+        form: async () => {
+          return new Form({
+            fields: [
+              {
+                name: "host",
+                label: "Database host",
+                type: "String",
+                required: true,
+                exclude_from_mobile: true,
+              },
+              {
+                name: "port",
+                label: "Port",
+                type: "Integer",
+                required: true,
+                default: 3306,
+                exclude_from_mobile: true,
+              },
+              {
+                name: "user",
+                label: "User",
+                type: "String",
+                required: true,
+                exclude_from_mobile: true,
+              },
+              {
+                name: "password",
+                label: "Password",
+                type: "String",
+                fieldview: "password",
+                required: true,
+                sublabel:
+                  "If blank, use environment variable <code>SC_EXTMYSQL_PASS_{database name}</code>",
+                exclude_from_mobile: true,
+              },
+              {
+                name: "database",
+                label: "Database",
+                type: "String",
+                required: true,
+                exclude_from_mobile: true,
+              },
+              {
+                name: "table_name",
+                label: "Table name",
+                type: "String",
+                required: true,
+                exclude_from_mobile: true,
+              },
+              {
+                name: "read_only",
+                label: "Read-only",
+                type: "Bool",
+              },
+            ],
+          });
+        },
+      },
+      {
+        name: "fields",
+        form: async (ctx) => {
+          const pool = await getConnection(ctx);
+          const pack = await discover_tables(
+            [ctx.table_name],
+            ctx.database,
+            pool,
+          );
+          const tables = await Table.find({});
+
+          const real_fkey_opts = tables.map((t) => `Key to ${t.name}`);
+          const fkey_opts = ["File", ...real_fkey_opts];
+
+          const form = new Form({
+            fields: [
+              {
+                input_type: "section_header",
+                label: "Column types",
+              },
+              new FieldRepeat({
+                name: "fields",
+                fields: [
+                  {
+                    name: "name",
+                    label: "Name",
+                    type: "String",
+                    required: true,
+                  },
+                  {
+                    name: "label",
+                    label: "Label",
+                    type: "String",
+                    required: true,
+                  },
+                  {
+                    name: "type",
+                    label: "Type",
+                    type: "String",
+                    required: true,
+                    attributes: {
+                      options: getState().type_names.concat(fkey_opts || []),
+                    },
+                  },
+                  {
+                    name: "primary_key",
+                    label: "Primary key",
+                    type: "Bool",
+                  },
+                  {
+                    name: "summary_field",
+                    label: "Summary field",
+                    sublabel:
+                      "The field name, on the target table, which will be used to pick values for this key",
+                    type: "String",
+                    showIf: { type: real_fkey_opts },
+                  },
+                ],
+              }),
+            ],
+          });
+          if (!ctx.fields || !ctx.fields.length) {
+            if (!form.values) form.values = {};
+            form.values.fields = pack.tables[0].fields;
+          } else {
+            (ctx.fields || []).forEach((f) => {
+              if (f.type === "Key" && f.reftable_name)
+                f.type = `Key to ${f.reftable_name}`;
+              if (f.attributes?.summary_field)
+                f.summary_field = f.attributes?.summary_field;
+              const reftable_name =
+                f.reftable_name || typeof f.type === "string"
+                  ? f.type.replace("Key to ", "")
+                  : null;
+              const reftable = reftable_name && Table.findOne(reftable_name);
+              const repeater = form.fields.find((ff) => ff.isRepeat);
+              const sum_form_field = repeater.fields.find(
+                (ff) => ff.name === "summary_field",
+              );
+              if (reftable && sum_form_field) {
+                sum_form_field.showIf.type = sum_form_field.showIf.type.filter(
+                  (t) => t !== f.type,
+                );
+
+                repeater.fields.push(
+                  new Field({
+                    name: "summary_field",
+                    label: "Summary field for " + f.name,
+                    sublabel: `The field name, on the ${reftable_name} table, which will be used to pick values for this key`,
+                    type: "String",
+                    showIf: { type: f.type },
+                    attributes: {
+                      options: reftable.fields.map((f) => f.name),
+                    },
+                  }),
+                );
+              }
+            });
+          }
+
+          return form;
+        },
+      },
+    ],
+  });
+
+const getPkName = (cfg) => {
+  const pkField = (cfg?.fields || []).find((f) => f.primary_key);
+  return pkField ? pkField.name : "id"; 
+};
+
+module.exports = {
+  "MySQL remote table": {
+    configuration_workflow,
+    fields: (cfg) => {
+      return cfg?.fields || [];
+    },
+    get_table: (cfg) => {
+      const pkName = getPkName(cfg);
+      return {
+        disableFiltering: true,
+        ...(cfg?.read_only
+          ? {}
+          : {
+              deleteRows: async (where, user) => {
+                const pool = await getConnection(cfg);
+                const { where: whereClause, values: whereVals } = mkWhere(
+                  where || {},
+                );
+                const { sql, values } = pgToMysql(
+                  `DELETE FROM "${sqlsanitize(cfg.table_name)}" ${whereClause}`,
+                  whereVals,
+                );
+                await pool.query(sql, values);
+              },
+              updateRow: async (updRow, id, user) => {
+                const pool = await getConnection(cfg);
+                const kvs = Object.entries(updRow);
+                const assigns = kvs
+                  .map(([k]) => `\`${sqlsanitize(k)}\` = ?`)
+                  .join(", ");
+                const values = [...kvs.map(([, v]) => v), id];
+                const sql = `UPDATE \`${sqlsanitize(cfg.table_name)}\` SET ${assigns} WHERE \`${sqlsanitize(pkName)}\` = ?`;
+                await pool.query(sql, values);
+              },
+              insertRow: async (rec, user) => {
+                const pool = await getConnection(cfg);
+                const kvs = Object.entries(rec);
+                const fnameList = kvs
+                  .map(([k]) => `\`${sqlsanitize(k)}\``)
+                  .join(", ");
+                const valPlaceholders = kvs.map(() => "?").join(", ");
+                const values = kvs.map(([, v]) => v);
+                const sql = `INSERT INTO \`${sqlsanitize(cfg.table_name)}\` (${fnameList}) VALUES (${valPlaceholders})`;
+                const [result] = await pool.query(sql, values);
+                return result.insertId;
+              },
+            }),
+        countRows: async (where, opts) => {
+          const pool = await getConnection(cfg);
+          const { where: whereClause, values: whereVals } = mkWhere(
+            where || {},
+          );
+          const { sql, values } = pgToMysql(
+            `SELECT COUNT(*) as count FROM "${sqlsanitize(cfg.table_name)}" ${whereClause}`,
+            whereVals,
+          );
+          const [rows] = await pool.query(sql, values);
+          return parseInt(rows[0].count);
+        },
+        aggregationQuery: async (aggregations, options) => {
+          const pool = await getConnection(cfg);
+          const {
+            sql: pgSql,
+            values: pgValues,
+            groupBy,
+          } = aggregation_query_fields(cfg.table_name, aggregations, {
+            ...options,
+            schema: cfg.database,
+          });
+          const { sql, values } = pgToMysql(pgSql, pgValues);
+
+          const [rows] = await pool.query(sql, values);
+          if (groupBy) return rows;
+          return rows[0];
+        },
+        distinctValues: async (fieldnm, whereObj) => {
+          const pool = await getConnection(cfg);
+          if (whereObj) {
+            const { where, values: whereVals } = mkWhere(whereObj);
+            const { sql, values } = pgToMysql(
+              `SELECT DISTINCT "${sqlsanitize(fieldnm)}" FROM "${sqlsanitize(cfg.table_name)}" ${where} ORDER BY "${sqlsanitize(fieldnm)}"`,
+              whereVals,
+            );
+            const [rows] = await pool.query(sql, values);
+            return rows.map((r) => r[fieldnm]);
+          } else {
+            const sql = `SELECT DISTINCT \`${sqlsanitize(fieldnm)}\` FROM \`${sqlsanitize(cfg.table_name)}\` ORDER BY \`${sqlsanitize(fieldnm)}\``;
+            const [rows] = await pool.query(sql);
+            return rows.map((r) => r[fieldnm]);
+          }
+        },
+        getRows: async (where, opts) => {
+          const pool = await getConnection(cfg);
+          const { where: whereClause, values: whereVals } = mkWhere(
+            where || {},
+          );
+          const selectOpts = mkSelectOptions(opts || {});
+          const { sql, values } = pgToMysql(
+            `SELECT * FROM "${sqlsanitize(cfg.table_name)}" ${whereClause} ${selectOpts}`,
+            whereVals,
+          );
+          const [rows] = await pool.query(sql, values);
+          return rows;
+        },
+        getJoinedRows: async (opts) => {
+          const pool = await getConnection(cfg);
+          const pseudoTable = new Table({
+            name: cfg.table_name,
+            fields: cfg.fields,
+          });
+          const {
+            sql: pgSql,
+            values: pgValues,
+            joinFields,
+            aggregations,
+          } = await pseudoTable.getJoinedQuery({
+            schema: cfg.database,
+            ...opts,
+            ignoreExternal: true,
+          });
+          const { sql, values } = pgToMysql(pgSql, pgValues);
+          if (db.get_sql_logging?.()) console.log(sql, values);
+          const [rows] = await pool.query(sql, values);
+          let result = joinfield_renamer
+            ? joinfield_renamer(joinFields, aggregations)(rows)
+            : rows;
+          for (const k of Object.keys(joinFields || {})) {
+            if (!joinFields?.[k].lookupFunction) continue;
+            for (const row of result) {
+              row[k] = await joinFields[k].lookupFunction(row);
+            }
+          }
+          return result;
+        },
+      };
+    },
+  },
+};