velocious 1.0.430 → 1.0.431

package/src/database/drivers/mssql/options.js

@@ -0,0 +1,79 @@
+// @ts-check
+
+import QueryParserOptions from "../../query-parser/options.js"
+
+export default class VelociousDatabaseDriversMssqlOptions extends QueryParserOptions {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../base.js").default} args.driver - Database driver instance.
+   */
+  constructor({driver}) {
+    const options = {
+      driver,
+      columnQuote: "\"",
+      indexQuote: "\"",
+      stringQuote: "'",
+      tableQuote: "\""
+    }
+
+    super(options)
+  }
+
+  /**
+   * Runs quote.
+   * @param {?} string - String.
+   * @returns {number | string} - The quote.
+   */
+  quote(string) {
+    if (!this.driver) throw new Error("Driver not set")
+
+    return this.driver.quote(string)
+  }
+
+  /**
+   * Runs quote column name.
+   * @param {string} string - String.
+   * @returns {string} - The quote column name.
+   */
+  quoteColumnName(string) {
+    if (string.includes("[") || string.includes("]")) throw new Error(`Possible SQL injection in column name: ${string}`)
+
+    return `[${string}]`
+  }
+
+  /**
+   * Runs quote database name.
+   * @param {string} databaseName - Database name.
+   * @returns {string} - The quote database name.
+   */
+  quoteDatabaseName(databaseName) {
+    if (typeof databaseName != "string") throw new Error(`Invalid database name given: ${databaseName}`)
+    if (databaseName.includes("[") || databaseName.includes("]")) throw new Error(`Possible SQL injection in database name: ${databaseName}`)
+
+    return `[${databaseName}]`
+  }
+
+  /**
+   * Runs quote index name.
+   * @param {string} string - String.
+   * @returns {string} - The quote index name.
+   */
+  quoteIndexName(string) {
+    if (string.includes("[") || string.includes("]")) throw new Error(`Possible SQL injection in index name: ${string}`)
+
+    return `[${string}]`
+  }
+
+  /**
+   * Runs quote table name.
+   * @param {string} string - String.
+   * @returns {string} - The quote table name.
+   */
+  quoteTableName(string) {
+    if (string.includes("[") || string.includes("]")) throw new Error(`Possible SQL injection in table name: ${string}`)
+
+    return `[${string}]`
+  }
+}
+

package/src/database/drivers/mssql/query-parser.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import BaseQueryParser from "../../query-parser/base-query-parser.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlQueryParser extends BaseQueryParser {
+}

package/src/database/drivers/mssql/sql/alter-table.js

@@ -0,0 +1,4 @@
+import AlterTableBase from "../../../query/alter-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlAlterTable extends AlterTableBase {
+}

package/src/database/drivers/mssql/sql/create-database.js

@@ -0,0 +1,36 @@
+// @ts-check
+
+import CreateDatabaseBase from "../../../query/create-database-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateDatabase extends CreateDatabaseBase {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../../base.js").default} args.driver - Database driver instance.
+   * @param {string} args.databaseName - Database name.
+   * @param {boolean} [args.ifNotExists] - Whether if not exists.
+   */
+  constructor({driver, databaseName, ifNotExists}) {
+    super({databaseName, driver})
+    this.ifNotExists = ifNotExists
+  }
+
+  toSql() {
+    const {databaseName} = this
+    const options = this.getOptions()
+
+    let sql = ""
+
+    if (this.ifNotExists) {
+      sql += `IF NOT EXISTS(SELECT * FROM [sys].[databases] WHERE [name] = ${options.quote(databaseName)}) BEGIN `
+    }
+
+    sql += `CREATE DATABASE ${options.quoteDatabaseName(databaseName)}`
+
+    if (this.ifNotExists) {
+      sql += " END"
+    }
+
+    return [sql]
+  }
+}

package/src/database/drivers/mssql/sql/create-index.js

@@ -0,0 +1,4 @@
+import CreateIndexBase from "../../../query/create-index-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateIndex extends CreateIndexBase {
+}

package/src/database/drivers/mssql/sql/create-table.js

