Bump h2 from 1.4.200 to 2.0.202 in /liquibase-dist

liquibase-core/src/main/java/liquibase/changelog/StandardChangeLogHistoryService.java

@@ -137,7 +137,7 @@ public void init() throws DatabaseException {
             boolean checksumNotRightSize = false;
             if (!(this.getDatabase() instanceof SQLiteDatabase)) {
                 DataType type = changeLogTable.getColumn("MD5SUM").getType();
-                if (type.getTypeName().toLowerCase().startsWith("varchar")) {
+                if (type.getTypeName().toLowerCase().startsWith("varchar") || type.getTypeName().toLowerCase().startsWith("character varying")) {
                     Integer columnSize = type.getColumnSize();
                     checksumNotRightSize = (columnSize != null) && (columnSize < 35);
                 } else {

liquibase-core/src/main/java/liquibase/database/core/H2Database.java

@@ -34,21 +34,31 @@ public class H2Database extends AbstractJdbcDatabase {
     private static List keywords = Arrays.asList(
             "ALL",
             "AND",
+            "ANY",
             "ARRAY",
             "AS",
+            "ASYMMETRIC",
+            "AUTHORIZATION",
             "BETWEEN",
             "BOTH",
             "CASE",
+            "CAST",
             "CHECK",
             "CONSTRAINT",
             "CROSS",
             "CURRENT_CATALOG",
             "CURRENT_DATE",
+            "CURRENT_PATH",
+            "CURRENT_ROLE",
             "CURRENT_SCHEMA",
             "CURRENT_TIME",
             "CURRENT_TIMESTAMP",
             "CURRENT_USER",
+            "DAY",
+            "DEFAULT",
             "DISTINCT",
+            "ELSE",
+            "END",
             "EXCEPT",
             "EXISTS",
             "FALSE",
@@ -61,22 +71,28 @@ public class H2Database extends AbstractJdbcDatabase {
             "GROUP",
             "GROUPS",
             "HAVING",
+            "HOUR",
             "IF",
             "ILIKE",
             "IN",
+            "ILIKE",
+            "IN",
             "INNER",
             "INTERSECT",
             "INTERSECTS",
             "INTERVAL",
             "IS",
             "JOIN",
+            "KEY",
             "LEADING",
             "LEFT",
             "LIKE",
             "LIMIT",
             "LOCALTIME",
             "LOCALTIMESTAMP",
             "MINUS",
+            "MINUTE",
+            "MONTH",
             "NATURAL",
             "NOT",
             "NULL",
@@ -92,26 +108,37 @@ public class H2Database extends AbstractJdbcDatabase {
             "REGEXP",
             "RIGHT",
             "ROW",
-            "_ROWID_",
             "ROWNUM",
             "ROWS",
             "SELECT",
+            "SESSION_USER",
+            "SET",
+            "SOME",
+            "SYMMETRIC",
+            "SYSTEM_USER",
             "SYSDATE",
             "SYSTIME",
             "SYSTIMESTAMP",
             "TABLE",
+            "TO",
             "TODAY",
             "TOP",
             "TRAILING",
             "TRUE",
+            "UNESCAPE",
             "UNION",
             "UNIQUE",
             "UNKNOWN",
+            "USER",
             "USING",
+            "VALUE",
             "VALUES",
+            "WHEN",
             "WHERE",
             "WINDOW",
-            "WITH"
+            "WITH",
+            "YEAR",
+            "_ROWID_"
     );
     private String connectionSchemaName = "PUBLIC";
 

liquibase-core/src/main/java/liquibase/datatype/core/BlobType.java

@@ -20,6 +20,9 @@ public DatabaseDataType toDatabaseDataType(Database database) {
         String originalDefinition = StringUtil.trimToEmpty(getRawDefinition());
 
         if ((database instanceof H2Database) || (database instanceof HsqlDatabase)) {
+            if (originalDefinition.toLowerCase(Locale.US).contains("large object")) {
+                return new DatabaseDataType("BINARY LARGE OBJECT");
+            }
             if (originalDefinition.toLowerCase(Locale.US).startsWith("varbinary") || originalDefinition.startsWith("java.sql.Types.VARBINARY")) {
                 return new DatabaseDataType("VARBINARY", getParameters());
             } else if (originalDefinition.toLowerCase(Locale.US).startsWith("longvarbinary") || originalDefinition.startsWith("java.sql.Types.LONGVARBINARY")) {

liquibase-core/src/main/java/liquibase/datatype/core/CharType.java

@@ -2,6 +2,7 @@
 
 import liquibase.change.core.LoadDataChange;
 import liquibase.database.Database;
+import liquibase.database.core.H2Database;
 import liquibase.database.core.MSSQLDatabase;
 import liquibase.database.core.PostgresDatabase;
 import liquibase.datatype.DataTypeInfo;
@@ -14,7 +15,7 @@
 import java.util.Arrays;
 import java.util.Locale;
 
-@DataTypeInfo(name="char", aliases = {"java.sql.Types.CHAR", "bpchar"}, minParameters = 0, maxParameters = 1, priority = LiquibaseDataType.PRIORITY_DEFAULT)
+@DataTypeInfo(name="char", aliases = {"java.sql.Types.CHAR", "bpchar", "character"}, minParameters = 0, maxParameters = 1, priority = LiquibaseDataType.PRIORITY_DEFAULT)
 public class CharType extends LiquibaseDataType {
     @Override
     public DatabaseDataType toDatabaseDataType(Database database) {
@@ -45,6 +46,10 @@ public DatabaseDataType toDatabaseDataType(Database database) {
                 return type;
             }
             return super.toDatabaseDataType(database);
+        } else if (database instanceof H2Database) {
+            if (getRawDefinition().toLowerCase(Locale.US).contains("large object")) {
+                return new DatabaseDataType("CHARACTER LARGE OBJECT");
+            }
         }
 
         return super.toDatabaseDataType(database);

liquibase-core/src/main/java/liquibase/datatype/core/DoubleType.java

@@ -21,10 +21,13 @@ public DatabaseDataType toDatabaseDataType(Database database) {
                 return new DatabaseDataType("DOUBLE");
             }
         }
-        if ((database instanceof AbstractDb2Database) || (database instanceof DerbyDatabase) || (database instanceof
-            HsqlDatabase)) {
+        if ((database instanceof AbstractDb2Database) || (database instanceof DerbyDatabase) || (database instanceof HsqlDatabase)) {
             return new DatabaseDataType("DOUBLE");
         }
+        if (database instanceof H2Database && getRawDefinition().toLowerCase().contains("precision")) {
+            return new DatabaseDataType("DOUBLE PRECISION");
+        }
+
         if (database instanceof OracleDatabase) {
             return new DatabaseDataType("FLOAT", 24);
         }

liquibase-core/src/main/java/liquibase/snapshot/JdbcDatabaseSnapshot.java

@@ -1653,6 +1653,25 @@ private String createSql(String catalogName, String schemaName, String tableName
                             sql += " and systable.table_name = '" + tableName + "'";
                         }
                     } else {
+                        if (database instanceof H2Database) {
+                            try {
+                                if (database.getDatabaseMajorVersion() >= 2) {
+                                    sql = "select CONSTRAINT_NAME, CONSTRAINT_TYPE, TABLE_NAME "
+                                            + "from " + database.getSystemSchema() + ".table_constraints "
+                                            + "where constraint_schema='" + jdbcSchemaName + "' "
+                                            + "and constraint_catalog='" + jdbcCatalogName + "' "
+                                            + "and constraint_type='UNIQUE'";
+                                    if (tableName != null) {
+                                        sql += " and table_name='" + tableName + "'";
+                                    }
+
+                                    return sql;
+                                }
+                            } catch (DatabaseException e) {
+                                Scope.getCurrentScope().getLog(getClass()).fine("Cannot determine h2 version, using default unique constraint query");
+                            }
+                        }
+
                         sql = "select CONSTRAINT_NAME, CONSTRAINT_TYPE, TABLE_NAME "
                                 + "from " + database.getSystemSchema() + ".constraints "
                                 + "where constraint_schema='" + jdbcSchemaName + "' "

liquibase-core/src/main/java/liquibase/snapshot/jvm/IndexSnapshotGenerator.java

@@ -200,7 +200,7 @@ protected DatabaseObject snapshotObject(DatabaseObject example, DatabaseSnapshot
                     continue;
                 }
 
-                if (type == DatabaseMetaData.tableIndexStatistic) {
+                if (!(database instanceof H2Database) && type == DatabaseMetaData.tableIndexStatistic) {
                     continue;
                 }
 

liquibase-core/src/main/java/liquibase/snapshot/jvm/SequenceSnapshotGenerator.java

@@ -173,7 +173,14 @@ protected String getSelectSequenceSql(Schema schema, Database database) {
         } else if (database instanceof FirebirdDatabase) {
             return "SELECT TRIM(RDB$GENERATOR_NAME) AS SEQUENCE_NAME FROM RDB$GENERATORS WHERE RDB$SYSTEM_FLAG IS NULL OR RDB$SYSTEM_FLAG = 0";
         } else if (database instanceof H2Database) {
-            return "SELECT SEQUENCE_NAME FROM INFORMATION_SCHEMA.SEQUENCES WHERE SEQUENCE_SCHEMA = '" + schema.getName() + "' AND IS_GENERATED=FALSE";
+            try {
+                if (database.getDatabaseMajorVersion() <= 1) {
+                    return "SELECT SEQUENCE_NAME FROM INFORMATION_SCHEMA.SEQUENCES WHERE SEQUENCE_SCHEMA = '" + schema.getName() + "' AND IS_GENERATED=FALSE";
+                }
+            } catch (DatabaseException e) {
+                Scope.getCurrentScope().getLog(getClass()).fine("Cannot determine h2 version in order to generate sequence snapshot query");
+            }
+            return "SELECT SEQUENCE_NAME FROM INFORMATION_SCHEMA.SEQUENCES WHERE SEQUENCE_SCHEMA = '" + schema.getName() + "'";
         } else if (database instanceof HsqlDatabase) {
             return "SELECT SEQUENCE_NAME FROM INFORMATION_SCHEMA.SYSTEM_SEQUENCES WHERE SEQUENCE_SCHEMA = '" + schema.getName() + "'";
         } else if (database instanceof InformixDatabase) {

liquibase-core/src/main/java/liquibase/snapshot/jvm/UniqueConstraintSnapshotGenerator.java

@@ -330,9 +330,33 @@ protected List<CachedRow> listConstraints(Table table, DatabaseSnapshot snapshot
                         + "where KC.CONSTNAME = TC.CONSTNAME "
                         + "and KC.TBCREATOR = TC.TBCREATOR "
                         + "and TC.TYPE='U' "
-                        + (bulkQuery? "" : "and KC.CONSTNAME='" + database.correctObjectName(name, UniqueConstraint.class) + "' ")
+                        + (bulkQuery ? "" : "and KC.CONSTNAME='" + database.correctObjectName(name, UniqueConstraint.class) + "' ")
                         + "and TC.TBCREATOR = '" + database.correctObjectName(schema.getName(), Schema.class) + "' "
                         + "order by KC.COLSEQ";
+            } else if (database instanceof H2Database && database.getDatabaseMajorVersion() >= 2) {
+                String catalogName = database.correctObjectName(schema.getCatalogName(), Catalog.class);
+                String schemaName = database.correctObjectName(schema.getName(), Schema.class);
+                String constraintName = database.correctObjectName(name, UniqueConstraint.class);
+                String tableName = database.correctObjectName(table.getName(), Table.class);
+                sql = "select table_constraints.CONSTRAINT_NAME, index_columns.COLUMN_NAME, table_constraints.constraint_schema as CONSTRAINT_CONTAINER "
+                        + "from information_schema.table_constraints " +
+                        "join information_schema.index_columns on index_columns.index_name=table_constraints.index_name "
+                        + "where constraint_type='UNIQUE' ";
+                if (catalogName != null) {
+                    sql += "and constraint_catalog='" + catalogName + "' ";
+                }
+                if (schemaName != null) {
+                    sql += "and constraint_schema='" + schemaName + "' ";
+                }
+
+                if (!bulkQuery) {
+                    if (tableName != null) {
+                        sql += "and table_constraints.table_name='" + tableName + "' ";
+                    }
+                    if (constraintName != null) {
+                        sql += "and constraint_name='" + constraintName + "'";
+                    }
+                }
             } else {
                 // If we do not have a specific handler for the RDBMS, we assume that the database has an
                 // INFORMATION_SCHEMA we can use. This is a last-resort measure and might fail.

liquibase-core/src/test/resources/liquibase/integration/ant/DatabaseRollbackTaskTest.xml

@@ -47,13 +47,13 @@
 
     <target name="testRollbackDatabaseByCount">
         <db:assertRowCountEquals driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                 table="users" count="1"/>
+                                 table="TEST_USERS" count="1"/>
         <lb:rollbackDatabase rollbackCount="1"
                              changelogfile="${liquibase.test.ant.basedir}/changelog/changelog-with-rollback.xml">
             <lb:database driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"/>
         </lb:rollbackDatabase>
         <db:assertRowCountEquals driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                 table="users" count="0"/>
+                                 table="TEST_USERS" count="0"/>
     </target>
 
     <target name="testRollbackDatabaseByCountOutputToFile">
@@ -74,13 +74,13 @@
 
     <target name="testRollbackDatabaseByTag">
         <db:assertRowCountEquals driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                 table="users" count="1"/>
+                                 table="TEST_USERS" count="1"/>
         <lb:rollbackDatabase rollbacktag="${tag}"
                              changelogfile="${liquibase.test.ant.basedir}/changelog/changelog-with-rollback.xml">
             <lb:database driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"/>
         </lb:rollbackDatabase>
         <db:assertRowCountEquals driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                 table="users" count="0"/>
+                                 table="TEST_USERS" count="0"/>
     </target>
 
     <target name="testRollbackDatabaseByTagOutputToFile">
@@ -93,13 +93,13 @@
 
     <target name="testRollbackDatabaseByDate">
         <db:assertRowCountEquals driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                 table="users" count="1"/>
+                                 table="TEST_USERS" count="1"/>
         <lb:rollbackDatabase rollbackdate="${today.date}"
                              changelogfile="${liquibase.test.ant.basedir}/changelog/changelog-with-rollback.xml">
             <lb:database driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"/>
         </lb:rollbackDatabase>
         <db:assertRowCountEquals driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                 table="users" count="0"/>
+                                 table="TEST_USERS" count="0"/>
     </target>
 
     <target name="testRollbackDatabaseByDateOutputToFile">
@@ -146,14 +146,14 @@
     	<!--   to changelog-with-rollback.xml::1::testuser -->
     	<!-- So it's not the same we inserted into databasechangelog during the setUp preStep -->
         <db:assertRowCountEquals driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                 table="users" count="1"/>
+                                 table="TEST_USERS" count="1"/>
         <lb:rollbackDatabase rollbackCount="1"
                              changelogdirectory="${liquibase.test.ant.basedir}/changelog"
                              changelogfile="changelog-with-rollback.xml">
             <lb:database driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"/>
         </lb:rollbackDatabase>
         <db:assertRowCountEquals driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                 table="users" count="1"/>
+                                 table="TEST_USERS" count="1"/>
     </target>
 
     <target name="testRollbackDatabaseByCountChangeLogDirectoryDoesNotExist">

liquibase-core/src/test/resources/liquibase/integration/ant/DropAllTaskTest.xml

@@ -28,20 +28,18 @@
     </target>
 
     <target name="testDropAllTask">
-        <db:assertTableExists driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                             table="USERS"/>
+        <db:assertTableExists driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}" table="TEST_USERS"/>
         <lb:dropAllDatabaseObjects>
             <lb:database driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"/>
         </lb:dropAllDatabaseObjects>
-        <db:assertTableDoesntExist driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                   table="USERS"/>
+        <db:assertTableDoesntExist driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}" table="TEST_USERS"/>
     </target>
 
     <target name="testDropAllTaskDatabaseRef">
         <db:assertTableExists driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                             table="USERS"/>
+                             table="TEST_USERS"/>
         <lb:dropAllDatabaseObjects databaseref="test-db"/>
         <db:assertTableDoesntExist driver="${jdbc.driver}" url="${jdbc.url}" user="${db.user}" password="${db.password}"
-                                    table="USERS"/>
+                                    table="TEST_USERS"/>
     </target>
-</project>
+</project>

liquibase-core/src/test/resources/liquibase/integration/ant/changelog/changelog-with-properties.xml

@@ -3,9 +3,9 @@
                    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
                    http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.2.xsd">
     <changeSet id="1" author="testuser">
-        <addColumn tableName="users">
+        <addColumn tableName="test_users">
             <column name="${column.one}" type="VARCHAR(50)"/>
             <column name="${column.two}" type="VARCHAR(50)"/>
         </addColumn>
     </changeSet>
-</databaseChangeLog>
+</databaseChangeLog>

liquibase-core/src/test/resources/liquibase/integration/ant/changelog/changelog-with-rollback.xml

@@ -3,12 +3,12 @@
                    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
                    http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.2.xsd">
     <changeSet id="1" author="testuser">
-        <insert tableName="users">
+        <insert tableName="test_users">
             <column name="first_name" value="test"/>
             <column name="last_name" value="name"/>
         </insert>
         <rollback>
-            DELETE FROM users WHERE first_name = 'test' AND last_name = 'name' LIMIT 1;
+            DELETE FROM test_users WHERE first_name = 'test' AND last_name = 'name' LIMIT 1;
         </rollback>
     </changeSet>
-</databaseChangeLog>
+</databaseChangeLog>

liquibase-core/src/test/resources/liquibase/integration/ant/changelog/simple-changelog.xml

@@ -3,7 +3,7 @@
                    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog
                    http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-3.2.xsd">
     <changeSet id="1" author="testuser">
-        <insert tableName="users">
+        <insert tableName="test_users">
             <column name="first_name" value="test"/>
             <column name="last_name" value="name"/>
         </insert>
@@ -24,4 +24,4 @@
     <changeSet id="4" author="testuser">
         <tagDatabase tag="version_2.0"/>
     </changeSet>
-</databaseChangeLog>
+</databaseChangeLog>

liquibase-core/src/test/resources/liquibase/integration/ant/sql/h2-setup.sql

@@ -1,5 +1,5 @@
-CREATE TABLE users (
-  user_id BIGINT NOT NULL IDENTITY,
+CREATE TABLE test_users (
+  user_id BIGINT NOT NULL GENERATED BY DEFAULT AS IDENTITY,
   first_name VARCHAR(50) NOT NULL,
   last_name VARCHAR(50) NOT NULL,
   CONSTRAINT pk_users PRIMARY KEY (user_id)