velocious 1.0.47 → 1.0.49

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

@@ -9,6 +9,8 @@ export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
     this.table = table
   }
 
+  getAutoIncrement() { return this.getPrimaryKey() }
+
   async getIndexes() {
     const indexes = await this.getTable().getIndexes()
     const indexesForColumn = indexes.filter((index) => index.getColumnNames().includes(this.getName()))
@@ -16,9 +18,7 @@ export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
     return indexesForColumn
   }
 
-  getDefault() {
-    return digg(this, "column", "dflt_value")
-  }
+  getDefault() { return digg(this, "column", "dflt_value") }
 
   getName() {
     const name = digg(this, "column", "name")
@@ -47,6 +47,8 @@ export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
     }
   }
 
+  getPrimaryKey() { return digg(this, "column", "pk") == 1 }
+
   getType() {
     const columnType = digg(this, "column", "type")
     const match = columnType.match(/(.*)\((\d+)\)$/)

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

@@ -1,8 +1,8 @@
 import BaseColumnsIndex from "../base-columns-index.js"
 import {digg} from "diggerize"
-import {TableIndex} from "../../table-data/index.js"
+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

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

@@ -35,6 +35,8 @@ export default class VelociousDatabaseDriversSqliteNode extends Base {
   }
 
   async query(sql) {
+    console.error("SQL: ", sql)
+
     return await query(this.connection, sql)
   }
 }

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

@@ -56,7 +56,9 @@ export default class VelociousDatabaseDriversSqliteNative extends Base {
     this.connection = undefined
   }
 
-  query = async (sql) => {
+  async query(sql) {
+    console.error("Native SQL: ", sql)
+
     if (!this.connection) throw new Error("Not connected yet")
 
     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/sql/alter-table.js

@@ -1,6 +1,8 @@
 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"
 
@@ -11,6 +13,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
     if (!(tableData instanceof TableData)) throw new Error("Invalid table data was given")
 
     super({driver, tableData})
+    this.logger = new Logger(this)
     this.tableData = tableData
   }
 
@@ -21,7 +24,15 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
     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)
@@ -29,13 +40,73 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
     const newTableData = new TableData(tempTableName)
 
     for (const tableDataColumn of currentTableData.getColumns()) {
-      const newTableDataColumn = newTableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == tableDataColumn.getName())
+      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()) {
+      console.log(`Foreign key`, {foreignKey})
+
+      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(foreignKey)
+    }
+
     const createNewTableSQL = this.getDriver().createTableSql(newTableData)
-    const insertSQL = `INSERT INTO ${options.quoteTableName(tempTableName)} (${oldColumnsSQL}) SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(tableName)}`
+    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 = []
@@ -54,10 +125,14 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
 
       newTableData.addIndex(actualTableIndex)
 
-      console.log({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: actualTableIndex.getColumns(),
+        columns: columnNames,
         driver: this.getDriver(),
         name: actualTableIndex.getName(),
         tableName,
@@ -68,8 +143,6 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
       sqls.push(sql)
     }
 
-    console.log({sqls})
-
     return sqls
   }
 }

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 tableColumnArgs = Object.assign({isNewColumn: true, type: columnType}, args)
     const tableData = new TableData(tableName)
 
     tableData.addColumn(columnName, tableColumnArgs)
 
-    const sqls = await this._db.alterTableSql(tableData)
+    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) {
@@ -59,23 +61,29 @@ export default class VelociousDatabaseMigration {
     const tableNameUnderscore = inflection.underscore(tableName)
     const columnName = `${referenceNameUnderscore}_id`
     const foreignKeyName = `fk_${tableName}_${referenceName}`
-    let sql = ""
-
-    sql += `ALTER TABLE ${this._db.quoteTable(tableName)}`
-    sql += ` ADD CONSTRAINT ${foreignKeyName} `
-    sql += ` FOREIGN KEY (${this._db.quoteColumn(columnName)})`
-    sql += ` REFERENCES ${tableNameUnderscore}(id)`
 
-    await this._db.query(sql)
+    await this.getDriver().addForeignKey(
+      tableName,
+      columnName,
+      tableNameUnderscore,
+      "id",
+      {
+        isNewForeignKey: true,
+        name: foreignKeyName
+      }
+    )
   }
 
   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)
     }
   }
@@ -118,15 +126,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

@@ -27,15 +27,20 @@ export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
 
       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 += column.getSQL({driver: this.getDriver(), forAlterTable: true})
       }
 
-      sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
+
       columnsCount++
     }
 

package/src/database/query/create-index-base.js