@@ -0,0 +1,4 @@
+import CreateTableBase from "../../../query/create-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateTable extends CreateTableBase {
+}

package/src/database/drivers/mssql/sql/delete.js

@@ -0,0 +1,19 @@
+import DeleteBase from "../../../query/delete-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlDelete extends DeleteBase {
+  toSql() {
+    let sql = `DELETE FROM ${this.getOptions().quoteTableName(this.tableName)} WHERE `
+    let count = 0
+
+    for (let columnName in this.conditions) {
+      if (count > 0) sql += " AND "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.getOptions().quote(this.conditions[columnName])
+      count++
+    }
+
+    return sql
+  }
+}

package/src/database/drivers/mssql/sql/drop-database.js

@@ -0,0 +1,36 @@
+// @ts-check
+
+import DropDatabaseBase from "../../../query/drop-database-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlDropDatabase extends DropDatabaseBase {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../../base.js").default} args.driver - Database driver instance.
+   * @param {string} args.databaseName - Database name.
+   * @param {boolean} [args.ifExists] - Whether if exists.
+   */
+  constructor({driver, databaseName, ifExists}) {
+    super({databaseName, driver})
+    this.ifExists = ifExists
+  }
+
+  toSql() {
+    const {databaseName} = this
+    const options = this.getOptions()
+
+    let sql = ""
+
+    if (this.ifExists) {
+      sql += `IF EXISTS(SELECT * FROM [sys].[databases] WHERE [name] = ${options.quote(databaseName)}) BEGIN `
+    }
+
+    sql += `DROP DATABASE ${options.quoteDatabaseName(databaseName)}`
+
+    if (this.ifExists) {
+      sql += " END"
+    }
+
+    return [sql]
+  }
+}

package/src/database/drivers/mssql/sql/drop-table.js

@@ -0,0 +1,4 @@
+import DropTableBase from "../../../query/drop-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlDropTable extends DropTableBase {
+}

package/src/database/drivers/mssql/sql/insert.js

@@ -0,0 +1,4 @@
+import InsertBase from "../../../query/insert-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlInsert extends InsertBase {
+}

package/src/database/drivers/mssql/sql/update.js

@@ -0,0 +1,31 @@
+import UpdateBase from "../../../query/update-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlUpdate extends UpdateBase {
+  toSql() {
+    let sql = `UPDATE ${this.getOptions().quoteTableName(this.tableName)} SET `
+    let count = 0
+
+    for (let columnName in this.data) {
+      if (count > 0) sql += ", "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.formatValue(this.data[columnName])
+      count++
+    }
+
+    sql += " WHERE "
+    count = 0
+
+    for (let columnName in this.conditions) {
+      if (count > 0) sql += " AND "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.formatValue(this.conditions[columnName])
+      count++
+    }
+
+    return sql
+  }
+}

package/src/database/drivers/mssql/sql/upsert.js

@@ -0,0 +1,23 @@
+// @ts-check
+
+import UpsertBase from "../../../query/upsert-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlUpsert extends UpsertBase {
+  toSql() {
+    const sourceColumnsSql = this.dataColumns().map((columnName) => {
+      return `${this.formatColumnValue(columnName)} AS ${this.quotedColumn(columnName)}`
+    }).join(", ")
+    const conflictSql = this.conflictColumns.map((columnName) => {
+      return `target.${this.quotedColumn(columnName)} = source.${this.quotedColumn(columnName)}`
+    }).join(" AND ")
+    const updateSql = this.updateColumns.map((columnName) => {
+      return `${this.quotedColumn(columnName)} = source.${this.quotedColumn(columnName)}`
+    }).join(", ")
+    const insertColumnsSql = this.dataColumns().map((columnName) => this.quotedColumn(columnName)).join(", ")
+    const insertValuesSql = this.dataColumns().map((columnName) => `source.${this.quotedColumn(columnName)}`).join(", ")
+
+    // HOLDLOCK prevents the race where two concurrent MERGEs both
+    // see NOT MATCHED and both try to INSERT, causing a PK violation.
+    return `MERGE ${this.quotedTableName()} WITH (HOLDLOCK) AS target USING (SELECT ${sourceColumnsSql}) AS source ON ${conflictSql} WHEN MATCHED THEN UPDATE SET ${updateSql} WHEN NOT MATCHED THEN INSERT (${insertColumnsSql}) VALUES (${insertValuesSql});`
+  }
+}

