velocious 1.0.46 → 1.0.48

package/src/database/drivers/pgsql/index.js

@@ -1,5 +1,6 @@
+import AlterTable from "./sql/alter-table.js"
 import Base from "../base.js"
-import {Client, escapeLiteral} from "pg"
+import {Client} from "pg"
 import CreateDatabase from "./sql/create-database.js"
 import CreateIndex from "./sql/create-index.js"
 import CreateTable from "./sql/create-table.js"
@@ -49,6 +50,13 @@ export default class VelociousDatabaseDriversPgsql extends Base{
     this.connection = undefined
   }
 
+  async alterTableSql(tableData) {
+    const alterArgs = {tableData, driver: this}
+    const alterTable = new AlterTable(alterArgs)
+
+    return await alterTable.toSqls()
+  }
+
   createDatabaseSql(databaseName, args) {
     const createArgs = Object.assign({databaseName, driver: this}, args)
     const createDatabase = new CreateDatabase(createArgs)
@@ -64,7 +72,7 @@ export default class VelociousDatabaseDriversPgsql extends Base{
   }
 
   createTableSql(tableData) {
-    const createArgs = Object.assign({tableData, driver: this, indexInCreateTable: false})
+    const createArgs = {tableData, driver: this, indexInCreateTable: false}
     const createTable = new CreateTable(createArgs)
 
     return createTable.toSql()

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

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

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

@@ -1,5 +1,6 @@
 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 VelociousDatabaseDriversPgsqlTable extends BaseTable {
@@ -43,10 +44,10 @@ export default class VelociousDatabaseDriversPgsqlTable extends BaseTable {
       WHERE
         constraint_type = 'FOREIGN KEY' AND
         tc.table_catalog = CURRENT_DATABASE() AND
-        tc.table_name = ${this.driver.quote(this.getName())}
+        tc.table_name = ${this.getDriver().quote(this.getName())}
     `
 
-    const foreignKeyRows = await this.driver.query(sql)
+    const foreignKeyRows = await this.getDriver().query(sql)
     const foreignKeys = []
 
     for (const foreignKeyRow of foreignKeyRows) {
@@ -58,6 +59,35 @@ export default class VelociousDatabaseDriversPgsqlTable extends BaseTable {
     return foreignKeys
   }
 
+  async getIndexes() {
+    const options = this.getOptions()
+
+    const indexesRows = await this.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_class.relname = ${options.quote(this.getName())}
+    `)
+
+    const indexes = []
+
+    for (const indexRow of indexesRows) {
+      const columnsIndex = new ColumnsIndex(this, indexRow)
+
+      indexes.push(columnsIndex)
+    }
+
+    return indexes
+  }
+
   getName() {
     return this.data.table_name
   }

package/src/database/drivers/sqlite/base.js

@@ -14,11 +14,11 @@ import Table from "./table.js"
 import Update from "./sql/update.js"
 
 export default class VelociousDatabaseDriversSqliteBase extends Base {
-  alterTableSql(columnData) {
-    const createArgs = Object.assign({driver: this}, columnData)
-    const alterTable = new AlterTable(createArgs)
+  async alterTableSql(tableData) {
+    const alterArgs = {driver: this, tableData}
+    const alterTable = new AlterTable(alterArgs)
 
-    return alterTable.toSqls()
+    return await alterTable.toSqls()
   }
 
   createIndexSql(indexData) {
@@ -29,7 +29,7 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   }
 
   createTableSql(tableData) {
-    const createArgs = Object.assign({tableData, driver: this, indexInCreateTable: false})
+    const createArgs = {tableData, driver: this, indexInCreateTable: false}
     const createTable = new CreateTable(createArgs)
 
     return createTable.toSql()

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

@@ -1,5 +1,5 @@
+import {digg} from "diggerize"
 import BaseColumn from "../base-column.js"
-import ColumnsIndex from "./columns-index.js"
 
 export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
   constructor({column, driver, table}) {
@@ -10,59 +10,51 @@ export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
   }
 
   async getIndexes() {
-    const table = this.getTable()
-    const rows = await this.getDriver().query(`PRAGMA index_list(${this.getOptions().quoteTableName(table.getName())})`)
-    const indexes = []
+    const indexes = await this.getTable().getIndexes()
+    const indexesForColumn = indexes.filter((index) => index.getColumnNames().includes(this.getName()))
 
-    for (const row of rows) {
-      const columnsIndex = new ColumnsIndex(table, row)
-      const indexMasterData = await this.getDriver().query(`SELECT * FROM sqlite_master WHERE type = 'index' AND name = ${this.getOptions().quote(columnsIndex.getName())}`)
-
-      columnsIndex.columnNames = this._parseColumnsFromSQL(indexMasterData[0].sql)
-
-      indexes.push(columnsIndex)
-    }
+    return indexesForColumn
+  }
 
-    return indexes
+  getDefault() {
+    return digg(this, "column", "dflt_value")
   }
 
+  getName() {
+    const name = digg(this, "column", "name")
+
+    if (!name) throw new Error("No name given for SQLite column")
 
-  _parseColumnsFromSQL(sql) {
-    const columnsSQLMatch = sql.match(/\((.+?)\)/)
-    const columnsSQL = columnsSQLMatch[1].split(",")
-    const columnNames = []
+    return name
+  }
 
-    for (const column of columnsSQL) {
-      const matchTicks = column.match(/`(.+)`/)
-      const matchQuotes = column.match(/"(.+)"/)
+  getMaxLength() {
+    const columnType = digg(this, "column", "type")
+    const match = columnType.match(/(.*)\((\d+)\)$/)
 
-      if (matchTicks) {
-        columnNames.push(matchTicks[1])
-      } else if (matchQuotes) {
-        columnNames.push(matchQuotes[1])
-      } else{
-        throw new Error(`Couldn't parse column part: ${column}`)
-      }
+    if (match) {
+      return parseInt(match[2])
     }
-
-    return columnNames
   }
 
-  getName() {
-    if (!this.column.name) {
-      throw new Error("No name given for SQLite column")
-    }
+  getNull() {
+    const notNullValue = digg(this, "column", "notnull")
 
-    return this.column.name
+    if (notNullValue === 1) {
+      return false
+    } else {
+      return true
+    }
   }
 
   getType() {
-    const match = this.column.type.match(/(.*)\((\d+)\)$/)
+    const columnType = digg(this, "column", "type")
+    const match = columnType.match(/(.*)\((\d+)\)$/)
 
     if (match) {
       return match[1].toLowerCase()
     }
 
-    return this.column.type.toLowerCase()
+    return columnType.toLowerCase()
   }
 }

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

@@ -1,17 +1,29 @@
 import BaseColumnsIndex from "../base-columns-index.js"
 import {digg} from "diggerize"
+import TableIndex from "../../table-data/table-index.js"
 
-export default class VelociousDatabaseDriversSqliteColumn extends BaseColumnsIndex {
+export default class VelociousDatabaseDriversSqliteColumnsIndex extends BaseColumnsIndex {
   constructor(table, data) {
     super()
     this.data = data
     this.table = table
   }
 
+  getColumnNames() {
+    return digg(this, "data", "columnNames")
+  }
+
   getName() {
     return digg(this, "data", "name")
   }
 
+  getTableDataIndex() {
+    return new TableIndex(this.getColumnNames(), {
+      name: this.getName(),
+      unique: this.isUnique()
+    })
+  }
+
   isPrimaryKey() {
     return false
   }

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

@@ -1,14 +1,15 @@
+import BaseForeignKey from "../base-foreign-key.js"
 import {digg} from "diggerize"
 
-export default class VelociousDatabaseDriversSqliteForeignKey {
+export default class VelociousDatabaseDriversSqliteForeignKey extends BaseForeignKey {
   constructor(data, {tableName}) {
-    this.data = data
+    super(data)
     this.tableName = tableName
   }
 
-  getColumnName = () => digg(this, "data", "from")
-  getName = () => `${this.getTableName()}_${this.getColumnName()}_${this.data.id}`
-  getTableName = () => digg(this, "tableName")
-  getReferencedColumnName = () => digg(this, "data", "to")
-  getReferencedTableName = () => digg(this, "data", "table")
+  getColumnName() { return digg(this, "data", "from") }
+  getName() { return `${this.getTableName()}_${this.getColumnName()}_${this.data.id}` }
+  getTableName() { return digg(this, "tableName") }
+  getReferencedColumnName() { return digg(this, "data", "to") }
+  getReferencedTableName() { return digg(this, "data", "table") }
 }

package/src/database/drivers/sqlite/index.js

@@ -34,7 +34,7 @@ export default class VelociousDatabaseDriversSqliteNode extends Base {
     this.connection = undefined
   }
 
-  query = async (sql) => {
+  async query(sql) {
     return await query(this.connection, sql)
   }
 }

package/src/database/drivers/sqlite/index.web.js

@@ -45,5 +45,7 @@ export default class VelociousDatabaseDriversSqliteWeb extends Base {
     return `VelociousDatabaseDriversSqliteWeb---${this.args.name}`
   }
 
-  query = async (sql) => await this.getConnection().query(sql)
+  query = async (sql) => {
+    return await this.getConnection().query(sql)
+  }
 }

package/src/database/drivers/sqlite/query.js

@@ -1,5 +1,4 @@
 export default async function query(connection, sql) {
-  const rows = []
   let result
 
   try {
@@ -13,7 +12,7 @@ export default async function query(connection, sql) {
 
     error.message += `\n\n${sqlInErrorMessage}`
 
-    throw error
+    throw new Error(error.message)
   }
 
   return result

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

@@ -1,4 +1,146 @@
 import AlterTableBase from "../../../query/alter-table-base.js"
+import CreateIndexBase from "../../../query/create-index-base.js"
+import {digs} from "diggerize"
+import * as inflection from "inflection"
+import {Logger} from "../../../../logger.js"
+import restArgsError from "../../../../utils/rest-args-error.js"
+import TableData from "../../../table-data/index.js"
 
-export default class VelociousDatabaseConnectionDriversMysqlSqlAlterTable extends AlterTableBase {
+export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable extends AlterTableBase {
+  constructor({driver, tableData, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!(tableData instanceof TableData)) throw new Error("Invalid table data was given")
+
+    super({driver, tableData})
+    this.logger = new Logger(this)
+    this.tableData = tableData
+  }
+
+  async toSqls() {
+    const {tableData} = digs(this, "tableData")
+    const table = await this.getDriver().getTableByName(tableData.getName())
+    const currentTableData = await table.getTableData()
+    const options = this.getOptions()
+    const tableName = tableData.getName()
+    const tempTableName = `${tableData.getName()}AlterTableTemp`
+    const newColumnNames = currentTableData.getColumns()
+      .filter((column) => !column.isNewColumn())
+      .map((column) => {
+        const newTableColumn = tableData.getColumns().find((tableColumn) => tableColumn.getName() == column.getName())
+
+        return newTableColumn?.getNewName() || newTableColumn?.getName() || column.getNewName() || column.getName()
+      })
+    const oldColumnNames = currentTableData.getColumns().filter((column) => !column.isNewColumn()).map((column) => column.getName())
+    const newColumnsSQL = newColumnNames.map((name) => options.quoteColumnName(name)).join(", ")
+    const oldColumnsSQL = oldColumnNames.map((name) => options.quoteColumnName(name)).join(", ")
+
+    tableData.setName(tempTableName)
+
+    const newTableData = new TableData(tempTableName)
+
+    for (const tableDataColumn of currentTableData.getColumns()) {
+      const newTableDataColumn = tableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == tableDataColumn.getName())
+
+      if (newTableDataColumn) {
+        const settingsToClone = ["autoIncrement", "default", "index", "foreignKey", "maxLength", "primaryKey", "type"]
+
+        for (const settingToClone of settingsToClone) {
+          const camelizedSettingToClone = inflection.camelize(settingToClone)
+
+          if (!newTableDataColumn[`get${camelizedSettingToClone}`]) {
+            throw new Error(`No such method on column: get${camelizedSettingToClone}`)
+          }
+
+          if (!newTableDataColumn[`get${camelizedSettingToClone}`]()) {
+            newTableDataColumn[`set${camelizedSettingToClone}`](tableDataColumn[`get${camelizedSettingToClone}`]())
+          }
+        }
+      }
+
+      newTableData.addColumn(newTableDataColumn || tableDataColumn)
+    }
+
+    for (const tableDataColumn of tableData.getColumns()) {
+      if (!tableDataColumn.isNewColumn()) continue
+
+      newTableData.addColumn(tableDataColumn)
+    }
+
+    const foundForeignKeys = []
+
+    for (const tableDataForeignKey of currentTableData.getForeignKeys()) {
+      const newTableDataForeignKey = newTableData.getForeignKeys().find((newTableDataForeignKey) => newTableDataForeignKey.getName() == tableDataForeignKey.getName())
+
+      if (newTableDataForeignKey) foundForeignKeys.push(newTableDataForeignKey.getName())
+
+      const actualTableDataForeignKey = newTableDataForeignKey || tableDataForeignKey
+
+      // Register foreign key on the table
+      newTableData.addForeignKey(actualTableDataForeignKey)
+
+      // Register foreign key on the column
+      const tableDataColumn = newTableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == actualTableDataForeignKey.getColumnName())
+
+      if (!tableDataColumn) throw new Error(`Couldn't find column for foreign key: ${actualTableDataForeignKey.getName()}`)
+
+      this.logger.debug(() => [`Setting foreign key on column ${tableDataColumn.getName()}`])
+      tableDataColumn.setForeignKey(actualTableDataForeignKey)
+    }
+
+    for (const foreignKey of tableData.getForeignKeys()) {
+      if (foundForeignKeys.includes(foreignKey.getName())) continue
+
+      // Register foreign key on the table
+      newTableData.addForeignKey(foreignKey)
+
+      // Register foreign key on the column
+      const tableDataColumn = newTableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == foreignKey.getColumnName())
+
+      if (!tableDataColumn) throw new Error(`Couldn't find column for foreign key: ${actualTableDataForeignKey.getName()}`)
+
+      this.logger.debug(() => [`Setting foreign key on column ${tableDataColumn.getName()}`])
+      tableDataColumn.setForeignKey(actualTableDataForeignKey)
+    }
+
+    const createNewTableSQL = this.getDriver().createTableSql(newTableData)
+    const insertSQL = `INSERT INTO ${options.quoteTableName(tempTableName)} (${newColumnsSQL}) SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(tableName)}`
+    const dropTableSQL = `DROP TABLE ${options.quoteTableName(tableName)}`
+    const renameTableSQL = `ALTER TABLE ${options.quoteTableName(tempTableName)} RENAME TO ${options.quoteTableName(tableName)}`
+    const sqls = []
+
+    for (const sql of createNewTableSQL) {
+      sqls.push(sql)
+    }
+
+    sqls.push(insertSQL)
+    sqls.push(dropTableSQL)
+    sqls.push(renameTableSQL)
+
+    for (const tableDataIndex of currentTableData.getIndexes()) {
+      const newTableDataIndex = newTableData.getIndexes().find((newTableDataIndex) => newTableDataIndex.getName() == tableDataIndex.getName())
+      const actualTableIndex = newTableDataIndex || tableDataIndex
+
+      newTableData.addIndex(actualTableIndex)
+
+      const columnNames = actualTableIndex.getColumns().map((columnName) => {
+        const newTableColumn = tableData.getColumns().find((tableColumn) => tableColumn.getName() == columnName)
+
+        return newTableColumn?.getNewName() || newTableColumn?.getName() || columnName
+      })
+
+      const createIndexArgs = {
+        columns: columnNames,
+        driver: this.getDriver(),
+        name: actualTableIndex.getName(),
+        tableName,
+        unique: actualTableIndex.getUnique()
+      }
+      const sql = new CreateIndexBase(createIndexArgs).toSql()
+
+      sqls.push(sql)
+    }
+
+    return sqls
+  }
 }

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

@@ -1,5 +1,6 @@
 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 VelociousDatabaseDriversSqliteTable extends BaseTable {
@@ -35,6 +36,43 @@ export default class VelociousDatabaseDriversSqliteTable extends BaseTable {
     return foreignKeys
   }
 
+  async getIndexes() {
+    const rows = await this.getDriver().query(`PRAGMA index_list(${this.getOptions().quoteTableName(this.getName())})`)
+    const indexes = []
+
+    for (const row of rows) {
+      const columnsIndex = new ColumnsIndex(this, row)
+      const indexMasterData = await this.getDriver().query(`SELECT * FROM sqlite_master WHERE type = 'index' AND name = ${this.getOptions().quote(columnsIndex.getName())}`)
+
+      columnsIndex.data.columnNames = this._parseColumnsFromSQL(indexMasterData[0].sql)
+
+      indexes.push(columnsIndex)
+    }
+
+    return indexes
+  }
+
+  _parseColumnsFromSQL(sql) {
+    const columnsSQLMatch = sql.match(/\((.+?)\)/)
+    const columnsSQL = columnsSQLMatch[1].split(",")
+    const columnNames = []
+
+    for (const column of columnsSQL) {
+      const matchTicks = column.match(/`(.+)`/)
+      const matchQuotes = column.match(/"(.+)"/)
+
+      if (matchTicks) {
+        columnNames.push(matchTicks[1])
+      } else if (matchQuotes) {
+        columnNames.push(matchQuotes[1])
+      } else{
+        throw new Error(`Couldn't parse column part: ${column}`)
+      }
+    }
+
+    return columnNames
+  }
+
   getName() {
     if (!this.row.name) {
       throw new Error("No name given for SQLite table")

package/src/database/migration/index.js

@@ -1,6 +1,6 @@
 import * as inflection from "inflection"
 import restArgsError from "../../utils/rest-args-error.js"
-import TableData, {TableColumn} from "../table-data/index.js"
+import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseMigration {
   static onDatabases(databaseIdentifiers) {
@@ -29,15 +29,17 @@ export default class VelociousDatabaseMigration {
   getDriver() { return this._db }
 
   async addColumn(tableName, columnName, columnType, args) {
-    const tableColumnArgs = Object.assign({type: columnType}, args)
+    if (!columnType) throw new Error("No column type given")
 
-    const sqls = this._db.alterTableSql({
-      columns: [new TableColumn(columnName, tableColumnArgs)],
-      tableName
-    })
+    const tableColumnArgs = Object.assign({isNewColumn: true, type: columnType}, args)
+    const tableData = new TableData(tableName)
+
+    tableData.addColumn(columnName, tableColumnArgs)
+
+    const sqls = await this.getDriver().alterTableSql(tableData)
 
     for (const sql of sqls) {
-      await this._db.query(sql)
+      await this.getDriver().query(sql)
     }
   }
 
@@ -49,9 +51,9 @@ export default class VelociousDatabaseMigration {
       },
       args
     )
-    const sql = this._db.createIndexSql(createIndexArgs)
+    const sql = this.getDriver().createIndexSql(createIndexArgs)
 
-    await this._db.query(sql)
+    await this.getDriver().query(sql)
   }
 
   async addForeignKey(tableName, referenceName) {
@@ -66,20 +68,30 @@ export default class VelociousDatabaseMigration {
     sql += ` FOREIGN KEY (${this._db.quoteColumn(columnName)})`
     sql += ` REFERENCES ${tableNameUnderscore}(id)`
 
-    await this._db.query(sql)
+    await this.getDriver().query(sql)
   }
 
   async addReference(tableName, referenceName, args) {
+    const {foreignKey, type, unique, ...restArgs} = args
     const columnName = `${inflection.underscore(referenceName)}_id`
 
-    await this.addColumn(tableName, columnName, {type: args?.type})
-    await this.addIndex(tableName, [columnName], {unique: args?.unique})
+    restArgsError(restArgs)
+
+    await this.addColumn(tableName, columnName, type || "integer")
+    await this.addIndex(tableName, [columnName], {unique: unique})
 
-    if (args?.foreignKey) {
+    if (foreignKey) {
       await this.addForeignKey(tableName, referenceName)
     }
   }
 
+  async changeColumnNull(tableName, columnName, nullable) {
+    const table = await this.getDriver().getTableByName(tableName)
+    const column = await table.getColumnByName(columnName)
+
+    await column.changeNullable(nullable)
+  }
+
   async createTable(tableName, arg1, arg2) {
     let args
     let callback
@@ -111,15 +123,19 @@ export default class VelociousDatabaseMigration {
       callback(tableData)
     }
 
-    const sqls = this._db.createTableSql(tableData)
+    const sqls = this.getDriver().createTableSql(tableData)
 
     for (const sql of sqls) {
       await this._db.query(sql)
     }
   }
 
+  async renameColumn(tableName, oldColumnName, newColumnName) {
+    await this.getDriver().renameColumn(tableName, oldColumnName, newColumnName)
+  }
+
   async tableExists(tableName) {
-    const exists = await this._db.tableExists(tableName)
+    const exists = await this.getDriver().tableExists(tableName)
 
     return exists
   }

package/src/database/query/alter-table-base.js

@@ -1,26 +1,51 @@
+import {digs} from "diggerize"
 import QueryBase from "./base.js"
 import restArgsError from "../../utils/rest-args-error.js"
+import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
-  constructor({columns, driver, tableName, ...restArgs}) {
+  constructor({driver, tableData, ...restArgs}) {
     restArgsError(restArgs)
 
+    if (!(tableData instanceof TableData)) throw new Error("Invalid table data was given")
+
     super({driver})
-    this.columns = columns
-    this.tableName = tableName
+    this.tableData = tableData
   }
 
   toSqls() {
+    const databaseType = this.getDriver().getType()
     const sqls = []
+    const {tableData} = digs(this, "tableData")
+    const options = this.getOptions()
+
+    let sql = `ALTER TABLE ${options.quoteTableName(tableData.getName())} `
+    let columnsCount = 0
+
+    for (const column of tableData.getColumns()) {
+      if (columnsCount > 0) sql += ", "
 
-    for (const column of this.columns) {
-      let sql = `ALTER TABLE ${this.getOptions().quoteTableName(this.tableName)} ADD `
+      if (column.isNewColumn()) {
+        sql += "ADD "
+        sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
+      } else if (column.getNewName()) {
+        sql += `RENAME COLUMN ${options.quoteColumnName(column.getName())} TO ${options.quoteColumnName(column.getNewName())}`
+      } else {
+        if (databaseType == "mssql" || databaseType == "pgsql") {
+          sql += "ALTER COLUMN "
+        } else {
+          sql += "MODIFY "
+        }
 
-      sql += this.getOptions().quoteColumnName(column.getName())
+        sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
+      }
 
-      sqls.push(sql)
+
+      columnsCount++
     }
 
+    sqls.push(sql)
+
     return sqls
   }
 }