DAT-16825 :: RawSqlStatement refactoring

liquibase-integration-tests/src/test/groovy/liquibase/command/core/UpgradeChecksumVersionIntegrationTest.groovy

@@ -17,7 +17,7 @@ import liquibase.extension.testing.testsystem.TestSystemFactory
 import liquibase.extension.testing.testsystem.spock.LiquibaseIntegrationTest
 import liquibase.statement.SqlStatement
 import liquibase.statement.core.MarkChangeSetRanStatement
-import liquibase.statement.core.RawSqlStatement
+import liquibase.statement.core.RawParameterizedSqlStatement
 import spock.lang.Shared
 import spock.lang.Specification
 import spock.lang.Unroll
@@ -34,7 +34,7 @@ class UpgradeChecksumVersionIntegrationTest extends Specification{
     }
 
     private insertDbclRecord(String changelogfile) {
-        h2.execute(new RawSqlStatement("""
+        h2.execute(new RawParameterizedSqlStatement("""
 INSERT INTO DATABASECHANGELOG
 (ID, AUTHOR, FILENAME, DATEEXECUTED, ORDEREXECUTED, EXECTYPE, MD5SUM, DESCRIPTION, COMMENTS, TAG, LIQUIBASE, CONTEXTS, LABELS, DEPLOYMENT_ID)
 VALUES('1', 'your.name', '$changelogfile', '2023-05-31 14:33:39.108', 1, 'EXECUTED', '8:d925207397a5bb8863a41d513a65afd1', 'sql', 'example comment', NULL, 'DEV', 'example-context1', 'example-label', '5561619071');
@@ -298,12 +298,12 @@ VALUES('1', 'your.name', '$changelogfile', '2023-05-31 14:33:39.108', 1, 'EXECUT
         def changesetFilepath = "changelogs/h2/checksum/dbms-filter-changelog.xml"
         final ChangeLogHistoryService changeLogService = Scope.getCurrentScope().getSingleton(ChangeLogHistoryServiceFactory.class).getChangeLogService(h2.getDatabaseFromFactory())
         changeLogService.init()
-        h2.execute(new RawSqlStatement("""
+        h2.execute(new RawParameterizedSqlStatement("""
 INSERT INTO DATABASECHANGELOG
 (ID, AUTHOR, FILENAME, DATEEXECUTED, ORDEREXECUTED, EXECTYPE, MD5SUM, DESCRIPTION, COMMENTS, TAG, LIQUIBASE, CONTEXTS, LABELS, DEPLOYMENT_ID)
 VALUES('1', 'fl', '$changesetFilepath', '2023-09-29 14:33:39.108', 1, 'EXECUTED', '8:0a36c7b201a287dd3348e8dd19e44be7', 'sql', 'example comment', NULL, 'DEV', 'example-context1', 'example-label', '5561619071');
 """))
-        h2.execute(new RawSqlStatement("""
+        h2.execute(new RawParameterizedSqlStatement("""
 INSERT INTO DATABASECHANGELOG
 (ID, AUTHOR, FILENAME, DATEEXECUTED, ORDEREXECUTED, EXECTYPE, MD5SUM, DESCRIPTION, COMMENTS, TAG, LIQUIBASE, CONTEXTS, LABELS, DEPLOYMENT_ID)
 VALUES('2', 'fl', '$changesetFilepath', '2023-09-29 14:33:39.112', 2, 'EXECUTED', '8:a6a54dbc65048ebf1388da78c31ef1a9', 'sqlFile; sqlFile', '', NULL, 'DEV', 'example-context1', 'example-label', '5561619071');
@@ -342,12 +342,12 @@ VALUES('2', 'fl', '$changesetFilepath', '2023-09-29 14:33:39.112', 2, 'EXECUTED'
         def changesetFilepath = "changelogs/h2/checksum/dbms-filter-changelog.xml"
         final ChangeLogHistoryService changeLogService = Scope.getCurrentScope().getSingleton(ChangeLogHistoryServiceFactory.class).getChangeLogService(h2.getDatabaseFromFactory())
         changeLogService.init()
-        h2.execute(new RawSqlStatement("""
+        h2.execute(new RawParameterizedSqlStatement("""
 INSERT INTO DATABASECHANGELOG
 (ID, AUTHOR, FILENAME, DATEEXECUTED, ORDEREXECUTED, EXECTYPE, MD5SUM, DESCRIPTION, COMMENTS, TAG, LIQUIBASE, CONTEXTS, LABELS, DEPLOYMENT_ID)
 VALUES('1', 'fl', '$changesetFilepath', '2023-09-29 14:33:39.108', 1, 'EXECUTED', '8:0a36c7b201a287dd3348e8dd19e44be7', 'sql', 'example comment', NULL, 'DEV', 'example-context1', 'example-label', '5561619071');
 """))
-        h2.execute(new RawSqlStatement("""
+        h2.execute(new RawParameterizedSqlStatement("""
 INSERT INTO DATABASECHANGELOG
 (ID, AUTHOR, FILENAME, DATEEXECUTED, ORDEREXECUTED, EXECTYPE, MD5SUM, DESCRIPTION, COMMENTS, TAG, LIQUIBASE, CONTEXTS, LABELS, DEPLOYMENT_ID)
 VALUES('2', 'fl', '$changesetFilepath', '2023-09-29 14:33:39.112', 2, 'EXECUTED', '8:a6a54dbc65048ebf1388da78c31ef1a9', 'sqlFile; sqlFile', '', NULL, 'DEV', 'example-context1', 'example-label', '5561619071');

liquibase-integration-tests/src/test/groovy/liquibase/snapshot/IndexWithDescendingColumnSnapshotIntegrationTest.groovy

@@ -26,7 +26,7 @@ import liquibase.parser.core.json.JsonChangeLogParser
 import liquibase.resource.ResourceAccessor
 import liquibase.resource.SearchPathResourceAccessor
 import liquibase.statement.SqlStatement
-import liquibase.statement.core.RawSqlStatement
+import liquibase.statement.core.RawParameterizedSqlStatement
 import liquibase.structure.DatabaseObject
 import liquibase.structure.DatabaseObjectCollection
 import liquibase.structure.core.Column
@@ -47,7 +47,7 @@ class IndexWithDescendingColumnSnapshotIntegrationTest extends Specification {
         def connection = mssqlDb.getConnection()
         def db = DatabaseFactory.instance.findCorrectDatabaseImplementation(new JdbcConnection(connection))
         db.execute([
-                new RawSqlStatement(
+                new RawParameterizedSqlStatement(
                         "CREATE TABLE tbl_Preferences (fld_EmployeeID INTEGER NOT NULL, " +
                                 "fld_JobClass CHAR(4) NOT NULL, " +
                                 "fld_Mon VARCHAR(25) NULL, " +
@@ -58,7 +58,7 @@ class IndexWithDescendingColumnSnapshotIntegrationTest extends Specification {
                                 "fld_Sat VARCHAR(25) NULL, " +
                                 "fld_Sun VARCHAR(25) NULL)"
                 ),
-                new RawSqlStatement(
+                new RawParameterizedSqlStatement(
                         "CREATE INDEX IX_temp_tbl_Preferences_Plain " +
                                 "ON tbl_Preferences(" +
                                 "fld_Fri," +
@@ -147,10 +147,10 @@ class IndexWithDescendingColumnSnapshotIntegrationTest extends Specification {
 
         cleanup:
         db.execute([
-                new RawSqlStatement(
+                new RawParameterizedSqlStatement(
                         "DROP INDEX IX_temp_tbl_Preferences_Plain ON tbl_Preferences"
                 ),
-                new RawSqlStatement(
+                new RawParameterizedSqlStatement(
                         "DROP TABLE tbl_Preferences"
                 )
         ] as SqlStatement[], null)

liquibase-integration-tests/src/test/groovy/liquibase/snapshot/JdbcDatabaseSnapshotH2IntegrationTest.groovy

@@ -7,7 +7,7 @@ import liquibase.extension.testing.testsystem.DatabaseTestSystem
 import liquibase.extension.testing.testsystem.TestSystemFactory
 import liquibase.extension.testing.testsystem.spock.LiquibaseIntegrationTest
 import liquibase.statement.SqlStatement
-import liquibase.statement.core.RawSqlStatement
+import liquibase.statement.core.RawParameterizedSqlStatement
 import liquibase.structure.core.Column
 import liquibase.structure.core.Table
 import liquibase.structure.core.View
@@ -27,10 +27,10 @@ class JdbcDatabaseSnapshotH2IntegrationTest extends Specification {
         def connection = h2.getConnection()
         def db = DatabaseFactory.instance.findCorrectDatabaseImplementation(new JdbcConnection(connection))
         db.execute([
-                new RawSqlStatement("create schema if not exists \"TEST_SCHEMA\""),
-                new RawSqlStatement("create schema if not exists \"TEST-SCHEMA\""),
-                new RawSqlStatement("create table if not exists \"TEST-SCHEMA\".test_table (id int)"),
-                new RawSqlStatement("create view if not exists \"TEST-SCHEMA\".test_view as select * from \"TEST-SCHEMA\".test_table"),
+                new RawParameterizedSqlStatement("create schema if not exists \"TEST_SCHEMA\""),
+                new RawParameterizedSqlStatement("create schema if not exists \"TEST-SCHEMA\""),
+                new RawParameterizedSqlStatement("create table if not exists \"TEST-SCHEMA\".test_table (id int)"),
+                new RawParameterizedSqlStatement("create view if not exists \"TEST-SCHEMA\".test_view as select * from \"TEST-SCHEMA\".test_table"),
         ] as SqlStatement[], null)
 
         then:
@@ -45,8 +45,8 @@ class JdbcDatabaseSnapshotH2IntegrationTest extends Specification {
 
         cleanup:
         db.execute([
-                new RawSqlStatement("drop schema \"test_schema\" if exists"),
-                new RawSqlStatement("drop schema \"test-schema\" if exists"),
+                new RawParameterizedSqlStatement("drop schema \"test_schema\" if exists"),
+                new RawParameterizedSqlStatement("drop schema \"test-schema\" if exists"),
         ] as SqlStatement[], null)
     }
 }

liquibase-integration-tests/src/test/java/liquibase/dbtest/AbstractIntegrationTest.java

@@ -50,6 +50,7 @@
 import liquibase.structure.core.*;
 import liquibase.test.DiffResultAssert;
 import liquibase.test.JUnitResourceAccessor;
+import liquibase.util.ExceptionUtil;
 import liquibase.util.RegexMatcher;
 import org.junit.*;
 import org.junit.rules.TemporaryFolder;
@@ -992,11 +993,13 @@ public void testInvalidIncludeDoesntBreakLiquibase() throws Exception {
     public void testInvalidSqlThrowsException() throws Exception {
         assumeNotNull(this.getDatabase());
         Liquibase liquibase = createLiquibase(invalidSqlChangeLog);
+        Throwable exception = null;
         try {
             liquibase.update(new Contexts());
             fail("Did not fail with invalid SQL");
         } catch (CommandExecutionException executionException) {
-            Assert.assertTrue(executionException.getMessage().contains("this sql is not valid and should throw an exception"));
+            exception = ExceptionUtil.findExceptionInCauseChain(executionException.getCause(), DatabaseException.class);
+            Assert.assertTrue(exception.getCause() instanceof DatabaseException);
         }
 
         LockService lockService = LockServiceFactory.getInstance().getLockService(database);

liquibase-integration-tests/src/test/java/liquibase/dbtest/asany/SybaseASAIntegrationTest.java

@@ -7,7 +7,7 @@
 import liquibase.database.DatabaseFactory;
 import liquibase.dbtest.AbstractIntegrationTest;
 import liquibase.executor.ExecutorService;
-import liquibase.statement.core.RawSqlStatement;
+import liquibase.statement.core.RawParameterizedSqlStatement;
 import org.junit.Ignore;
 import org.junit.Test;
 
@@ -35,7 +35,7 @@ public void testGeneratedColumn() throws Exception {
         clearDatabase();
         Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase())
                 .execute(
-                        new RawSqlStatement("CREATE TABLE generated_test (height_cm numeric, height_stored numeric COMPUTE (height_cm / 2.54))"));
+                        new RawParameterizedSqlStatement("CREATE TABLE generated_test (height_cm numeric, height_stored numeric COMPUTE (height_cm / 2.54))"));
 
         // when
         ByteArrayOutputStream baos = new ByteArrayOutputStream();

liquibase-integration-tests/src/test/java/liquibase/dbtest/cockroachdb/CockroachDBIntegrationTest.java

@@ -8,7 +8,7 @@
 import liquibase.snapshot.DatabaseSnapshot;
 import liquibase.snapshot.SnapshotControl;
 import liquibase.snapshot.SnapshotGeneratorFactory;
-import liquibase.statement.core.RawSqlStatement;
+import liquibase.statement.core.RawParameterizedSqlStatement;
 import liquibase.structure.core.Column;
 import liquibase.structure.core.PrimaryKey;
 import liquibase.structure.core.Table;
@@ -33,9 +33,9 @@ public void descPrimaryKey() throws Exception {
         }
         final Executor executor = Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase());
 
-        executor.execute(new RawSqlStatement("DROP TABLE IF EXISTS pk"));
+        executor.execute(new RawParameterizedSqlStatement("DROP TABLE IF EXISTS pk"));
 
-        executor.execute(new RawSqlStatement("CREATE TABLE pk (\n" +
+        executor.execute(new RawParameterizedSqlStatement("CREATE TABLE pk (\n" +
                 "a INT8 NOT NULL,\n" +
                 "b INT8 NOT NULL,\n" +
                 "c INT8 NOT NULL,\n" +

liquibase-integration-tests/src/test/java/liquibase/dbtest/h2/H2IntegrationTest.java

@@ -20,7 +20,7 @@
 import liquibase.exception.ValidationFailedException;
 import liquibase.executor.Executor;
 import liquibase.executor.ExecutorService;
-import liquibase.statement.core.RawSqlStatement;
+import liquibase.statement.core.RawParameterizedSqlStatement;
 import liquibase.structure.core.DatabaseObjectFactory;
 import org.junit.Assert;
 import org.junit.Test;
@@ -154,21 +154,21 @@ public void testRollbackByContext() throws Exception {
             clearDatabase();
 
             Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase())
-                    .execute(new RawSqlStatement(String.format("CREATE TABLE %s (%s varchar(50))", tableName, colName)));
+                    .execute(new RawParameterizedSqlStatement(String.format("CREATE TABLE %s (%s varchar(50))", tableName, colName)));
 
             Liquibase liquibase = createLiquibase("changelogs/h2/complete/rollback.different.contexts.changelog.xml");
             liquibase.update(context);
 
             List<Map<String, ?>> queryResult = Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase())
-                    .queryForList(new RawSqlStatement(String.format("select * from %s", tableName)));
+                    .queryForList(new RawParameterizedSqlStatement(String.format("select * from %s", tableName)));
 
             Assert.assertEquals(1, queryResult.size());
             Assert.assertEquals(insertedValue.toString(), queryResult.get(0).get(colName));
             insertedValue++;
 
             liquibase.rollback(1, context);
             queryResult = Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase())
-                    .queryForList(new RawSqlStatement(String.format("select * from %s", tableName)));
+                    .queryForList(new RawParameterizedSqlStatement(String.format("select * from %s", tableName)));
             Assert.assertEquals("Rollbacking for " + insertedValue, 2, queryResult.size());
             Assert.assertEquals(insertedValue.toString(), queryResult.get(1).get(colName));
             insertedValue++;
@@ -182,23 +182,21 @@ public void testRollbackWithoutContext() throws Exception {
         String tableName = "tmp_tbl";
 
         clearDatabase();
-
         Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase())
-                .execute(new RawSqlStatement(String.format("CREATE TABLE %s (%s varchar(50))", tableName, colName)));
+                .execute(new RawParameterizedSqlStatement(String.format("CREATE TABLE %s (%s varchar(50))", tableName, colName)));
 
         Liquibase liquibase = createLiquibase("changelogs/h2/complete/rollback.sql.changelog.xml");
         liquibase.update();
-
         List<Map<String, ?>> queryResult = Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase())
-                .queryForList(new RawSqlStatement(String.format("select * from %s", tableName)));
+                .queryForList(new RawParameterizedSqlStatement(String.format("select * from %s", tableName)));
 
         Assert.assertEquals(1, queryResult.size());
         Assert.assertEquals(insertedValue.toString(), queryResult.get(0).get(colName));
         insertedValue++;
 
         liquibase.rollback(1, null);
         queryResult = Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase())
-                .queryForList(new RawSqlStatement(String.format("select * from %s", tableName)));
+                .queryForList(new RawParameterizedSqlStatement(String.format("select * from %s", tableName)));
         Assert.assertEquals("Rollbacking for " + insertedValue, 2, queryResult.size());
         Assert.assertEquals(insertedValue.toString(), queryResult.get(1).get(colName));
     }
@@ -210,14 +208,14 @@ public void makeSureDbmsFilteredChangeIsNotDeployed() throws Exception {
 
         try {
             Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase())
-                    .queryForList(new RawSqlStatement("select * from oraculo"));
+                    .queryForList(new RawParameterizedSqlStatement("select * from oraculo"));
         }
         catch (DatabaseException e) {
             Assert.assertTrue(e.getMessage().contains("Table \"ORACULO\" not found"));
         }
         try {
             Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase())
-                    .queryForList(new RawSqlStatement("select * from anydb"));
+                    .queryForList(new RawParameterizedSqlStatement("select * from anydb"));
         }
         catch (DatabaseException e) {
             Assert.assertTrue(e.getMessage().contains("Table \"ANYDB\" not found"));

liquibase-integration-tests/src/test/java/liquibase/dbtest/mariadb/MariaDBIntegrationTest.java

@@ -9,7 +9,7 @@
 import liquibase.snapshot.DatabaseSnapshot;
 import liquibase.snapshot.SnapshotControl;
 import liquibase.snapshot.SnapshotGeneratorFactory;
-import liquibase.statement.core.RawSqlStatement;
+import liquibase.statement.core.RawParameterizedSqlStatement;
 import liquibase.structure.core.Column;
 import liquibase.structure.core.Schema;
 import liquibase.structure.core.Table;
@@ -32,11 +32,11 @@ public void dateDefaultValue() throws Exception {
         if (getDatabase() == null) {
             return;
         }
-        Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawSqlStatement("DROP TABLE IF " +
+        Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawParameterizedSqlStatement("DROP TABLE IF " +
              "EXISTS ad"));
 
         try {
-            Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawSqlStatement("CREATE TABLE ad (\n" +
+            Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawParameterizedSqlStatement("CREATE TABLE ad (\n" +
                     "ad_id int(10) unsigned NOT NULL AUTO_INCREMENT,\n" +
                     "advertiser_id int(10) unsigned NOT NULL,\n" +
                     "ad_type_id int(10) unsigned NOT NULL,\n" +

liquibase-integration-tests/src/test/java/liquibase/dbtest/mysql/MySQLIntegrationTest.java

@@ -9,7 +9,7 @@
 import liquibase.snapshot.DatabaseSnapshot;
 import liquibase.snapshot.SnapshotControl;
 import liquibase.snapshot.SnapshotGeneratorFactory;
-import liquibase.statement.core.RawSqlStatement;
+import liquibase.statement.core.RawParameterizedSqlStatement;
 import liquibase.structure.core.Column;
 import liquibase.structure.core.Schema;
 import liquibase.structure.core.Table;
@@ -52,11 +52,11 @@ public void dateDefaultValue() throws Exception {
         if (getDatabase() == null) {
             return;
         }
-        Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawSqlStatement("DROP TABLE IF " +
+        Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawParameterizedSqlStatement("DROP TABLE IF " +
                                                                                                      "EXISTS ad"));
 
         try {
-            Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawSqlStatement("CREATE TABLE ad (\n" +
+            Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawParameterizedSqlStatement("CREATE TABLE ad (\n" +
                                                                                                          "ad_id int(10) unsigned NOT NULL AUTO_INCREMENT,\n" +
                                                                                                          "advertiser_id int(10) unsigned NOT NULL,\n" +
                                                                                                          "ad_type_id int(10) unsigned NOT NULL,\n" +

liquibase-integration-tests/src/test/java/liquibase/dbtest/oracle/OracleIntegrationTest.java

@@ -19,7 +19,7 @@
 import liquibase.executor.ExecutorService;
 import liquibase.snapshot.DatabaseSnapshot;
 import liquibase.sql.visitor.AbstractSqlVisitor;
-import liquibase.statement.core.RawSqlStatement;
+import liquibase.statement.core.RawParameterizedSqlStatement;
 import liquibase.structure.core.Index;
 import org.junit.Assert;
 import org.junit.Test;
@@ -224,7 +224,7 @@ public void testChangeLogGenerationForTableWithGeneratedColumn() throws Exceptio
         clearDatabase();
         String textToTest = "GENERATED ALWAYS AS (QTY*PRICE)";
 
-        Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawSqlStatement(
+        Scope.getCurrentScope().getSingleton(ExecutorService.class).getExecutor("jdbc", getDatabase()).execute(new RawParameterizedSqlStatement(
             String.format("CREATE TABLE GENERATED_COLUMN_TEST(QTY INT, PRICE INT, TOTALVALUE INT %s)", textToTest)));
 
         ByteArrayOutputStream baos = new ByteArrayOutputStream();