package/src/database/drivers/mssql/structure-sql.js

@@ -0,0 +1,120 @@
+// @ts-check
+
+import {normalizeCreateStatement, normalizeSqlStatement} from "../structure-sql/utils.js"
+
+export default class VelociousDatabaseDriversMssqlStructureSql {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../base.js").default} args.driver - Database driver instance.
+   */
+  constructor({driver}) {
+    this.driver = driver
+  }
+
+  /**
+   * Runs to sql.
+   * @returns {Promise<string | null>} - Resolves with SQL string.
+   */
+  async toSql() {
+    const {driver} = this
+    const rows = await driver.query("SELECT TABLE_NAME AS table_name, TABLE_TYPE AS table_type FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'dbo' ORDER BY TABLE_TYPE, TABLE_NAME")
+    const statements = []
+
+    for (const row of rows) {
+      const tableNameValue = row.table_name || row.TABLE_NAME
+      const tableTypeValue = row.table_type || row.TABLE_TYPE
+      const tableName = tableNameValue ? String(tableNameValue) : ""
+      const tableType = tableTypeValue ? String(tableTypeValue) : ""
+
+      if (!tableName || !tableType) continue
+
+      if (tableType == "BASE TABLE") {
+        const columns = await driver.query(`SELECT COLUMN_NAME AS column_name, DATA_TYPE AS data_type, IS_NULLABLE AS is_nullable, COLUMN_DEFAULT AS column_default, CHARACTER_MAXIMUM_LENGTH AS character_maximum_length, NUMERIC_PRECISION AS numeric_precision, NUMERIC_SCALE AS numeric_scale FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = 'dbo' AND TABLE_NAME = ${driver.quote(tableName)} ORDER BY ORDINAL_POSITION`)
+        const primaryKeys = await driver.query(`SELECT kcu.COLUMN_NAME AS column_name FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY' AND tc.TABLE_SCHEMA = 'dbo' AND tc.TABLE_NAME = ${driver.quote(tableName)} ORDER BY kcu.ORDINAL_POSITION`)
+        const columnSql = columns
+          .map((column) => this._columnDefinition(column))
+          .filter((column) => Boolean(column))
+        const primaryKeyColumns = primaryKeys
+          .map((primaryKeyRow) => primaryKeyRow.column_name || primaryKeyRow.COLUMN_NAME)
+          .filter((column) => Boolean(column))
+
+        if (primaryKeyColumns.length > 0) {
+          columnSql.push(`PRIMARY KEY (${primaryKeyColumns.map((name) => driver.quoteColumn(String(name))).join(", ")})`)
+        }
+
+        if (columnSql.length == 0) continue
+
+        statements.push(normalizeSqlStatement(`CREATE TABLE ${driver.quoteTable(tableName)} (${columnSql.join(", ")})`))
+      } else if (tableType == "VIEW") {
+        const viewRows = await driver.query(`SELECT m.definition AS definition FROM sys.sql_modules m JOIN sys.objects o ON m.object_id = o.object_id WHERE o.type = 'V' AND o.name = ${driver.quote(tableName)}`)
+        const viewDefValue = viewRows?.[0]?.definition || viewRows?.[0]?.DEFINITION
+        const viewDef = viewDefValue ? String(viewDefValue) : ""
+
+        if (!viewDef) continue
+
+        const createStatement = normalizeCreateStatement({
+          db: driver,
+          statement: viewDef,
+          objectName: tableName,
+          type: "VIEW"
+        })
+
+        statements.push(normalizeSqlStatement(createStatement))
+      }
+    }
+
+    if (statements.length == 0) return null
+
+    return `${statements.join("\n\n")}\n`
+  }
+
+  /**
+   * Runs column definition.
+   * @param {Record<string, ?>} column - Column.
+   * @returns {string | null} - The column definition.
+   */
+  _columnDefinition(column) {
+    const {driver} = this
+    const columnNameValue = column.column_name || column.COLUMN_NAME
+    const dataTypeValue = column.data_type || column.DATA_TYPE
+    const columnName = columnNameValue ? String(columnNameValue) : ""
+    const dataType = dataTypeValue ? String(dataTypeValue) : ""
+
+    if (!columnName || !dataType) return null
+
+    let typeSql = dataType
+    const charLengthValue = column.character_maximum_length || column.CHARACTER_MAXIMUM_LENGTH
+    const numericPrecisionValue = column.numeric_precision || column.NUMERIC_PRECISION
+    const numericScaleValue = column.numeric_scale || column.NUMERIC_SCALE
+    const charLength = charLengthValue === undefined || charLengthValue === null ? null : Number(charLengthValue)
+    const numericPrecision = numericPrecisionValue === undefined || numericPrecisionValue === null ? null : Number(numericPrecisionValue)
+    const numericScale = numericScaleValue === undefined || numericScaleValue === null ? null : Number(numericScaleValue)
+
+    if ((dataType == "varchar" || dataType == "nvarchar" || dataType == "char" || dataType == "nchar")) {
+      if (charLength == -1) {
+        typeSql = `${dataType}(max)`
+      } else if (charLength) {
+        typeSql = `${dataType}(${charLength})`
+      }
+    } else if ((dataType == "decimal" || dataType == "numeric") && numericPrecision) {
+      if (numericScale != null) {
+        typeSql = `${dataType}(${numericPrecision}, ${numericScale})`
+      } else {
+        typeSql = `${dataType}(${numericPrecision})`
+      }
+    }
+
+    const parts = [`${driver.quoteColumn(columnName)} ${typeSql}`]
+    const defaultValue = column.column_default || column.COLUMN_DEFAULT
+
+    if (defaultValue) parts.push(`DEFAULT ${defaultValue}`)
+
+    const isNullable = column.is_nullable || column.IS_NULLABLE
+
+    if (isNullable == "NO") parts.push("NOT NULL")
+
+    return parts.join(" ")
+  }
+}
+

