leoric 2.3.2 → 2.4.0

package/src/drivers/postgres/schema.js

@@ -1,125 +0,0 @@
-'use strict';
-
-const SqlString = require('sqlstring');
-
-const schema = require('../abstract/schema');
-const Attribute = require('./attribute');
-const { heresql } = require('../../utils/string');
-
-/**
- * - https://www.postgresql.org/docs/9.1/sql-altertable.html
- * @param {string} columnName
- * @param {Object} attribute
- */
-function formatAlterColumns(driver, columnName, attribute) {
-  const { allowNull, type, defaultValue } = attribute;
-  const sets = [
-    `TYPE ${type.toSqlString()}`,
-    allowNull ? 'DROP NOT NULL' : 'SET NOT NULL',
-    defaultValue == null
-      ? 'DROP DEFAULT'
-      : `SET DEFAULT ${SqlString.escape(defaultValue)}`,
-  ];
-
-  return sets.map(entry => `ALTER COLUMN ${driver.escapeId(columnName)} ${entry}`);
-}
-
-function formatAddColumn(driver, columnName, attribute) {
-  return `ADD COLUMN ${attribute.toSqlString()}`;
-}
-
-function formatDropColumn(driver, columnName) {
-  return `DROP COLUMN ${driver.escapeId(columnName)}`;
-}
-
-module.exports = {
-  ...schema,
-
-  async querySchemaInfo(database, tables) {
-    tables = [].concat(tables);
-    const text = heresql(`
-      SELECT columns.*,
-             constraints.constraint_type
-        FROM information_schema.columns AS columns
-   LEFT JOIN information_schema.key_column_usage AS usage
-          ON columns.table_catalog = usage.table_catalog
-         AND columns.table_name = usage.table_name
-         AND columns.column_name = usage.column_name
-   LEFT JOIN information_schema.table_constraints AS constraints
-          ON usage.constraint_name = constraints.constraint_name
-       WHERE columns.table_catalog = $1 AND columns.table_name = ANY($2)
-    `);
-
-    const { pool } = this;
-    const { rows } = await pool.query(text, [database, tables]);
-    const schemaInfo = {};
-
-    for (const row of rows) {
-      const tableName = row.table_name;
-      const columns = schemaInfo[tableName] || (schemaInfo[tableName] = []);
-      let { data_type: dataType, character_maximum_length: length } = row;
-
-      if (dataType === 'character varying') dataType = 'varchar';
-      if (dataType === 'timestamp without time zone') dataType = 'timestamp';
-
-      let columnDefault = row.column_default;
-      if (/^NULL::/i.test(columnDefault)) columnDefault = null;
-      if (dataType === 'boolean') columnDefault = columnDefault === 'true';
-
-      const primaryKey = row.constraint_type === 'PRIMARY KEY';
-      const precision = row.datetime_precision;
-
-      columns.push({
-        columnName: row.column_name,
-        columnType: length > 0 ? `${dataType}(${length})` : dataType,
-        defaultValue: primaryKey ? null : columnDefault,
-        dataType,
-        allowNull: row.is_nullable !== 'NO',
-        // https://www.postgresql.org/docs/9.5/infoschema-table-constraints.html
-        primaryKey,
-        unique: row.constraint_type === 'UNIQUE',
-        datetimePrecision: precision === 6 ? null : precision,
-      });
-    }
-
-    return schemaInfo;
-  },
-
-  async alterTable(table, changes) {
-    const { escapeId } = this;
-    const chunks = [ `ALTER TABLE ${escapeId(table)}` ];
-    const actions = Object.keys(changes).map(name => {
-      const options = changes[name];
-      if (options.remove) return formatDropColumn(this, name);
-      const attribute = new Attribute(name, options);
-      const { columnName } = attribute;;
-      return attribute.modify
-        ? formatAlterColumns(this, columnName, attribute).join(', ')
-        : formatAddColumn(this, columnName, attribute);
-    });
-    chunks.push(actions.join(', '));
-    await this.query(chunks.join(' '));
-  },
-
-  async changeColumn(table, column, params) {
-    const { escapeId } = this;
-    const attribute = new Attribute(column, params);
-    const { columnName } = attribute;
-    const alterColumns = formatAlterColumns(this, columnName, attribute);
-    const sql = heresql(`ALTER TABLE ${escapeId(table)} ${alterColumns.join(', ')}`);
-    await this.query(sql);
-  },
-
-  /**
-   * Truncate table
-   * @param {string} table the name of the table to truncate
-   * @param {Object} [opts={}] extra truncation options
-   * @param {object} [opts.restartIdentity] restart sequences owned by the table
-   */
-  async truncateTable(table, opts = {}) {
-    const { escapeId } = this;
-    const chunks = [ `TRUNCATE TABLE ${escapeId(table)}` ];
-    if (opts.restartIdentity) chunks.push('RESTART IDENTITY');
-    await this.query(chunks.join(' '));
-  },
-};

