velocious 1.0.430 → 1.0.432

package/build/database/drivers/mysql/sql/upsert.js

@@ -0,0 +1,13 @@
+// @ts-check
+
+import UpsertBase from "../../../query/upsert-base.js"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlUpsert extends UpsertBase {
+  toSql() {
+    const updateSql = this.updateColumns.map((columnName) => {
+      return `${this.quotedColumn(columnName)} = VALUES(${this.quotedColumn(columnName)})`
+    }).join(", ")
+
+    return `INSERT INTO ${this.quotedTableName()} (${this.quotedInsertColumnsSql()}) VALUES (${this.quotedInsertValuesSql()}) ON DUPLICATE KEY UPDATE ${updateSql}`
+  }
+}

package/build/database/drivers/mysql/structure-sql.js

@@ -0,0 +1,93 @@
+// @ts-check
+
+import {normalizeSqlStatement} from "../structure-sql/utils.js"
+
+export default class VelociousDatabaseDriversMysqlStructureSql {
+  /**
+   * 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 isMariaDb = await this._isMariaDb()
+    const rows = await driver.query("SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = DATABASE() 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 createRows = await driver.query(`SHOW CREATE TABLE ${driver.quoteTable(tableName)}`)
+        const rawCreateStatement = this._mysqlCreateStatement(createRows?.[0])
+        const createStatement = rawCreateStatement ? this._stripAutoIncrement(rawCreateStatement) : null
+
+        if (createStatement) statements.push(normalizeSqlStatement(createStatement))
+      } else if (tableType == "VIEW" || (isMariaDb && tableType == "SYSTEM VIEW")) {
+        const createRows = await driver.query(`SHOW CREATE VIEW ${driver.quoteTable(tableName)}`)
+        const createStatement = this._mysqlCreateStatement(createRows?.[0])
+
+        if (createStatement) statements.push(normalizeSqlStatement(createStatement))
+      }
+    }
+
+    if (statements.length == 0) return null
+
+    return `${statements.join("\n\n")}\n`
+  }
+
+  /**
+   * Runs is maria db.
+   * @returns {Promise<boolean>} - Resolves with Whether maria db.
+   */
+  async _isMariaDb() {
+    const {driver} = this
+    const rows = await driver.query("SELECT VERSION() AS version")
+    const version = rows?.[0]?.version || rows?.[0]?.VERSION
+
+    if (!version) return false
+
+    return String(version).toLowerCase().includes("mariadb")
+  }
+
+  /**
+   * Runs mysql create statement.
+   * @param {Record<string, ?> | undefined} row - Row data.
+   * @returns {string | null} - SQL string.
+   */
+  _mysqlCreateStatement(row) {
+    if (!row) return null
+
+    for (const key of Object.keys(row)) {
+      if (key.toLowerCase().startsWith("create ")) {
+        return String(row[key])
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Runs strip auto increment.
+   * @param {string} statement - Statement.
+   * @returns {string} - Statement without auto increment.
+   */
+  _stripAutoIncrement(statement) {
+    return statement
+      .replace(/\sAUTO_INCREMENT\s*=\s*\d+/gi, "")
+      .replace(/\s{2,}/g, " ")
+  }
+}

package/build/database/drivers/mysql/table.js

@@ -0,0 +1,121 @@
+// @ts-check
+
+import BaseTable from "../base-table.js"
+import Column from "./column.js"
+import ColumnsIndex from "./columns-index.js"
+import ForeignKey from "./foreign-key.js"
+
+export default class VelociousDatabaseDriversMysqlTable 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(`SHOW FULL COLUMNS FROM \`${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 TABLE_NAME, COLUMN_NAME, CONSTRAINT_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+        FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+        WHERE
+          REFERENCED_TABLE_SCHEMA = (SELECT DATABASE()) AND
+          TABLE_NAME = ${this.driver.quote(this.getName())}
+      `
+
+      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
+          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.getName())}
+        ORDER BY
+          INDEX_NAME,
+          SEQ_IN_INDEX
+      `
+      const indexesRows = await this.getDriver().query(sql)
+      const indexes = []
+      const indexRowsByName = new Map()
+
+      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 existingIndexRow = indexRowsByName.get(indexRow.index_name)
+
+        if (existingIndexRow) {
+          existingIndexRow.column_names.push(indexRow.COLUMN_NAME)
+        } else {
+          const groupedIndexRow = Object.assign({}, indexRow, {
+            column_names: [indexRow.COLUMN_NAME]
+          })
+          const index = new ColumnsIndex(this, groupedIndexRow)
+
+          indexRowsByName.set(indexRow.index_name, groupedIndexRow)
+          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} */ (Object.values(this.data)[0])
+  }
+}

package/build/database/drivers/pgsql/column.js

@@ -0,0 +1,90 @@
+// @ts-check
+
+import BaseColumn from "../base-column.js"
+import ColumnsIndex from "./columns-index.js"
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversPgsqlColumn 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 this.getDefault() == `nextval('${this.getTable().getName()}_${this.getName()}_seq'::regclass)`
+  }
+
+  getPrimaryKey() {
+    return digg(this, "data", "is_primary_key") === 1
+  }
+
+  async getIndexes() {
+    const options = this.getOptions()
+
+    const indexesRows = await this.table.getDriver().query(`
+      SELECT
+        pg_attribute.attname AS column_name,
+        pg_index.indexrelid::regclass as index_name,
+        pg_class.relnamespace::regnamespace as schema_name,
+        pg_class.relname as table_name,
+        pg_index.indisprimary as is_primary_key,
+        pg_index.indisunique as is_unique
+      FROM pg_index
+      JOIN pg_class ON pg_class.oid = pg_index.indrelid
+      JOIN pg_attribute ON pg_attribute.attrelid = pg_class.oid AND pg_attribute.attnum = ANY(pg_index.indkey)
+      WHERE
+        pg_attribute.attname = ${options.quote(this.getName())} AND
+        pg_class.relname = ${options.quote(this.getTable().getName())}
+    `)
+
+    const indexes = []
+
+    for (const indexRow of indexesRows) {
+      const columnsIndex = new ColumnsIndex(this.getTable(), indexRow)
+
+      indexes.push(columnsIndex)
+    }
+
+    return indexes
+  }
+
+  getDefault() {
+    return digg(this, "data", "column_default")
+  }
+
+  getMaxLength() {
+    return digg(this, "data", "character_maximum_length")
+  }
+
+  getName() {
+    return digg(this, "data", "column_name")
+  }
+
+  getNotes() {
+    return digg(this, "data", "column_comment") || undefined
+  }
+
+  getNull() {
+    const nullValue = digg(this, "data", "is_nullable")
+
+    if (nullValue == "NO") {
+      return false
+    } else {
+      return true
+    }
+  }
+
+  getType() {
+    const typeHint = this.getTypeHintFromNotes()
+
+    if (typeHint == "boolean") return "boolean"
+
+    return digg(this, "data", "data_type")
+  }
+}

package/build/database/drivers/pgsql/columns-index.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import BaseColumnsIndex from "../base-columns-index.js"
+
+export default class VelociousDatabaseDriversPgsqlColumn extends BaseColumnsIndex {
+}

package/build/database/drivers/pgsql/foreign-key.js

@@ -0,0 +1,12 @@
+// @ts-check
+
+import BaseForeignKey from "../base-foreign-key.js"
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversPgsqlForeignKey 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", "foreign_column_name") }
+  getReferencedTableName() { return digg(this, "data", "foreign_table_name") }
+}