package/src/database/drivers/mssql/table.js

@@ -0,0 +1,145 @@
+// @ts-check
+
+import BaseTable from "../base-table.js"
+import Column from "./column.js"
+import ColumnsIndex from "./columns-index.js"
+import {digg} from "diggerize"
+import ForeignKey from "./foreign-key.js"
+
+export default class VelociousDatabaseDriversMssqlTable extends BaseTable {
+  /**
+   * Runs constructor.
+   * @param {import("../base.js").default} driver - Database driver instance.
+   * @param {Record<string, string>} data - Data payload.
+   */
+  constructor(driver, data) {
+    super()
+    this.data = data
+    this.driver = driver
+  }
+
+  async getColumns() {
+    return await this.getDriver()._cachedTableSchemaMetadata(this.getName(), "columns", async () => {
+      const result = await this.driver.query(`
+        SELECT
+          *,
+          COLUMNPROPERTY(object_id(TABLE_SCHEMA + '.' + TABLE_NAME), COLUMN_NAME, 'IsIdentity') AS isIdentity
+        FROM [INFORMATION_SCHEMA].[COLUMNS]
+        WHERE [TABLE_NAME] = ${this.driver.quote(this.getName())}
+      `)
+      const columns = []
+
+      for (const data of result) {
+        const column = new Column(this, data)
+
+        columns.push(column)
+      }
+
+      return columns
+    })
+  }
+
+  async getForeignKeys() {
+    return await this.getDriver()._cachedTableSchemaMetadata(this.getName(), "foreignKeys", async () => {
+      const sql = `
+        SELECT
+            fk.name AS ForeignKeyName,
+            tp.name AS ParentTable,
+            ref.name AS ReferencedTable,
+            cp.name AS ParentColumn,
+            cref.name AS ReferencedColumn,
+            tp.name AS TableName
+        FROM sys.foreign_keys fk
+        INNER JOIN sys.foreign_key_columns fkc
+            ON fkc.constraint_object_id = fk.object_id
+        INNER JOIN sys.tables tp
+            ON fkc.parent_object_id = tp.object_id
+        INNER JOIN sys.columns cp
+            ON fkc.parent_object_id = cp.object_id
+            AND fkc.parent_column_id = cp.column_id
+        INNER JOIN sys.tables ref
+            ON fkc.referenced_object_id = ref.object_id
+        INNER JOIN sys.columns cref
+            ON fkc.referenced_object_id = cref.object_id
+            AND fkc.referenced_column_id = cref.column_id
+        WHERE tp.name = ${this.driver.quote(this.getName())}
+        ORDER BY ForeignKeyName, ParentTable, ReferencedTable;
+      `
+
+      const foreignKeyRows = await this.driver.query(sql)
+      const foreignKeys = []
+
+      for (const foreignKeyRow of foreignKeyRows) {
+        const foreignKey = new ForeignKey(foreignKeyRow)
+
+        foreignKeys.push(foreignKey)
+      }
+
+      return foreignKeys
+    })
+  }
+
+  async getIndexes() {
+    return await this.getDriver()._cachedTableSchemaMetadata(this.getName(), "indexes", async () => {
+      const options = this.getOptions()
+      const sql = `
+        SELECT
+          sys.tables.name AS TableName,
+          sys.columns.name AS ColumnName,
+          sys.indexes.name AS index_name,
+          sys.indexes.type_desc AS IndexType,
+          sys.index_columns.is_included_column AS IsIncludedColumn,
+          sys.indexes.is_unique,
+          sys.indexes.is_primary_key,
+          sys.indexes.is_unique_constraint
+        FROM sys.indexes
+        INNER JOIN sys.index_columns ON sys.indexes.object_id = sys.index_columns.object_id AND sys.indexes.index_id = sys.index_columns.index_id
+        INNER JOIN sys.columns ON sys.index_columns.object_id = sys.columns.object_id AND sys.index_columns.column_id = sys.columns.column_id
+        INNER JOIN sys.tables ON sys.indexes.object_id = sys.tables.object_id
+        WHERE
+          sys.tables.name = ${options.quote(this.getName())}
+        ORDER BY
+          sys.indexes.name,
+          sys.index_columns.key_ordinal
+      `
+
+      const rows = await this.getDriver().query(sql)
+      const indexes = []
+
+      for (const row of rows) {
+        const index = new ColumnsIndex(this, row)
+
+        indexes.push(index)
+      }
+
+      return indexes
+    })
+  }
+
+  /**
+   * Runs get name.
+   * @returns {string} - The table name.
+   */
+  getName() {
+    return /** Narrows the runtime value to the documented type. @type {string} */ (digg(this.data, "TABLE_NAME"))
+  }
+
+  /**
+   * Runs truncate.
+   * @param {{cascade: boolean}} [args] - Truncate options.
+   * @returns {Promise<Array<Record<string, ?>>>} - Resolves with the truncate.
+   */
+  async truncate(args) { // eslint-disable-line no-unused-vars
+    this.getDriver()._assertNotReadOnly()
+    try {
+      return await this.getDriver().query(`TRUNCATE TABLE ${this.getOptions().quoteTableName(this.getName())}`)
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("Query failed 'Cannot truncate table")) {
+        // Truncate table is really buggy for some reason - fall back to delete all rows instead
+        return await this.getDriver().query(`DELETE FROM ${this.getOptions().quoteTableName(this.getName())}`)
+      } else {
+        throw error
+      }
+    }
+  }
+}