@@ -12,7 +12,10 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
   }
 
   generateIndexName() {
-    let indexName = `index_on_${this.tableName}_`
+    const databaseType = this.getDriver().getType()
+    let indexName = `index_on_`
+
+    if (databaseType == "sqlite") indexName += `${this.tableName}_`
 
     for (const columnIndex in this.columns) {
       if (columnIndex > 0) indexName += "_and_"
@@ -33,17 +36,34 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
   }
 
   toSql() {
+    const databaseType = this.getDriver().getType()
+    const indexName = this.name || this.generateIndexName()
     const options = this.getOptions()
     const {tableName} = this
-    let sql = "CREATE"
+    let sql = ""
+
+    if (this.ifNotExists && databaseType == "mssql") {
+      sql += `
+        IF NOT EXISTS (
+          SELECT 1
+          FROM sys.indexes
+          WHERE
+            name = ${options.quote(indexName)} AND
+            object_id = OBJECT_ID(${options.quote(`dbo.${tableName}`)})
+        )
+        BEGIN
+      `
+    }
+
+    sql += "CREATE"
 
     if (this.unique) sql += " UNIQUE"
 
     sql += " INDEX"
 
-    if (this.ifNotExists) sql += " IF NOT EXISTS"
+    if (this.ifNotExists && databaseType != "mssql") sql += " IF NOT EXISTS"
 
-    sql += ` ${options.quoteIndexName(this.name || this.generateIndexName())}`
+    sql += ` ${options.quoteIndexName(indexName)}`
     sql += ` ON ${options.quoteTableName(tableName)} (`
 
     for (const columnIndex in this.columns) {
@@ -63,6 +83,10 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
 
     sql += ")"
 
+    if (this.ifNotExists && databaseType == "mssql") {
+      sql += " END"
+    }
+
     return sql
   }
 }

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

@@ -68,10 +68,15 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         sql += ")"
       }
 
