[#285] Add support for ALTER TABLE IF EXISTS

h2/src/main/org/h2/command/Parser.java

@@ -16,6 +16,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashSet;
+
 import org.h2.api.ErrorCode;
 import org.h2.api.Trigger;
 import org.h2.command.ddl.AlterIndexRename;
@@ -5421,21 +5422,24 @@ public class Parser {
     }
 
     private Prepared parseAlterTable() {
-        Table table = readTableOrView();
+        boolean ifTableExists = readIfExists(false);
+        String tableName = readIdentifierWithSchema();
+        Schema schema = getSchema();
         if (readIf("ADD")) {
-            Prepared command = parseAlterTableAddConstraintIf(table.getName(),
-                    table.getSchema());
+            Prepared command = parseAlterTableAddConstraintIf(tableName,
+                    schema, ifTableExists);
             if (command != null) {
                 return command;
             }
-            return parseAlterTableAddColumn(table);
+            return parseAlterTableAddColumn(tableName, schema, ifTableExists);
         } else if (readIf("SET")) {
             read("REFERENTIAL_INTEGRITY");
             int type = CommandInterface.ALTER_TABLE_SET_REFERENTIAL_INTEGRITY;
             boolean value = readBooleanSetting();
             AlterTableSet command = new AlterTableSet(session,
-                    table.getSchema(), type, value);
-            command.setTableName(table.getName());
+                    schema, type, value);
+            command.setTableName(tableName);
+            command.setIfTableExists(ifTableExists);
             if (readIf("CHECK")) {
                 command.setCheckExisting(true);
             } else if (readIf("NOCHECK")) {
@@ -5446,87 +5450,93 @@ public class Parser {
             if (readIf("COLUMN")) {
                 // PostgreSQL syntax
                 String columnName = readColumnIdentifier();
-                Column column = table.getColumn(columnName);
                 read("TO");
                 AlterTableRenameColumn command = new AlterTableRenameColumn(
-                        session);
-                command.setTable(table);
-                command.setColumn(column);
+                        session, schema);
+                command.setTableName(tableName);
+                command.setIfTableExists(ifTableExists);
+                command.setOldColumnName(columnName);
                 String newName = readColumnIdentifier();
                 command.setNewColumnName(newName);
                 return command;
             } else if (readIf("CONSTRAINT")) {
-                String constraintName = readIdentifierWithSchema(table
-                        .getSchema().getName());
-                checkSchema(table.getSchema());
+                String constraintName = readIdentifierWithSchema(schema.getName());
+                checkSchema(schema);
                 read("TO");
                 AlterTableRenameConstraint command = new AlterTableRenameConstraint(
-                        session, table.getSchema());
+                        session, schema);
                 command.setConstraintName(constraintName);
                 String newName = readColumnIdentifier();
                 command.setNewConstraintName(newName);
-                return command;
+                return commandIfTableExists(schema, tableName, ifTableExists, command);
             } else {
                 read("TO");
-                String newName = readIdentifierWithSchema(table.getSchema()
-                        .getName());
-                checkSchema(table.getSchema());
+                String newName = readIdentifierWithSchema(schema.getName());
+                checkSchema(schema);
                 AlterTableRename command = new AlterTableRename(session,
                         getSchema());
-                command.setOldTable(table);
+                command.setOldTableName(tableName);
                 command.setNewTableName(newName);
+                command.setIfTableExists(ifTableExists);
                 command.setHidden(readIf("HIDDEN"));
                 return command;
             }
         } else if (readIf("DROP")) {
             if (readIf("CONSTRAINT")) {
                 boolean ifExists = readIfExists(false);
-                String constraintName = readIdentifierWithSchema(table
-                        .getSchema().getName());
+                String constraintName = readIdentifierWithSchema(schema.getName());
                 ifExists = readIfExists(ifExists);
-                checkSchema(table.getSchema());
+                checkSchema(schema);
                 AlterTableDropConstraint command = new AlterTableDropConstraint(
                         session, getSchema(), ifExists);
                 command.setConstraintName(constraintName);
-                return command;
+                return commandIfTableExists(schema, tableName, ifTableExists, command);
             } else if (readIf("FOREIGN")) {
                 // MySQL compatibility
                 read("KEY");
-                String constraintName = readIdentifierWithSchema(table
-                        .getSchema().getName());
-                checkSchema(table.getSchema());
+                String constraintName = readIdentifierWithSchema(schema.getName());
+                checkSchema(schema);
                 AlterTableDropConstraint command = new AlterTableDropConstraint(
                         session, getSchema(), false);
                 command.setConstraintName(constraintName);
-                return command;
+                return commandIfTableExists(schema, tableName, ifTableExists, command);
             } else if (readIf("INDEX")) {
                 // MySQL compatibility
                 String indexName = readIdentifierWithSchema();
                 DropIndex command = new DropIndex(session, getSchema());
                 command.setIndexName(indexName);
-                return command;
+                return commandIfTableExists(schema, tableName, ifTableExists, command);
             } else if (readIf("PRIMARY")) {
                 read("KEY");
+                Table table = tableIfTableExists(schema, tableName, ifTableExists);
+                if (table == null) {
+                    return new NoOperation(session);
+                }
                 Index idx = table.getPrimaryKey();
-                DropIndex command = new DropIndex(session, table.getSchema());
+                DropIndex command = new DropIndex(session, schema);
                 command.setIndexName(idx.getName());
                 return command;
             } else {
                 readIf("COLUMN");
                 boolean ifExists = readIfExists(false);
                 AlterTableAlterColumn command = new AlterTableAlterColumn(
-                        session, table.getSchema());
+                        session, schema);
                 command.setType(CommandInterface.ALTER_TABLE_DROP_COLUMN);
                 ArrayList<Column> columnsToRemove = New.arrayList();
+                Table table = tableIfTableExists(schema, tableName, ifTableExists);
                 do {
                     String columnName = readColumnIdentifier();
+                    if (table == null) {
+                        return new NoOperation(session);
+                    }
                     if (ifExists && !table.doesColumnExist(columnName)) {
                         return new NoOperation(session);
                     }
                     Column column = table.getColumn(columnName);
                     columnsToRemove.add(column);
                 } while (readIf(","));
-                command.setTable(table);
+                command.setTableName(tableName);
+                command.setIfTableExists(ifTableExists);
                 command.setColumnsToRemove(columnsToRemove);
                 return command;
             }
@@ -5534,32 +5544,34 @@ public class Parser {
             // MySQL compatibility
             readIf("COLUMN");
             String columnName = readColumnIdentifier();
-            Column column = table.getColumn(columnName);
             String newColumnName = readColumnIdentifier();
+            Column column = columnIfTableExists(schema, tableName, columnName, ifTableExists);
+            boolean nullable = column == null ? true : column.isNullable();
             // new column type ignored. RENAME and MODIFY are
             // a single command in MySQL but two different commands in H2.
-            parseColumnForTable(newColumnName, column.isNullable());
-            AlterTableRenameColumn command = new AlterTableRenameColumn(session);
-            command.setTable(table);
-            command.setColumn(column);
+            parseColumnForTable(newColumnName, nullable);
+            AlterTableRenameColumn command = new AlterTableRenameColumn(session, schema);
+            command.setTableName(tableName);
+            command.setIfTableExists(ifTableExists);
+            command.setOldColumnName(columnName);
             command.setNewColumnName(newColumnName);
             return command;
         } else if (readIf("MODIFY")) {
             // MySQL compatibility
             readIf("COLUMN");
             String columnName = readColumnIdentifier();
-            Column column = table.getColumn(columnName);
-            return parseAlterTableAlterColumnType(table, columnName, column);
+            return parseAlterTableAlterColumnType(schema, tableName, columnName, ifTableExists);
         } else if (readIf("ALTER")) {
             readIf("COLUMN");
             String columnName = readColumnIdentifier();
-            Column column = table.getColumn(columnName);
+            Column column = columnIfTableExists(schema, tableName, columnName, ifTableExists);
             if (readIf("RENAME")) {
                 read("TO");
                 AlterTableRenameColumn command = new AlterTableRenameColumn(
-                        session);
-                command.setTable(table);
-                command.setColumn(column);
+                        session, schema);
+                command.setTableName(tableName);
+                command.setIfTableExists(ifTableExists);
+                command.setOldColumnName(columnName);
                 String newName = readColumnIdentifier();
                 command.setNewColumnName(newName);
                 return command;
@@ -5567,8 +5579,9 @@ public class Parser {
                 // PostgreSQL compatibility
                 if (readIf("DEFAULT")) {
                     AlterTableAlterColumn command = new AlterTableAlterColumn(
-                            session, table.getSchema());
-                    command.setTable(table);
+                            session, schema);
+                    command.setTableName(tableName);
+                    command.setIfTableExists(ifTableExists);
                     command.setOldColumn(column);
                     command.setType(CommandInterface.ALTER_TABLE_ALTER_COLUMN_DEFAULT);
                     command.setDefaultExpression(null);
@@ -5577,24 +5590,26 @@ public class Parser {
                 read("NOT");
                 read("NULL");
                 AlterTableAlterColumn command = new AlterTableAlterColumn(
-                        session, table.getSchema());
-                command.setTable(table);
+                        session, schema);
+                command.setTableName(tableName);
+                command.setIfTableExists(ifTableExists);
                 command.setOldColumn(column);
                 command.setType(CommandInterface.ALTER_TABLE_ALTER_COLUMN_NULL);
                 return command;
             } else if (readIf("TYPE")) {
                 // PostgreSQL compatibility
-                return parseAlterTableAlterColumnType(table, columnName, column);
+                return parseAlterTableAlterColumnType(schema, tableName, columnName, ifTableExists);
             } else if (readIf("SET")) {
                 if (readIf("DATA")) {
                     // Derby compatibility
                     read("TYPE");
-                    return parseAlterTableAlterColumnType(table, columnName,
-                            column);
+                    return parseAlterTableAlterColumnType(schema, tableName, columnName,
+                            ifTableExists);
                 }
                 AlterTableAlterColumn command = new AlterTableAlterColumn(
-                        session, table.getSchema());
-                command.setTable(table);
+                        session, schema);
+                command.setTableName(tableName);
+                command.setIfTableExists(ifTableExists);
                 command.setOldColumn(column);
                 if (readIf("NULL")) {
                     command.setType(CommandInterface.ALTER_TABLE_ALTER_COLUMN_NULL);
@@ -5612,45 +5627,66 @@ public class Parser {
             } else if (readIf("RESTART")) {
                 readIf("WITH");
                 Expression start = readExpression();
-                AlterSequence command = new AlterSequence(session,
-                        table.getSchema());
+                AlterSequence command = new AlterSequence(session, schema);
                 command.setColumn(column);
                 command.setStartWith(start);
-                return command;
+                return commandIfTableExists(schema, tableName, ifTableExists, command);
             } else if (readIf("SELECTIVITY")) {
                 AlterTableAlterColumn command = new AlterTableAlterColumn(
-                        session, table.getSchema());
-                command.setTable(table);
+                        session, schema);
+                command.setTableName(tableName);
+                command.setIfTableExists(ifTableExists);
                 command.setType(CommandInterface.ALTER_TABLE_ALTER_COLUMN_SELECTIVITY);
                 command.setOldColumn(column);
                 command.setSelectivity(readExpression());
                 return command;
             } else {
-                return parseAlterTableAlterColumnType(table, columnName, column);
+                return parseAlterTableAlterColumnType(schema, tableName, columnName, ifTableExists);
             }
         }
         throw getSyntaxError();
     }
 