package/src/database/drivers/mysql/column.js

@@ -0,0 +1,112 @@
+// @ts-check
+
+import BaseColumn from "../base-column.js"
+import ColumnsIndex from "./columns-index.js"
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversMysqlColumn extends BaseColumn {
+  /**
+   * Runs constructor.
+   * @param {import("../base-table.js").default} table - Table.
+   * @param {Record<string, ?>} data - Data payload.
+   */
+  constructor(table, data) {
+    super()
+    this.data = data
+    this.table = table
+  }
+
+  getAutoIncrement() { return digg(this, "data", "Extra").includes("auto_increment") }
+
+  async getIndexes() {
+    const options = this.getOptions()
+    const sql = `
+      SELECT
+        TABLE_SCHEMA,
+        TABLE_NAME,
+        INDEX_NAME AS index_name,
+        COLUMN_NAME,
+        SEQ_IN_INDEX,
+        NON_UNIQUE,
+        INDEX_TYPE
+      FROM INFORMATION_SCHEMA.STATISTICS
+      WHERE
+        TABLE_SCHEMA = DATABASE() AND
+        TABLE_NAME = ${options.quote(this.table.getName())} AND
+        COLUMN_NAME = ${options.quote(this.getName())}
+    `
+    const indexesRows = await this.getDriver().query(sql)
+    const indexes = []
+
+    for (const indexRow of indexesRows) {
+      if (indexRow.NON_UNIQUE == 1) {
+        indexRow.is_unique = false
+      } else {
+        indexRow.is_unique = true
+      }
+
+      if (indexRow.index_name == "PRIMARY") {
+        indexRow.is_primary_key = true
+      } else {
+        indexRow.is_primary_key = false
+      }
+
+      const index = new ColumnsIndex(this.getTable(), indexRow)
+
+      indexes.push(index)
+    }
+
+    return indexes
+  }
+
+  getDefault() { return digg(this, "data", "Default") }
+
+  getMaxLength() {
+    const type = digg(this, "data", "Type")
+    const match = type.match(/\((\d+)\)$/)
+
+    if (match) {
+      const maxLength = parseInt(match[1])
+
+      return maxLength
+    }
+  }
+
+  getName() { return digg(this, "data", "Field") }
+  getNotes() { return digg(this, "data", "Comment") || undefined }
+
+  getNull() {
+    const nullValue = digg(this, "data", "Null")
+
+    if (nullValue == "NO") {
+      return false
+    } else if (nullValue == "YES") {
+      return true
+    } else {
+      throw new Error(`Unknown null value: ${nullValue}`)
+    }
+  }
+
+  getPrimaryKey() { return digg(this, "data", "Key") == "PRI" }
+
+  getType() {
+    const typeHint = this.getTypeHintFromNotes()
+
+    if (typeHint == "boolean") return "boolean"
+
+    const type = digg(this, "data", "Type")
+    const tinyintMatch = type.match(/^tinyint\((\d+)\)/i)
+
+    if (tinyintMatch && tinyintMatch[1] == "1") return "boolean"
+
+    if (type.match(/^[a-z]+$/i)) {
+      return type.toLowerCase()
+    }
+
+    const match = type.match(/^([a-z]+)(?:\((\d+)\))*/i)
+
+    if (!match) throw new Error(`Couldn't match column type from: ${type}`)
+
+    return match[1].toLowerCase()
+  }
+}

