private void convertAutoIncrementColumn(Column c) {
if (c.isAutoIncrement()) {
if (c.isPrimaryKey()) {
c.setOriginalSQL("IDENTITY");
} else {
int objId = getObjectId();
c.convertAutoIncrementToSequence(session, getSchema(), objId, table.isTemporary());
}
}
}
private void checkNoNullValues() {
String sql =
"SELECT COUNT(*) FROM " + table.getSQL() + " WHERE " + oldColumn.getSQL() + " IS NULL";
Prepared command = (Prepared) session.prepare(sql);
ResultInterface result = command.query(0);
result.next();
if (result.currentRow()[0].getInt() > 0) {
throw DbException.get(ErrorCode.COLUMN_CONTAINS_NULL_VALUES_1, oldColumn.getSQL());
}
}
@Override
public void createIndexConditions(Session session, TableFilter filter) {
TableFilter tf = getTableFilter();
if (filter == tf && column.getType() == Value.BOOLEAN) {
IndexCondition cond =
IndexCondition.get(Comparison.EQUAL, this, ValueExpression.get(ValueBoolean.get(true)));
filter.addIndexCondition(cond);
}
}
@Override
public String getAlias() {
if (column != null) {
return column.getName();
}
if (tableAlias != null) {
return tableAlias + "." + columnName;
}
return columnName;
}
@Override
public boolean isEverything(ExpressionVisitor visitor) {
switch (visitor.getType()) {
case ExpressionVisitor.OPTIMIZABLE_MIN_MAX_COUNT_ALL:
return false;
case ExpressionVisitor.READONLY:
case ExpressionVisitor.DETERMINISTIC:
case ExpressionVisitor.QUERY_COMPARABLE:
return true;
case ExpressionVisitor.INDEPENDENT:
return this.queryLevel < visitor.getQueryLevel();
case ExpressionVisitor.EVALUATABLE:
// if the current value is known (evaluatable set)
// or if this columns belongs to a 'higher level' query and is
// therefore just a parameter
if (database.getSettings().nestedJoins) {
if (visitor.getQueryLevel() < this.queryLevel) {
return true;
}
if (getTableFilter() == null) {
return false;
}
return getTableFilter().isEvaluatable();
}
return evaluatable || visitor.getQueryLevel() < this.queryLevel;
case ExpressionVisitor.SET_MAX_DATA_MODIFICATION_ID:
visitor.addDataModificationId(column.getTable().getMaxDataModificationId());
return true;
case ExpressionVisitor.NOT_FROM_RESOLVER:
return columnResolver != visitor.getResolver();
case ExpressionVisitor.GET_DEPENDENCIES:
if (column != null) {
visitor.addDependency(column.getTable());
}
return true;
case ExpressionVisitor.GET_COLUMNS:
visitor.addColumn(column);
return true;
default:
throw DbException.throwInternalError("type=" + visitor.getType());
}
}
@Override
public String getSQL(boolean isDistributed) {
String sql;
boolean quote = database.getSettings().databaseToUpper;
if (column != null) {
sql = column.getSQL();
} else {
sql = quote ? Parser.quoteIdentifier(columnName) : columnName;
}
if (tableAlias != null) {
String a = quote ? Parser.quoteIdentifier(tableAlias) : tableAlias;
sql = a + "." + sql;
}
if (schemaName != null) {
String s = quote ? Parser.quoteIdentifier(schemaName) : schemaName;
sql = s + "." + sql;
}
return sql;
}
@Override
public int getNullable() {
return column.isNullable() ? Column.NULLABLE : Column.NOT_NULLABLE;
}
@Override
public boolean isAutoIncrement() {
return column.getSequence() != null;
}
@Override
public String getTableName() {
Table table = column.getTable();
return table == null ? null : table.getName();
}
@Override
public int getDisplaySize() {
return column.getDisplaySize();
}
@Override
public long getPrecision() {
return column.getPrecision();
}
@Override
public int getScale() {
return column.getScale();
}
@Override
public int getType() {
return column.getType();
}
@Override
public int update() {
session.commit(true);
Database db = session.getDatabase();
session.getUser().checkRight(table, Right.ALL);
table.checkSupportAlter();
table.lock(session, true, true);
Sequence sequence = oldColumn == null ? null : oldColumn.getSequence();
if (newColumn != null) {
checkDefaultReferencesTable((Expression) newColumn.getDefaultExpression());
}
if (columnsToAdd != null) {
for (Column column : columnsToAdd) {
checkDefaultReferencesTable((Expression) column.getDefaultExpression());
}
}
switch (type) {
case CommandInterface.ALTER_TABLE_ALTER_COLUMN_NOT_NULL:
{
if (!oldColumn.isNullable()) {
// no change
break;
}
checkNoNullValues();
oldColumn.setNullable(false);
db.updateMeta(session, table);
break;
}
case CommandInterface.ALTER_TABLE_ALTER_COLUMN_NULL:
{
if (oldColumn.isNullable()) {
// no change
break;
}
checkNullable();
oldColumn.setNullable(true);
db.updateMeta(session, table);
break;
}
case CommandInterface.ALTER_TABLE_ALTER_COLUMN_DEFAULT:
{
checkDefaultReferencesTable(defaultExpression);
oldColumn.setSequence(null);
oldColumn.setDefaultExpression(session, defaultExpression);
removeSequence(sequence);
db.updateMeta(session, table);
break;
}
case CommandInterface.ALTER_TABLE_ALTER_COLUMN_CHANGE_TYPE:
{
// if the change is only increasing the precision, then we don't
// need to copy the table because the length is only a constraint,
// and does not affect the storage structure.
if (oldColumn.isWideningConversion(newColumn)) {
convertAutoIncrementColumn(newColumn);
oldColumn.copy(newColumn);
db.updateMeta(session, table);
} else {
oldColumn.setSequence(null);
oldColumn.setDefaultExpression(session, null);
oldColumn.setConvertNullToDefault(false);
if (oldColumn.isNullable() && !newColumn.isNullable()) {
checkNoNullValues();
} else if (!oldColumn.isNullable() && newColumn.isNullable()) {
checkNullable();
}
convertAutoIncrementColumn(newColumn);
copyData();
}
break;
}
case CommandInterface.ALTER_TABLE_ADD_COLUMN:
{
// ifNotExists only supported for single column add
if (ifNotExists
&& columnsToAdd.size() == 1
&& table.doesColumnExist(columnsToAdd.get(0).getName())) {
break;
}
for (Column column : columnsToAdd) {
if (column.isAutoIncrement()) {
int objId = getObjectId();
column.convertAutoIncrementToSequence(
session, getSchema(), objId, table.isTemporary());
}
}
copyData();
break;
}
case CommandInterface.ALTER_TABLE_DROP_COLUMN:
{
if (table.getColumns().length == 1) {
throw DbException.get(ErrorCode.CANNOT_DROP_LAST_COLUMN, oldColumn.getSQL());
}
table.dropSingleColumnConstraintsAndIndexes(session, oldColumn);
copyData();
break;
}
case CommandInterface.ALTER_TABLE_ALTER_COLUMN_SELECTIVITY:
{
int value = newSelectivity.optimize(session).getValue(session).getInt();
oldColumn.setSelectivity(value);
db.updateMeta(session, table);
break;
}
default:
DbException.throwInternalError("type=" + type);
}
return 0;
}
private Table cloneTableStructure(
Column[] columns, Database db, String tempName, ArrayList<Column> newColumns) {
for (Column col : columns) {
newColumns.add(col.getClone());
}
if (type == CommandInterface.ALTER_TABLE_DROP_COLUMN) {
int position = oldColumn.getColumnId();
newColumns.remove(position);
} else if (type == CommandInterface.ALTER_TABLE_ADD_COLUMN) {
int position;
if (addBefore != null) {
position = table.getColumn(addBefore).getColumnId();
} else if (addAfter != null) {
position = table.getColumn(addAfter).getColumnId() + 1;
} else {
position = columns.length;
}
for (Column column : columnsToAdd) {
newColumns.add(position++, column);
}
} else if (type == CommandInterface.ALTER_TABLE_ALTER_COLUMN_CHANGE_TYPE) {
int position = oldColumn.getColumnId();
newColumns.remove(position);
newColumns.add(position, newColumn);
}
// create a table object in order to get the SQL statement
// can't just use this table, because most column objects are 'shared'
// with the old table
// still need a new id because using 0 would mean: the new table tries
// to use the rows of the table 0 (the meta table)
int id = db.allocateObjectId();
CreateTableData data = new CreateTableData();
data.tableName = tempName;
data.id = id;
data.columns = newColumns;
data.temporary = table.isTemporary();
data.persistData = table.isPersistData();
data.persistIndexes = table.isPersistIndexes();
data.isHidden = table.isHidden();
data.create = true;
data.session = session;
data.storageEngineName = table.getStorageEngineName();
Table newTable = getSchema().createTable(data);
newTable.setComment(table.getComment());
StringBuilder buff = new StringBuilder();
buff.append(newTable.getCreateSQL());
if (table.supportsAlterColumnWithCopyData()) {
StringBuilder columnList = new StringBuilder();
for (Column nc : newColumns) {
if (columnList.length() > 0) {
columnList.append(", ");
}
if (type == CommandInterface.ALTER_TABLE_ADD_COLUMN && columnsToAdd.contains(nc)) {
Expression def = (Expression) nc.getDefaultExpression();
columnList.append(def == null ? "NULL" : def.getSQL());
} else {
columnList.append(nc.getSQL());
}
}
buff.append(" AS SELECT ");
if (columnList.length() == 0) {
// special case: insert into test select * from
buff.append('*');
} else {
buff.append(columnList);
}
buff.append(" FROM ").append(table.getSQL());
}
String newTableSQL = buff.toString();
String newTableName = newTable.getName();
Schema newTableSchema = newTable.getSchema();
newTable.removeChildrenAndResources(session);
execute(newTableSQL, true);
newTable = newTableSchema.getTableOrView(session, newTableName);
ArrayList<String> triggers = New.arrayList();
for (DbObject child : table.getChildren()) {
if (child instanceof Sequence) {
continue;
} else if (child instanceof Index) {
Index idx = (Index) child;
if (idx.getIndexType().getBelongsToConstraint()) {
continue;
}
}
String createSQL = child.getCreateSQL();
if (createSQL == null) {
continue;
}
if (child instanceof TableView) {
continue;
} else if (child.getType() == DbObject.TABLE_OR_VIEW) {
DbException.throwInternalError();
}
String quotedName = Parser.quoteIdentifier(tempName + "_" + child.getName());
String sql = null;
if (child instanceof ConstraintReferential) {
ConstraintReferential r = (ConstraintReferential) child;
if (r.getTable() != table) {
sql = r.getCreateSQLForCopy(r.getTable(), newTable, quotedName, false);
}
}
if (sql == null) {
sql = child.getCreateSQLForCopy(newTable, quotedName);
}
if (sql != null) {
if (child instanceof TriggerObject) {
triggers.add(sql);
} else {
execute(sql, true);
}
}
}
table.setModified();
// remove the sequences from the columns (except dropped columns)
// otherwise the sequence is dropped if the table is dropped
for (Column col : newColumns) {
Sequence seq = col.getSequence();
if (seq != null) {
table.removeSequence(seq);
col.setSequence(null);
}
}
for (String sql : triggers) {
execute(sql, true);
}
return newTable;
}
@Override
public String getColumnName() {
return columnName != null ? columnName : column.getName();
}
@Override
public void mapColumns(ColumnResolver resolver, int level) {
if (select == null) select = (Select) resolver.getSelect();
if (resolver instanceof TableFilter
&& resolver.getTableFilter().getTable().supportsColumnFamily()) {
Table t = resolver.getTableFilter().getTable();
// if (!t.isStatic() && t.getRowKeyName().equalsIgnoreCase(columnName)) {
// if (columnFamilyName != null) {
// schemaName = tableAlias;
// tableAlias = columnFamilyName;
// columnFamilyName = null;
// }
// if (tableAlias != null && !database.equalsIdentifiers(tableAlias,
// resolver.getTableAlias())) {
// return;
// }
// if (schemaName != null && !database.equalsIdentifiers(schemaName,
// resolver.getSchemaName())) {
// return;
// }
// mapColumn(resolver, t.getRowKeyColumn(), level);
// return;
// }
if (database.equalsIdentifiers(Column.ROWKEY, columnName)) {
Column col = t.getRowKeyColumn();
if (col != null) {
mapColumn(resolver, col, level);
return;
}
}
if (resolver.getSelect() == null) {
Column c = t.getColumn(columnName);
mapColumn(resolver, c, level);
return;
}
String tableAlias = this.tableAlias;
boolean useAlias = false;
// 当columnFamilyName不存在时，有可能是想使用简化的tableAlias.columnName语法
if (columnFamilyName != null && !t.doesColumnFamilyExist(columnFamilyName)) {
// 不替换原有的tableAlias，因为有可能在另一个table中存在这样的columnFamilyName
tableAlias = columnFamilyName;
if (!t.doesColumnExist(columnName)) return;
useAlias = true;
}
if (tableAlias != null && !database.equalsIdentifiers(tableAlias, resolver.getTableAlias())) {
return;
}
if (schemaName != null && !database.equalsIdentifiers(schemaName, resolver.getSchemaName())) {
return;
}
String fullColumnName;
if (useAlias || columnFamilyName == null) fullColumnName = columnName;
else fullColumnName = t.getFullColumnName(columnFamilyName, columnName);
if (t.doesColumnExist(fullColumnName)) {
Column c = t.getColumn(fullColumnName);
mapColumn(resolver, c, level);
return;
}
} else {
if (columnFamilyName != null) {
schemaName = tableAlias;
tableAlias = columnFamilyName;
columnFamilyName = null;
}
}
if (tableAlias != null && !database.equalsIdentifiers(tableAlias, resolver.getTableAlias())) {
return;
}
if (schemaName != null && !database.equalsIdentifiers(schemaName, resolver.getSchemaName())) {
return;
}
for (Column col : resolver.getColumns()) {
String n = col.getName();
if (database.equalsIdentifiers(columnName, n)) {
mapColumn(resolver, col, level);
return;
}
}
if (database.equalsIdentifiers(Column.ROWID, columnName)) {
Column col = resolver.getRowIdColumn();
if (col != null) {
mapColumn(resolver, col, level);
return;
}
}
Column[] columns = resolver.getSystemColumns();
for (int i = 0; columns != null && i < columns.length; i++) {
Column col = columns[i];
if (database.equalsIdentifiers(columnName, col.getName())) {
mapColumn(resolver, col, level);
return;
}
}
}
@Override
public int update() {
if (!transactional) {
session.commit(true);
}
Database db = session.getDatabase();
if (!db.isPersistent()) {
data.persistIndexes = false;
}
if (getSchema().findTableOrView(session, data.tableName) != null) {
if (ifNotExists) {
return 0;
}
throw DbException.get(ErrorCode.TABLE_OR_VIEW_ALREADY_EXISTS_1, data.tableName);
}
if (asQuery != null) {
asQuery.prepare();
if (data.columns.isEmpty()) {
generateColumnsFromQuery();
} else if (data.columns.size() != asQuery.getColumnCount()) {
throw DbException.get(ErrorCode.COLUMN_COUNT_DOES_NOT_MATCH);
}
}
if (pkColumns != null) {
for (Column c : data.columns) {
for (IndexColumn idxCol : pkColumns) {
if (c.getName().equals(idxCol.columnName)) {
c.setNullable(false);
}
}
}
}
data.id = getObjectId();
data.create = create;
data.session = session;
boolean isSessionTemporary = data.temporary && !data.globalTemporary;
if (!isSessionTemporary) {
db.lockMeta(session);
}
Table table = createTable(data);
ArrayList<Sequence> sequences = New.arrayList();
for (Column c : data.columns) {
if (c.isAutoIncrement()) {
int objId = getObjectId();
c.convertAutoIncrementToSequence(session, getSchema(), objId, data.temporary);
}
Sequence seq = c.getSequence();
if (seq != null) {
sequences.add(seq);
}
}
table.setComment(comment);
if (isSessionTemporary) {
if (onCommitDrop) {
table.setOnCommitDrop(true);
}
if (onCommitTruncate) {
table.setOnCommitTruncate(true);
}
session.addLocalTempTable(table);
} else {
db.lockMeta(session);
db.addSchemaObject(session, table);
}
try {
for (Column c : data.columns) {
c.prepareExpression(session);
}
for (Sequence sequence : sequences) {
table.addSequence(sequence);
}
for (DefineCommand command : constraintCommands) {
command.setTransactional(transactional);
command.update();
}
if (asQuery != null) {
Insert insert = null;
insert = new Insert(session);
insert.setSortedInsertMode(sortedInsertMode);
insert.setQuery(asQuery);
insert.setTable(table);
insert.setInsertFromSelect(true);
insert.prepare();
insert.update();
}
} catch (DbException e) {
db.checkPowerOff();
db.removeSchemaObject(session, table);
if (!transactional) {
session.commit(true);
}
throw e;
}
return 0;
}