-    private AlterTableAlterColumn parseAlterTableAlterColumnType(Table table,
-            String columnName, Column column) {
-        Column newColumn = parseColumnForTable(columnName, column.isNullable());
+    private Table tableIfTableExists(Schema schema, String tableName, boolean ifTableExists) {
+        Table table = schema.findTableOrView(session, tableName);
+        if (table == null && !ifTableExists) {
+            throw DbException.get(ErrorCode.TABLE_OR_VIEW_NOT_FOUND_1, tableName);
+        }
+        return table;
+    }
+
+    private Column columnIfTableExists(Schema schema, String tableName, String columnName, boolean ifTableExists) {
+        Table table = tableIfTableExists(schema, tableName, ifTableExists);
+        return table == null ? null : table.getColumn(columnName);
+    }
+
+    private Prepared commandIfTableExists(Schema schema, String tableName, boolean ifTableExists, Prepared commandIfTableExists) {
+        return tableIfTableExists(schema, tableName, ifTableExists) == null
+            ? new NoOperation(session)
+            : commandIfTableExists;
+    }
+
+    private AlterTableAlterColumn parseAlterTableAlterColumnType(Schema schema, String tableName,
+            String columnName, boolean ifTableExists) {
+        Column oldColumn = columnIfTableExists(schema, tableName, columnName, ifTableExists);
+        Column newColumn = parseColumnForTable(columnName, oldColumn == null ? true : oldColumn.isNullable());
         AlterTableAlterColumn command = new AlterTableAlterColumn(session,
-                table.getSchema());
-        command.setTable(table);
+                schema);
+        command.setTableName(tableName);
+        command.setIfTableExists(ifTableExists);
         command.setType(CommandInterface.ALTER_TABLE_ALTER_COLUMN_CHANGE_TYPE);
-        command.setOldColumn(column);
+        command.setOldColumn(oldColumn);
         command.setNewColumn(newColumn);
         return command;
     }
 