+      // Create indexes for all columns with the index argument
       for (const column of tableData.getColumns()) {
         if (!column.getIndex()) continue
 
-        const indexName = `index_on_${tableData.getName()}_${column.getName()}`
+        let indexName = `index_on_`
+
+        if (databaseType == "sqlite") sql += `${tableData.getName()}_`
+
+        indexName += column.getName()
 
         sql += ","
 
@@ -100,6 +105,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         const createIndexArgs = {
           columns: index.getColumns(),
           driver: this.getDriver(),
+          ifNotExists: true,
           name: index.getName(),
           tableName: tableData.getName(),
           unique: index.getUnique()
@@ -109,14 +115,20 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         sqls.push(sql)
       }
 
+      // Create indexes for all columns with the index argument
       for (const column of tableData.getColumns()) {
         if (!column.getIndex()) continue
 
-        const indexName = `index_on_${tableData.getName()}_${column.getName()}`
         const {unique, ...restIndexArgs} = column.getIndex()
 
         restArgsError(restIndexArgs)
 
+        let indexName = `index_on_`
+
+        if (databaseType == "sqlite") indexName += `${tableData.getName()}_`
+
+        indexName += column.getName()
+
         const createIndexArgs = {
           columns: [column.getName()],
           driver: this.getDriver(),

package/src/database/table-data/index.js

@@ -1,152 +1,10 @@
-import * as inflection from "inflection"
-import restArgsError from "../../utils/rest-args-error.js"
-
-class TableColumn {
-  constructor(name, args) {
-    if (args) {
-      const {autoIncrement, default: columnDefault, foreignKey, index, isNewColumn, maxLength, name, null: argsNull, primaryKey, type, ...restArgs} = args
-
-      if (Object.keys(args).length == 0) {
-        throw new Error("Empty args given")
-      }
-
-      restArgsError(restArgs)
-    }
-
-    this.args = args
-    this.name = name
-  }
-
-  getAutoIncrement() { return this.args?.autoIncrement }
-  getDefault() { return this.args?.default }
-  getForeignKey() { return this.args?.foreignKey }
-  getIndex() { return this.args?.index }
-  getMaxLength() { return this.args?.maxLength }
-  getName() { return this.name }
-  getNull() { return this.args?.null }
-  setNull(nullable) { this.args.null = nullable }
-  getPrimaryKey() { return this.args?.primaryKey }
-  getType() { return this.args?.type }
-  isNewColumn() { return this.args?.isNewColumn }
-
-  getSQL({forAlterTable, driver}) {
-    const databaseType = driver.getType()
-    const options = driver.options()
-    let maxlength = this.getMaxLength()
-    let type = this.getType().toUpperCase()
-
-    if (type == "DATETIME" && databaseType == "pgsql") {
-      type = "TIMESTAMP"
-    }
-
-    if (type == "STRING") {
-      type = "VARCHAR"
-      maxlength ||= 255
-    }
-
-    if (databaseType == "mssql" && type == "BOOLEAN") {
-      type = "BIT"
-    } else if (databaseType == "mssql" && type == "UUID") {
-      type = "VARCHAR"
-      maxlength ||= 36
-    }
-
-    if (databaseType == "sqlite" && this.getAutoIncrement() && this.getPrimaryKey()) {
-      type = "INTEGER"
-    }
-
-    if (databaseType == "pgsql" && this.getAutoIncrement() && this.getPrimaryKey()) {
-      type = "SERIAL"
-    }
-
-    let sql = `${options.quoteColumnName(this.getName())} `
-
-    if (databaseType == "pgsql" && forAlterTable) sql += "TYPE "
-
-    sql += type
-
-    if (maxlength !== undefined && maxlength !== null) sql += `(${maxlength})`
-
-    if (this.getAutoIncrement() && driver.shouldSetAutoIncrementWhenPrimaryKey()) {
-      if (databaseType == "mssql") {
-        sql += " IDENTITY"
-      } else if (databaseType == "pgsql") {
-        if (this.getAutoIncrement() && this.getPrimaryKey()) {
-          // Do nothing
-        } else {
-          throw new Error("pgsql auto increment must be primary key")
-        }
-      } else {
-        sql += " AUTO_INCREMENT"
-      }
-    }
-
-    if (typeof this.getDefault() == "function") {
-      const defaultValue = this.getDefault()()
-
-      sql += ` DEFAULT (`
-
-      if (databaseType == "pgsql" && defaultValue == "UUID()") {
-        sql += "gen_random_uuid()"
-      } else if (databaseType == "mssql" && defaultValue == "UUID()") {
-        sql += "NEWID()"
-      } else {
-        sql += defaultValue
-      }
-
-      sql += ")"
-    } else if (this.getDefault()) {
-      sql += ` DEFAULT ${options.quote(this.getDefault())}`
-    }
-
-    if (this.getPrimaryKey()) sql += " PRIMARY KEY"
-    if (this.getNull() === false) sql += " NOT NULL"
-
-    if (this.getForeignKey()) {
-      let foreignKeyTable, foreignKeyColumn
-
-      if (this.getForeignKey() === true) {
-        foreignKeyColumn = "id"
-        foreignKeyTable = inflection.pluralize(this.getName().replace(/_id$/, ""))
-      } else {
-        throw new Error(`Unknown foreign key type given: ${this.getForeignKey()} (${typeof this.getForeignKey()})`)
-      }
-
-      sql += ` REFERENCES ${options.quoteTableName(foreignKeyTable)}(${options.quoteColumnName(foreignKeyColumn)})`
-    }
-
-    return sql
-  }
-}
-
-class TableIndex {
-  constructor(columns, args) {
-    if (args) {
-      const {name, unique, ...restArgs} = args
-
-      restArgsError(restArgs)
-    }
-
-    this.args = args
-    this.columns = columns
-  }
-
-  getColumns() { return this.columns }
-  getName() { return this.args.name }
-  getUnique() { return Boolean(this.args.unique) }
-}
-
-class TableReference {
-  constructor(name, args) {
-    this.args = args
-    this.name = name
-  }
-}
-
-export {TableColumn, TableIndex}
+import TableColumn from "./table-column.js"
+import TableIndex from "./table-index.js"
+import TableReference from "./table-reference.js"
 
 export default class TableData {
   _columns = []
+  _foreignKeys = []
   _indexes = []
   _references = []
 
@@ -167,12 +25,17 @@ export default class TableData {
     }
   }
 
-  addIndex(index) { this._indexes.push(index) }
   getColumns() { return this._columns }
+
+  addForeignKey(foreignKey) { this._foreignKeys.push(foreignKey) }
+  getForeignKeys() { return this._foreignKeys }
+
+  addIndex(index) { this._indexes.push(index) }
+  getIndexes() { return this._indexes }
+
   getName() { return this._name }
   setName(newName) { this._name = newName }
   getIfNotExists() { return this.args.ifNotExists }
-  getIndexes() { return this._indexes }
   getReferences() { return this._references }
 
   bigint(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "bigint"}, args)) }
@@ -184,11 +47,10 @@ export default class TableData {
 
   references(name, args = {}) {
     const columnName = `${name}_id`
-    const indexName = `index_on_${this.getName()}_${columnName}`
     const reference = new TableReference(name, args)
     const columnArgs = Object.assign({isNewColumn: true, type: "bigint"}, args)
     const column = new TableColumn(columnName, columnArgs)
-    const index = new TableIndex([column], {name: indexName})
+    const index = new TableIndex([column])
 
     this._columns.push(column)
     this._indexes.push(index)