package/src/drivers/sqlite/schema.js

@@ -1,211 +0,0 @@
-'use strict';
-
-const debug = require('debug')('leoric');
-const SqlString = require('sqlstring');
-
-const { parseExpr } = require('../../expr');
-const { heresql } = require('../../utils/string');
-const schema = require('../abstract/schema');
-const Attribute = require('./attribute');
-
-/**
- * Schema altering commands other than RENAME COLUMN or ADD COLUMN
- * - https://www.sqlite.org/lang_altertable.html
- * @param {string} table
- * @param {Object} attributes the changed attributes
- */
-async function alterTableWithChangeColumn(driver, table, changes) {
-  const { escapeId } = driver;
-  const schemaInfo = await driver.querySchemaInfo(null, table);
-  const columns = schemaInfo[table];
-
-  const changeMap = changes.reduce((result, entry) => {
-    result[entry.columnName] = entry;
-    return result;
-  }, {});
-
-  const newAttributes = [];
-  for (const column of columns) {
-    const { columnName } = column;
-    const change = changeMap[columnName];
-    if (!change || !change.remove) {
-      newAttributes.push(Object.assign(column, change));
-    }
-  }
-
-  for (const attribute of changes) {
-    if (!attribute.modify && !attribute.remove) {
-      newAttributes.push(attribute);
-    }
-  }
-
-  const newColumns = [];
-  for (const attribute of newAttributes) {
-    const { columnName, defaultValue } = attribute;
-    const change = changeMap[columnName];
-    if (!change || change.modify) {
-      newColumns.push(escapeId(columnName));
-    } else {
-      newColumns.push(SqlString.escape(defaultValue));
-    }
-  }
-
-  const connection = await driver.getConnection();
-  await connection.query('BEGIN');
-  try {
-    const newTable = `new_${table}`;
-    await driver.createTable(newTable, newAttributes, { connection });
-    await connection.query(heresql(`
-      INSERT INTO ${escapeId(newTable)}
-      SELECT ${newColumns.join(', ')}
-      FROM ${escapeId(table)}
-    `));
-    await connection.query(`DROP TABLE ${escapeId(table)}`);
-    await connection.query(heresql(`
-      ALTER TABLE ${escapeId(newTable)}
-      RENAME TO ${escapeId(table)}
-    `));
-    await connection.query('COMMIT');
-  } catch (err) {
-    await connection.query('ROLLBACK');
-    throw err;
-  } finally {
-    await connection.release();
-  }
-}
-
-// eslint-disable-next-line no-unused-vars
-function parseDefaultValue(text, type) {
-  if (typeof text !== 'string') return text;
-  if (type === 'boolean') return text === 'true';
-
-  try {
-    const ast = parseExpr(text);
-    if (ast.type === 'literal') {
-      return ast.value;
-    }
-  } catch (err) {
-    debug('[parseDefaultValue] [%s] %s', text, err);
-  }
-
-  return text;
-}
-
-module.exports = {
-  ...schema,
-
-  async querySchemaInfo(database, tables) {
-    tables = [].concat(tables);
-
-    const queries = tables.map(table => {
-      return this.query(`PRAGMA table_info(${this.escapeId(table)})`);
-    });
-    const results = await Promise.all(queries);
-    const schemaInfo = {};
-    const rColumnType = /^(\w+)(?:\(([^)]+)\))?/i;
-    const rDateType = /(?:date|datetime|timestamp)/i;
-
-    for (let i = 0; i < tables.length; i++) {
-      const table = tables[i];
-      const { rows } = results[i];
-      const columns = rows.map(row => {
-        const { name, type, notnull, dflt_value, pk } = row;
-        const columnType = type.toLowerCase();
-        const [, dataType, precision ] = columnType.match(rColumnType);
-        const primaryKey = pk === 1;
-
-        const result = {
-          columnName: name,
-          columnType,
-          defaultValue: parseDefaultValue(dflt_value, type),
-          dataType: dataType,
-          allowNull: primaryKey ? false : notnull == 0,
-          primaryKey,
-          datetimePrecision: rDateType.test(dataType) ? parseInt(precision, 10) : null,
-        };
-        return result;
-      });
-      if (columns.length > 0) schemaInfo[table] = columns;
-    }
-
-    return schemaInfo;
-  },
-
-  async createTable(table, attributes, opts = {}) {
-    const { escapeId } = this;
-    const chunks = [ `CREATE TABLE ${escapeId(table)}` ];
-    const columns = Object.keys(attributes).map(name => {
-      const attribute = new Attribute(name, attributes[name]);
-      return attribute.toSqlString();
-    });
-    chunks.push(`(${columns.join(', ')})`);
-    await this.query(chunks.join(' '), [], opts);
-  },
-
-  async alterTable(table, changes) {
-    const { escapeId } = this;
-    const chunks = [ `ALTER TABLE ${escapeId(table)}` ];
-    const attributes = Object.keys(changes).map(name => {
-      const options = changes[name];
-      if (options.remove) return { columnName: name, remove: true };
-      return new Attribute(name, changes[name]);
-    });
-
-    // SQLite doesn't support altering column attributes with MODIFY COLUMN and adding a PRIMARY KEY column
-    if (attributes.some(entry => entry.modify || entry.primaryKey)) {
-      await alterTableWithChangeColumn(this, table, attributes);
-      return;
-    }
-
-    // SQLite can only add one column a time
-    // - https://www.sqlite.org/lang_altertable.html
-    for (const attribute of attributes) {
-      if (attribute.remove) {
-        const { columnName } = attribute;
-        await this.query(chunks.concat(`DROP COLUMN ${this.escapeId(columnName)}`).join(' '));
-      } else {
-        await this.query(chunks.concat(`ADD COLUMN ${attribute.toSqlString()}`).join(' '));
-      }
-    }
-  },
-
-  async addColumn(table, name, params) {
-    const { escapeId } = this;
-    const attribute = new Attribute(name, params);
-    const sql = heresql(`
-      ALTER TABLE ${escapeId(table)}
-      ADD COLUMN ${attribute.toSqlString()}
-    `);
-    await this.query(sql);
-  },
-
-  async changeColumn(table, name, params) {
-    const attribute = new Attribute(name, params);
-    const schemaInfo = await this.querySchemaInfo(null, table);
-    const columns = schemaInfo[table];
-
-    for (const entry of columns) {
-      if (entry.columnName === attribute.columnName) {
-        Object.assign(entry, attribute, { modify: true });
-      }
-    }
-
-    await this.alterTable(table, columns);
-  },
-
-  async removeColumn(table, name) {
-    const attribute = new Attribute(name);
-    attribute.remove = true;
-    const changes = [ attribute ];
-    await alterTableWithChangeColumn(this, table, changes);
-  },
-
-  /**
-   * SQLite has only got implicit table truncation.
-   * - https://sqlite.org/lang_delete.html#the_truncate_optimization
-   */
-  async truncateTable(table) {
-    const { escapeId } = this;
-    await this.query(`DELETE FROM ${escapeId(table)}`);
-  }
-};