-    private AlterTableAlterColumn parseAlterTableAddColumn(Table table) {
+    private AlterTableAlterColumn parseAlterTableAddColumn(String tableName, Schema schema, boolean ifTableExists) {
         readIf("COLUMN");
-        Schema schema = table.getSchema();
         AlterTableAlterColumn command = new AlterTableAlterColumn(session,
                 schema);
         command.setType(CommandInterface.ALTER_TABLE_ADD_COLUMN);
-        command.setTable(table);
+        command.setTableName(tableName);
+        command.setIfTableExists(ifTableExists);
         ArrayList<Column> columnsToAdd = New.arrayList();
         if (readIf("(")) {
             command.setIfNotExists(false);
@@ -5705,7 +5741,7 @@ public class Parser {
     }
 
     private DefineCommand parseAlterTableAddConstraintIf(String tableName,
-            Schema schema) {
+            Schema schema, boolean ifTableExists) {
         String constraintName = null, comment = null;
         boolean ifNotExists = false;
         boolean allowIndexDefinition = database.getMode().indexDefinitionInCreateTable;
@@ -5724,6 +5760,7 @@ public class Parser {
             command.setComment(comment);
             command.setConstraintName(constraintName);
             command.setTableName(tableName);
+            command.setIfTableExists(ifTableExists);
             if (readIf("HASH")) {
                 command.setPrimaryKeyHash(true);
             }
@@ -5748,6 +5785,7 @@ public class Parser {
             CreateIndex command = new CreateIndex(session, schema);
             command.setComment(comment);
             command.setTableName(tableName);
+            command.setIfTableExists(ifTableExists);
             if (!readIf("(")) {
                 command.setIndexName(readUniqueIdentifier());
                 read("(");
@@ -5807,6 +5845,7 @@ public class Parser {
             command.setCheckExisting(true);
         }
         command.setTableName(tableName);
+        command.setIfTableExists(ifTableExists);
         command.setConstraintName(constraintName);
         command.setComment(comment);
         return command;
@@ -5902,7 +5941,7 @@ public class Parser {
             if (!readIf(")")) {
                 do {
                     DefineCommand c = parseAlterTableAddConstraintIf(tableName,
-                            schema);
+                            schema, false);
                     if (c != null) {
                         command.addConstraintCommand(c);
                     } else {

h2/src/main/org/h2/command/ddl/AlterTableAddConstraint.java

@@ -49,6 +49,7 @@ public class AlterTableAddConstraint extends SchemaCommand {
     private String comment;
     private boolean checkExisting;
     private boolean primaryKeyHash;
+    private boolean ifTableExists;
     private final boolean ifNotExists;
     private ArrayList<Index> createdIndexes = New.arrayList();
 
@@ -58,6 +59,10 @@ public class AlterTableAddConstraint extends SchemaCommand {
         this.ifNotExists = ifNotExists;
     }
 
+    public void setIfTableExists(boolean b) {
+        ifTableExists = b;
+    }
+
     private String generateConstraintName(Table table) {
         if (constraintName == null) {
             constraintName = getSchema().getUniqueConstraintName(
@@ -90,7 +95,13 @@ public class AlterTableAddConstraint extends SchemaCommand {
             session.commit(true);
         }
         Database db = session.getDatabase();
-        Table table = getSchema().getTableOrView(session, tableName);
+        Table table = getSchema().findTableOrView(session, tableName);
+        if (table == null) {
+            if (ifTableExists) {
+                return 0;
+            }
+            throw DbException.get(ErrorCode.TABLE_OR_VIEW_NOT_FOUND_1, tableName);
+        }
         if (getSchema().findConstraint(session, constraintName) != null) {
             if (ifNotExists) {
                 return 0;

h2/src/main/org/h2/command/ddl/AlterTableAlterColumn.java

@@ -48,7 +48,7 @@ import org.h2.util.New;
  */
 public class AlterTableAlterColumn extends SchemaCommand {
 
-    private Table table;
+    private String tableName;
     private Column oldColumn;
     private Column newColumn;
     private int type;
@@ -56,6 +56,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
     private Expression newSelectivity;
     private String addBefore;
     private String addAfter;
+    private boolean ifTableExists;
     private boolean ifNotExists;
     private ArrayList<Column> columnsToAdd;
     private ArrayList<Column> columnsToRemove;
@@ -64,8 +65,12 @@ public class AlterTableAlterColumn extends SchemaCommand {
         super(session, schema);
     }
 
-    public void setTable(Table table) {
-        this.table = table;
+    public void setIfTableExists(boolean b) {
+        ifTableExists = b;
+    }
+
+    public void setTableName(String tableName) {
+        this.tableName = tableName;
     }
 
     public void setOldColumn(Column oldColumn) {
@@ -84,16 +89,23 @@ public class AlterTableAlterColumn extends SchemaCommand {
     public int update() {
         session.commit(true);
         Database db = session.getDatabase();
+        Table table = getSchema().findTableOrView(session, tableName);
+        if (table == null) {
+            if (ifTableExists) {
+                return 0;
+            }
+            throw DbException.get(ErrorCode.TABLE_OR_VIEW_NOT_FOUND_1, tableName);
+        }
         session.getUser().checkRight(table, Right.ALL);
         table.checkSupportAlter();
         table.lock(session, true, true);
         if (newColumn != null) {
-            checkDefaultReferencesTable(newColumn.getDefaultExpression());
+            checkDefaultReferencesTable(table, newColumn.getDefaultExpression());
             checkClustering(newColumn);
         }
         if (columnsToAdd != null) {
             for (Column column : columnsToAdd) {
-                checkDefaultReferencesTable(column.getDefaultExpression());
+                checkDefaultReferencesTable(table, column.getDefaultExpression());
                 checkClustering(column);
             }
         }
@@ -103,7 +115,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
                 // no change
                 break;
             }
-            checkNoNullValues();
+            checkNoNullValues(table);
             oldColumn.setNullable(false);
             db.updateMeta(session, table);
             break;
@@ -113,17 +125,17 @@ public class AlterTableAlterColumn extends SchemaCommand {
                 // no change
                 break;
             }
-            checkNullable();
+            checkNullable(table);
             oldColumn.setNullable(true);
             db.updateMeta(session, table);
             break;
         }
         case CommandInterface.ALTER_TABLE_ALTER_COLUMN_DEFAULT: {
             Sequence sequence = oldColumn == null ? null : oldColumn.getSequence();
-            checkDefaultReferencesTable(defaultExpression);
+            checkDefaultReferencesTable(table, defaultExpression);
             oldColumn.setSequence(null);
             oldColumn.setDefaultExpression(session, defaultExpression);
-            removeSequence(sequence);
+            removeSequence(table, sequence);
             db.updateMeta(session, table);
             break;
         }
@@ -132,7 +144,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
             // 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);
+                convertAutoIncrementColumn(table, newColumn);
                 oldColumn.copy(newColumn);
                 db.updateMeta(session, table);
             } else {
@@ -140,12 +152,12 @@ public class AlterTableAlterColumn extends SchemaCommand {
                 oldColumn.setDefaultExpression(session, null);
                 oldColumn.setConvertNullToDefault(false);
                 if (oldColumn.isNullable() && !newColumn.isNullable()) {
-                    checkNoNullValues();
+                    checkNoNullValues(table);
                 } else if (!oldColumn.isNullable() && newColumn.isNullable()) {
-                    checkNullable();
+                    checkNullable(table);
                 }
-                convertAutoIncrementColumn(newColumn);
-                copyData();
+                convertAutoIncrementColumn(table, newColumn);
+                copyData(table);
             }
             break;
         }
@@ -162,7 +174,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
                             table.isTemporary());
                 }
             }
-            copyData();
+            copyData(table);
             break;
         }
         case CommandInterface.ALTER_TABLE_DROP_COLUMN: {
@@ -171,7 +183,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
                         columnsToRemove.get(0).getSQL());
             }
             table.dropMultipleColumnsConstraintsAndIndexes(session, columnsToRemove);
-            copyData();
+            copyData(table);
             break;
         }
         case CommandInterface.ALTER_TABLE_ALTER_COLUMN_SELECTIVITY: {
@@ -186,7 +198,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
         return 0;
     }
 
-    private void checkDefaultReferencesTable(Expression defaultExpression) {
+    private void checkDefaultReferencesTable(Table table, Expression defaultExpression) {
         if (defaultExpression == null) {
             return;
         }
@@ -209,7 +221,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
         }
     }
 
-    private void convertAutoIncrementColumn(Column c) {
+    private void convertAutoIncrementColumn(Table table, Column c) {
         if (c.isAutoIncrement()) {
             if (c.isPrimaryKey()) {
                 c.setOriginalSQL("IDENTITY");
@@ -221,7 +233,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
         }
     }
 
-    private void removeSequence(Sequence sequence) {
+    private void removeSequence(Table table, Sequence sequence) {
         if (sequence != null) {
             table.removeSequence(sequence);
             sequence.setBelongsToTable(false);
@@ -230,7 +242,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
         }
     }
 
-    private void copyData() {
+    private void copyData(Table table) {
         if (table.isTemporary()) {
             throw DbException.getUnsupportedException("TEMP TABLE");
         }
@@ -239,7 +251,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
         String tempName = db.getTempTableName(baseName, session);
         Column[] columns = table.getColumns();
         ArrayList<Column> newColumns = New.arrayList();
-        Table newTable = cloneTableStructure(columns, db, tempName, newColumns);
+        Table newTable = cloneTableStructure(table, columns, db, tempName, newColumns);
         try {
             // check if a view would become invalid
             // (because the column to drop is referenced or so)
@@ -289,7 +301,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
         }
     }
 
-    private Table cloneTableStructure(Column[] columns, Database db,
+    private Table cloneTableStructure(Table table, Column[] columns, Database db,
             String tempName, ArrayList<Column> newColumns) {
         for (Column col : columns) {
             newColumns.add(col.getClone());
@@ -479,7 +491,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
         }
     }
 
-    private void checkNullable() {
+    private void checkNullable(Table table) {
         for (Index index : table.getIndexes()) {
             if (index.getColumnIndex(oldColumn) < 0) {
                 continue;
@@ -492,7 +504,7 @@ public class AlterTableAlterColumn extends SchemaCommand {
         }
     }
 
-    private void checkNoNullValues() {
+    private void checkNoNullValues(Table table) {
         String sql = "SELECT COUNT(*) FROM " +
                 table.getSQL() + " WHERE " +
                 oldColumn.getSQL() + " IS NULL";

h2/src/main/org/h2/command/ddl/AlterTableRename.java

@@ -20,7 +20,8 @@ import org.h2.table.Table;
  */
 public class AlterTableRename extends SchemaCommand {
 
-    private Table oldTable;
+    private boolean ifTableExists;
+    private String oldTableName;
     private String newTableName;
     private boolean hidden;
 
@@ -28,8 +29,12 @@ public class AlterTableRename extends SchemaCommand {
         super(session, schema);
     }
 
-    public void setOldTable(Table table) {
-        oldTable = table;
+    public void setIfTableExists(boolean b) {
+        ifTableExists = b;
+    }
+
+    public void setOldTableName(String name) {
+        oldTableName = name;
     }
 
     public void setNewTableName(String name) {
@@ -40,6 +45,13 @@ public class AlterTableRename extends SchemaCommand {
     public int update() {
         session.commit(true);
         Database db = session.getDatabase();
+        Table oldTable = getSchema().findTableOrView(session, oldTableName);
+        if (oldTable == null) {
+            if (ifTableExists) {
+                return 0;
+            }
+            throw DbException.get(ErrorCode.TABLE_OR_VIEW_NOT_FOUND_1, oldTableName);
+        }
         session.getUser().checkRight(oldTable, Right.ALL);
         Table t = getSchema().findTableOrView(session, newTableName);
         if (t != null && hidden && newTableName.equals(oldTable.getName())) {

h2/src/main/org/h2/command/ddl/AlterTableRenameColumn.java

@@ -5,12 +5,15 @@
  */
 package org.h2.command.ddl;
 
+import org.h2.api.ErrorCode;
 import org.h2.command.CommandInterface;
 import org.h2.engine.Database;
 import org.h2.engine.DbObject;
 import org.h2.engine.Right;
 import org.h2.engine.Session;
 import org.h2.expression.Expression;
+import org.h2.message.DbException;
+import org.h2.schema.Schema;
 import org.h2.table.Column;
 import org.h2.table.Table;
 
@@ -18,22 +21,27 @@ import org.h2.table.Table;
  * This class represents the statement
  * ALTER TABLE ALTER COLUMN RENAME
  */
-public class AlterTableRenameColumn extends DefineCommand {
+public class AlterTableRenameColumn extends SchemaCommand {
 
-    private Table table;
-    private Column column;
+    private boolean ifTableExists;
+    private String tableName;
+    private String oldName;
     private String newName;
 
-    public AlterTableRenameColumn(Session session) {
-        super(session);
+    public AlterTableRenameColumn(Session session, Schema schema) {
+        super(session, schema);
     }
 
-    public void setTable(Table table) {
-        this.table = table;
+    public void setIfTableExists(boolean b) {
+        this.ifTableExists = b;
     }
 
-    public void setColumn(Column column) {
-        this.column = column;
+    public void setTableName(String tableName) {
+        this.tableName = tableName;
+    }
+
+    public void setOldColumnName(String oldName) {
+        this.oldName = oldName;
     }
 
     public void setNewColumnName(String newName) {
@@ -44,6 +52,14 @@ public class AlterTableRenameColumn extends DefineCommand {
     public int update() {
         session.commit(true);
         Database db = session.getDatabase();
+        Table table = getSchema().findTableOrView(session, tableName);
+        if (table == null) {
+            if (ifTableExists) {
+                return 0;
+            }
+            throw DbException.get(ErrorCode.TABLE_OR_VIEW_NOT_FOUND_1, tableName);
+        }
+        Column column = table.getColumn(oldName);
         session.getUser().checkRight(table, Right.ALL);
         table.checkSupportAlter();
         // we need to update CHECK constraint

h2/src/main/org/h2/command/ddl/CreateIndex.java

@@ -27,6 +27,7 @@ public class CreateIndex extends SchemaCommand {
     private String indexName;
     private IndexColumn[] indexColumns;
     private boolean primaryKey, unique, hash, spatial;
+    private boolean ifTableExists;
     private boolean ifNotExists;
     private String comment;
 
@@ -34,6 +35,10 @@ public class CreateIndex extends SchemaCommand {
         super(session, schema);
     }
 
+    public void setIfTableExists(boolean b) {
+        this.ifTableExists = b;
+    }
+
     public void setIfNotExists(boolean ifNotExists) {
         this.ifNotExists = ifNotExists;
     }
@@ -57,7 +62,13 @@ public class CreateIndex extends SchemaCommand {
         }
         Database db = session.getDatabase();
         boolean persistent = db.isPersistent();
-        Table table = getSchema().getTableOrView(session, tableName);
+        Table table = getSchema().findTableOrView(session, tableName);
+        if (table == null) {
+            if (ifTableExists) {
+                return 0;
+            }
+            throw DbException.get(ErrorCode.TABLE_OR_VIEW_NOT_FOUND_1, tableName);
+        }
         if (getSchema().findIndex(session, indexName) != null) {
             if (ifNotExists) {
                 return 0;

h2/src/main/org/h2/command/dml/AlterTableSet.java

@@ -5,6 +5,7 @@
  */
 package org.h2.command.dml;
 
+import org.h2.api.ErrorCode;
 import org.h2.command.CommandInterface;
 import org.h2.command.ddl.SchemaCommand;
 import org.h2.engine.Right;
@@ -19,6 +20,7 @@ import org.h2.table.Table;
  */
 public class AlterTableSet extends SchemaCommand {
 
+    private boolean ifTableExists;
     private String tableName;
     private final int type;
 
@@ -40,13 +42,23 @@ public class AlterTableSet extends SchemaCommand {
         return true;
     }
 
+    public void setIfTableExists(boolean b) {
+        this.ifTableExists = b;
+    }
+
     public void setTableName(String tableName) {
         this.tableName = tableName;
     }
 
     @Override
     public int update() {
-        Table table = getSchema().getTableOrView(session, tableName);
+        Table table = getSchema().findTableOrView(session, tableName);
+        if (table == null) {
+            if (ifTableExists) {
+                return 0;
+            }
+            throw DbException.get(ErrorCode.TABLE_OR_VIEW_NOT_FOUND_1, tableName);
+        }
         session.getUser().checkRight(table, Right.ALL);
         table.lock(session, true, true);
         switch (type) {

h2/src/test/org/h2/test/testScript.sql

@@ -10227,3 +10227,207 @@ select 0 from ((
 > rows: 0
 };
 > update count: 0
+
+create table x(id int not null);
+> ok
+
+alter table if exists y add column a varchar;
+> ok
+
+alter table if exists x add column a varchar;
+> ok
+
+alter table if exists x add column a varchar;
+> exception
+
+alter table if exists y alter column a rename to b;
+> ok
+
+alter table if exists x alter column a rename to b;
+> ok
+
+alter table if exists x alter column a rename to b;
+> exception
+
+alter table if exists y alter column b set default 'a';
+> ok
+
+alter table if exists x alter column b set default 'a';
+> ok
+
+insert into x(id) values(1);
+> update count: 1
+
+select b from x;
+> B
+> -
+> a
+> rows: 1
+
+delete from x;
+> update count: 1
+
+alter table if exists y alter column b drop default;
+> ok
+
+alter table if exists x alter column b drop default;
+> ok
+
+alter table if exists y alter column b set not null;
+> ok
+
+alter table if exists x alter column b set not null;
+> ok
+
+insert into x(id) values(1);
+> exception
+
+alter table if exists y alter column b drop not null;
+> ok
+
+alter table if exists x alter column b drop not null;
+> ok
+
+insert into x(id) values(1);
+> update count: 1
+
+select b from x;
+> B
+> ----
+> null
+> rows: 1
+
+delete from x;
+> update count: 1
+
+alter table if exists y add constraint x_pk primary key (id);
+> ok
+
+alter table if exists x add constraint x_pk primary key (id);
+> ok
+
+alter table if exists x add constraint x_pk primary key (id);
+> exception
+
+insert into x(id) values(1);
+> update count: 1
+
+insert into x(id) values(1);
+> exception
+
+delete from x;
+> update count: 1
+
+alter table if exists y add constraint x_chk check (b = 'a');
+> ok
+
+alter table if exists x add constraint x_chk check (b = 'a');
+> ok
+
+alter table if exists x add constraint x_chk check (b = 'a');
+> exception
+
+insert into x(id, b) values(1, 'b');
+> exception
+
+alter table if exists y rename constraint x_chk to x_chk1;
+> ok
+
+alter table if exists x rename constraint x_chk to x_chk1;
+> ok
+
+alter table if exists x rename constraint x_chk to x_chk1;
+> exception
+
+alter table if exists y drop constraint x_chk1;
+> ok
+
+alter table if exists x drop constraint x_chk1;
+> ok
+
+alter table if exists y rename to z;
+> ok
+
+alter table if exists x rename to z;
+> ok
+
+alter table if exists x rename to z;
+> ok
+
+insert into z(id, b) values(1, 'b');
+> update count: 1
+
+delete from z;
+> update count: 1
+
+alter table if exists y add constraint z_uk unique (b);
+> ok
+
+alter table if exists z add constraint z_uk unique (b);
+> ok
+
+alter table if exists z add constraint z_uk unique (b);
+> exception
+
+insert into z(id, b) values(1, 'b');
+> update count: 1
+
+insert into z(id, b) values(1, 'b');
+> exception
+
+delete from z;
+> update count: 1
+
+alter table if exists y drop column b;
+> ok
+
+alter table if exists z drop column b;
+> ok
+
+alter table if exists z drop column b;
+> exception
+
+alter table if exists y drop primary key;
+> ok
+
+alter table if exists z drop primary key;
+> ok
+
+alter table if exists z drop primary key;
+> exception
+
+create table x (id int not null primary key);
+> ok
+
+alter table if exists y add constraint z_fk foreign key (id) references x (id);
+> ok
+
+alter table if exists z add constraint z_fk foreign key (id) references x (id);
+> ok
+
+alter table if exists z add constraint z_fk foreign key (id) references x (id);
+> exception
+
+insert into z (id) values (1);
+> exception
+
+alter table if exists y drop foreign key z_fk;
+> ok
+
+alter table if exists z drop foreign key z_fk;
+> ok
+
+alter table if exists z drop foreign key z_fk;
+> exception
+
+insert into z (id) values (1);
+> update count: 1
+
+delete from z;
+> update count: 1
+
+drop table x;
+> ok
+
+drop table z;
+> ok