package/src/database/drivers/mysql/columns-index.js

@@ -0,0 +1,22 @@
+// @ts-check
+
+import BaseColumnsIndex from "../base-columns-index.js"
+import {digg} from "diggerize"
+import TableIndex from "../../table-data/table-index.js"
+
+export default class VelociousDatabaseDriversMysqlColumnsIndex extends BaseColumnsIndex {
+  getColumnNames() {
+    const columnNames = digg(this, "data", "column_names")
+
+    if (columnNames) return columnNames
+
+    return [digg(this, "data", "COLUMN_NAME")]
+  }
+
+  getTableDataIndex() {
+    return new TableIndex(this.getColumnNames(), {
+      name: this.getName(),
+      unique: this.isUnique()
+    })
+  }
+}

package/src/database/drivers/mysql/foreign-key.js

@@ -0,0 +1,12 @@
+// @ts-check
+
+import BaseForeignKey from "../base-foreign-key.js"
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversMysqlForeignKey extends BaseForeignKey {
+  getColumnName() { return digg(this, "data", "COLUMN_NAME") }
+  getName() { return digg(this, "data", "CONSTRAINT_NAME") }
+  getTableName() { return digg(this, "data", "TABLE_NAME") }
+  getReferencedColumnName() { return digg(this, "data", "REFERENCED_COLUMN_NAME") }
+  getReferencedTableName() { return digg(this, "data", "REFERENCED_TABLE_NAME") }
+}