From 6143d2a6ed98909dea33916f75299a1e6f977246 Mon Sep 17 00:00:00 2001 From: vishwasvaidya-cloudsufi Date: Sat, 21 Nov 2026 14:38:22 +0000 Subject: [PATCH] Fix SQL injection in connector sample path and escape init queries --- .../amazon/redshift/RedshiftConnector.java | 2 +- .../redshift/RedshiftConnectorUnitTest.java | 9 + .../mysql/CloudSQLMySQLConnector.java | 2 +- .../mysql/CloudSQLMySQLConnectorUnitTest.java | 48 +++ .../postgres/CloudSQLPostgreSQLConnector.java | 2 +- .../CloudSQLPostgreSQLConnectorUnitTest.java | 54 +++ database-commons/pom.xml | 5 + .../plugin/db/ConnectionConfigAccessor.java | 9 + .../plugin/db/RollbackOnCloseConnection.java | 55 +++ .../AbstractDBSpecificConnector.java | 77 +++- .../db/source/DataDrivenETLDBInputFormat.java | 12 + .../db/RollbackOnCloseConnectionTest.java | 71 ++++ ...stractDBSpecificConnectorReadOnlyTest.java | 360 ++++++++++++++++++ .../db/connector/QuoteIdentifierTest.java | 52 +++ .../DataDrivenETLDBInputFormatTest.java | 2 + .../databricks/DatabricksConnector.java | 22 +- .../DatabricksConnectorUnitTest.java | 19 +- .../io/cdap/plugin/mssql/SqlServerAction.java | 2 +- .../cdap/plugin/mssql/SqlServerConnector.java | 8 +- .../cdap/plugin/mssql/SqlServerConstants.java | 9 + .../plugin/mssql/SqlServerPostAction.java | 2 +- .../io/cdap/plugin/mssql/SqlServerSink.java | 2 +- .../io/cdap/plugin/mssql/SqlServerSource.java | 2 +- .../mssql/SqlServerConnectorUnitTest.java | 21 + .../mssql/SqlServerInitQueriesUnitTest.java | 97 +++++ .../io/cdap/plugin/mysql/MysqlAction.java | 2 +- .../io/cdap/plugin/mysql/MysqlConnector.java | 7 +- .../io/cdap/plugin/mysql/MysqlConstants.java | 9 + .../io/cdap/plugin/mysql/MysqlPostAction.java | 2 +- .../java/io/cdap/plugin/mysql/MysqlSink.java | 2 +- .../io/cdap/plugin/mysql/MysqlSource.java | 2 +- .../plugin/mysql/MysqlConnectorUnitTest.java | 19 + .../mysql/MysqlInitQueriesUnitTest.java | 104 +++++ .../cdap/plugin/oracle/OracleConnector.java | 7 +- .../oracle/OracleConnectorUnitTest.java | 19 + .../plugin/postgres/PostgresConnector.java | 7 +- .../postgres/PostgresConnectorUnitTest.java | 22 ++ 37 files changed, 1095 insertions(+), 51 deletions(-) create mode 100644 cloudsql-mysql-plugin/src/test/java/io/cdap/plugin/cloudsql/mysql/CloudSQLMySQLConnectorUnitTest.java create mode 100644 cloudsql-postgresql-plugin/src/test/java/io/cdap/plugin/cloudsql/postgres/CloudSQLPostgreSQLConnectorUnitTest.java create mode 100644 database-commons/src/main/java/io/cdap/plugin/db/RollbackOnCloseConnection.java create mode 100644 database-commons/src/test/java/io/cdap/plugin/db/RollbackOnCloseConnectionTest.java create mode 100644 database-commons/src/test/java/io/cdap/plugin/db/connector/AbstractDBSpecificConnectorReadOnlyTest.java create mode 100644 database-commons/src/test/java/io/cdap/plugin/db/connector/QuoteIdentifierTest.java create mode 100644 mssql-plugin/src/test/java/io/cdap/plugin/mssql/SqlServerInitQueriesUnitTest.java create mode 100644 mysql-plugin/src/test/java/io/cdap/plugin/mysql/MysqlInitQueriesUnitTest.java diff --git a/amazon-redshift-plugin/src/main/java/io/cdap/plugin/amazon/redshift/RedshiftConnector.java b/amazon-redshift-plugin/src/main/java/io/cdap/plugin/amazon/redshift/RedshiftConnector.java index fb8cac4a7..57a253ebb 100644 --- a/amazon-redshift-plugin/src/main/java/io/cdap/plugin/amazon/redshift/RedshiftConnector.java +++ b/amazon-redshift-plugin/src/main/java/io/cdap/plugin/amazon/redshift/RedshiftConnector.java @@ -82,7 +82,7 @@ protected SchemaReader getSchemaReader(String sessionID) { @Override protected String getTableName(String database, String schema, String table) { - return String.format("\"%s\".\"%s\"", schema, table); + return quoteIdentifier(schema, '"') + "." + quoteIdentifier(table, '"'); } @Override diff --git a/amazon-redshift-plugin/src/test/java/io/cdap/plugin/amazon/redshift/RedshiftConnectorUnitTest.java b/amazon-redshift-plugin/src/test/java/io/cdap/plugin/amazon/redshift/RedshiftConnectorUnitTest.java index 94ea6004b..16c94a3f0 100644 --- a/amazon-redshift-plugin/src/test/java/io/cdap/plugin/amazon/redshift/RedshiftConnectorUnitTest.java +++ b/amazon-redshift-plugin/src/test/java/io/cdap/plugin/amazon/redshift/RedshiftConnectorUnitTest.java @@ -41,6 +41,15 @@ public void getTableNameTest() { CONNECTOR.getTableName("db", "schema", "table")); } + /** + * Unit test for getTableName() with identifiers containing double quotes + */ + @Test + public void getTableNameEscapesQuotesTest() { + Assert.assertEquals("\"my\"\"schema\".\"t\"\"; DELETE FROM x; --\"", + CONNECTOR.getTableName("db", "my\"schema", "t\"; DELETE FROM x; --")); + } + @Test public void getRandomQuery() { Assert.assertEquals("SELECT * FROM TestData\n" + diff --git a/cloudsql-mysql-plugin/src/main/java/io/cdap/plugin/cloudsql/mysql/CloudSQLMySQLConnector.java b/cloudsql-mysql-plugin/src/main/java/io/cdap/plugin/cloudsql/mysql/CloudSQLMySQLConnector.java index 0751bd160..dccb8b047 100644 --- a/cloudsql-mysql-plugin/src/main/java/io/cdap/plugin/cloudsql/mysql/CloudSQLMySQLConnector.java +++ b/cloudsql-mysql-plugin/src/main/java/io/cdap/plugin/cloudsql/mysql/CloudSQLMySQLConnector.java @@ -82,7 +82,7 @@ protected SchemaReader getSchemaReader(String sessionID) { @Override protected String getTableName(String database, String schema, String table) { - return String.format("`%s`.`%s`", database, table); + return quoteIdentifier(database, '`') + "." + quoteIdentifier(table, '`'); } @Override diff --git a/cloudsql-mysql-plugin/src/test/java/io/cdap/plugin/cloudsql/mysql/CloudSQLMySQLConnectorUnitTest.java b/cloudsql-mysql-plugin/src/test/java/io/cdap/plugin/cloudsql/mysql/CloudSQLMySQLConnectorUnitTest.java new file mode 100644 index 000000000..84284ceb4 --- /dev/null +++ b/cloudsql-mysql-plugin/src/test/java/io/cdap/plugin/cloudsql/mysql/CloudSQLMySQLConnectorUnitTest.java @@ -0,0 +1,48 @@ +/* + * Copyright © 2026 Cask Data, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package io.cdap.plugin.cloudsql.mysql; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Unit tests for {@link CloudSQLMySQLConnector} + */ +public class CloudSQLMySQLConnectorUnitTest { + + private static final CloudSQLMySQLConnector CONNECTOR = new CloudSQLMySQLConnector( + new CloudSQLMySQLConnectorConfig("user", "password", "cloudsql-mysql", "", "public", + "project:region:instance", "db", null)); + + /** + * Unit test for getTableName() + */ + @Test + public void getTableNameTest() { + Assert.assertEquals("`db`.`table`", + CONNECTOR.getTableName("db", null, "table")); + } + + /** + * Unit test for getTableName() with identifiers containing backticks + */ + @Test + public void getTableNameEscapesBackticksTest() { + Assert.assertEquals("`my``db`.`t``; DELETE FROM x; --`", + CONNECTOR.getTableName("my`db", null, "t`; DELETE FROM x; --")); + } +} diff --git a/cloudsql-postgresql-plugin/src/main/java/io/cdap/plugin/cloudsql/postgres/CloudSQLPostgreSQLConnector.java b/cloudsql-postgresql-plugin/src/main/java/io/cdap/plugin/cloudsql/postgres/CloudSQLPostgreSQLConnector.java index 348a1b94c..8f1921478 100644 --- a/cloudsql-postgresql-plugin/src/main/java/io/cdap/plugin/cloudsql/postgres/CloudSQLPostgreSQLConnector.java +++ b/cloudsql-postgresql-plugin/src/main/java/io/cdap/plugin/cloudsql/postgres/CloudSQLPostgreSQLConnector.java @@ -86,7 +86,7 @@ protected SchemaReader getSchemaReader(String sessionID) { @Override protected String getTableName(String database, String schema, String table) { - return String.format("\"%s\".\"%s\"", schema, table); + return quoteIdentifier(schema, '"') + "." + quoteIdentifier(table, '"'); } @Override diff --git a/cloudsql-postgresql-plugin/src/test/java/io/cdap/plugin/cloudsql/postgres/CloudSQLPostgreSQLConnectorUnitTest.java b/cloudsql-postgresql-plugin/src/test/java/io/cdap/plugin/cloudsql/postgres/CloudSQLPostgreSQLConnectorUnitTest.java new file mode 100644 index 000000000..fa8cb8b6a --- /dev/null +++ b/cloudsql-postgresql-plugin/src/test/java/io/cdap/plugin/cloudsql/postgres/CloudSQLPostgreSQLConnectorUnitTest.java @@ -0,0 +1,54 @@ +/* + * Copyright © 2026 Cask Data, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package io.cdap.plugin.cloudsql.postgres; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Unit tests for {@link CloudSQLPostgreSQLConnector} + */ +public class CloudSQLPostgreSQLConnectorUnitTest { + + private static final CloudSQLPostgreSQLConnector CONNECTOR = new CloudSQLPostgreSQLConnector( + new CloudSQLPostgreSQLConnectorConfig("user", "password", "cloudsql-postgresql", "", "public", + "project:region:instance", "db", null)); + + /** + * Unit test for getTableName() + */ + @Test + public void getTableNameTest() { + Assert.assertEquals("\"schema\".\"table\"", + CONNECTOR.getTableName("db", "schema", "table")); + } + + /** + * Unit test for getTableName() with identifiers containing double quotes, using the payload from the + * reported sample path SQL injection + */ + @Test + public void getTableNameEscapesQuotesTest() { + String table = "pg_class\" LIMIT 0; UPDATE audit_vault.write_marker SET value='INJECTED_BY_SAMPLE_PATH' " + + "WHERE id=1; SELECT * FROM \"pg_catalog\".\"pg_class"; + Assert.assertEquals("\"pg_catalog\".\"pg_class\"\" LIMIT 0; UPDATE audit_vault.write_marker SET " + + "value='INJECTED_BY_SAMPLE_PATH' WHERE id=1; SELECT * FROM \"\"pg_catalog\"\".\"\"pg_class\"", + CONNECTOR.getTableName("db", "pg_catalog", table)); + Assert.assertEquals("\"my\"\"schema\".\"table\"", + CONNECTOR.getTableName("db", "my\"schema", "table")); + } +} diff --git a/database-commons/pom.xml b/database-commons/pom.xml index 98bcb3803..00f7a714d 100644 --- a/database-commons/pom.xml +++ b/database-commons/pom.xml @@ -109,6 +109,11 @@ ${mockito.version} test + + org.hsqldb + hsqldb + test + diff --git a/database-commons/src/main/java/io/cdap/plugin/db/ConnectionConfigAccessor.java b/database-commons/src/main/java/io/cdap/plugin/db/ConnectionConfigAccessor.java index 253422e79..f02daea5e 100644 --- a/database-commons/src/main/java/io/cdap/plugin/db/ConnectionConfigAccessor.java +++ b/database-commons/src/main/java/io/cdap/plugin/db/ConnectionConfigAccessor.java @@ -35,6 +35,7 @@ public class ConnectionConfigAccessor { private static final String CONNECTION_ARGUMENTS = "io.cdap.plugin.db.connection.arguments"; private static final String INIT_QUERIES = "io.cdap.plugin.db.init.queries"; public static final String AUTO_COMMIT_ENABLED = "io.cdap.plugin.db.output.autocommit.enabled"; + public static final String READ_ONLY = "io.cdap.plugin.db.readonly"; public static final String FETCH_SIZE = "io.cdap.plugin.db.fetch.size"; public static final String OPERATION_NAME = "io.cdap.plugin.db.operation.name"; public static final String RELATION_TABLE_KEY = "io.cdap.plugin.db.relation.table.key"; @@ -101,6 +102,14 @@ public boolean isAutoCommitEnabled() { return configuration.getBoolean(AUTO_COMMIT_ENABLED, false); } + public void setReadOnly(boolean readOnly) { + configuration.setBoolean(READ_ONLY, readOnly); + } + + public boolean isReadOnly() { + return configuration.getBoolean(READ_ONLY, false); + } + public void setFetchSize(Integer fetchSize) { configuration.setInt(FETCH_SIZE, fetchSize); } diff --git a/database-commons/src/main/java/io/cdap/plugin/db/RollbackOnCloseConnection.java b/database-commons/src/main/java/io/cdap/plugin/db/RollbackOnCloseConnection.java new file mode 100644 index 000000000..28f0a3c2b --- /dev/null +++ b/database-commons/src/main/java/io/cdap/plugin/db/RollbackOnCloseConnection.java @@ -0,0 +1,55 @@ +/* + * Copyright © 2026 Cask Data, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package io.cdap.plugin.db; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.sql.Connection; +import java.sql.SQLException; + +/** + * A {@link ForwardingConnection} for read-only operations that turns {@link #commit()} into {@link #rollback()} and + * rolls back any active transaction before closing, so Hadoop's {@code DBRecordReader#close()} or an implicit + * driver commit-on-close can never commit changes. + */ +public class RollbackOnCloseConnection extends ForwardingConnection { + + private static final Logger LOG = LoggerFactory.getLogger(RollbackOnCloseConnection.class); + + public RollbackOnCloseConnection(Connection delegate) { + super(delegate); + } + + @Override + public void commit() throws SQLException { + getDelegate().rollback(); + } + + @Override + public void close() throws SQLException { + try { + if (!getDelegate().isClosed() && !getDelegate().getAutoCommit()) { + getDelegate().rollback(); + } + } catch (SQLException e) { + LOG.debug("Failed to roll back read-only connection before close.", e); + } finally { + super.close(); + } + } +} diff --git a/database-commons/src/main/java/io/cdap/plugin/db/connector/AbstractDBSpecificConnector.java b/database-commons/src/main/java/io/cdap/plugin/db/connector/AbstractDBSpecificConnector.java index e0407203b..911dd6c7b 100644 --- a/database-commons/src/main/java/io/cdap/plugin/db/connector/AbstractDBSpecificConnector.java +++ b/database-commons/src/main/java/io/cdap/plugin/db/connector/AbstractDBSpecificConnector.java @@ -41,6 +41,8 @@ import org.apache.hadoop.mapreduce.MRJobConfig; import org.apache.hadoop.mapreduce.lib.db.DBConfiguration; import org.apache.hadoop.mapreduce.lib.db.DBWritable; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import java.io.IOException; import java.sql.Connection; @@ -48,6 +50,7 @@ import java.sql.SQLException; import java.sql.Statement; import java.util.Map; +import java.util.Objects; import java.util.UUID; import javax.annotation.Nullable; @@ -59,6 +62,8 @@ public abstract class AbstractDBSpecificConnector extends AbstractDBConnector implements BatchConnector { + private static final Logger LOG = LoggerFactory.getLogger(AbstractDBSpecificConnector.class); + private final AbstractDBConnectorConfig config; private final RetryPolicy retryPolicy; protected DBErrorDetailsProvider dbErrorDetailsProvider; @@ -105,6 +110,7 @@ public InputFormatProvider getInputFormatProvider(ConnectorContext context, Samp request.getProperties().get("sampleType"), request.getProperties().get("strata"), sessionID); DataDrivenETLDBInputFormat.setInput(connectionConfigAccessor.getConfiguration(), getDBRecordType(), tableQuery, null, isAutoCommitEnabled()); + connectionConfigAccessor.setReadOnly(true); connectionConfigAccessor.setConnectionArguments(Maps.fromProperties(config.getConnectionArgumentsProperties())); String isolationLevel = getTransactionIsolationLevel(); if (isolationLevel != null) { @@ -115,11 +121,11 @@ public InputFormatProvider getInputFormatProvider(ConnectorContext context, Samp for (Map.Entry argument : additionalArguments.entrySet()) { connectionConfigAccessor.getConfiguration().set(argument.getKey(), argument.getValue()); } - try { + try (Connection connection = getConnection(path)) { Long timeoutMs = request.getTimeoutMs(); Integer timeoutSec = timeoutMs != null ? (int) (timeoutMs / 1000) : null; connectionConfigAccessor - .setSchema(loadTableSchema(getConnection(path), tableQuery, timeoutSec, sessionID).toString()); + .setSchema(loadTableSchema(connection, tableQuery, timeoutSec, sessionID).toString()); } catch (SQLException e) { throw new IOException(String.format("Failed to get table schema due to: %s.", ExceptionUtils.getRootCauseMessage(e)), e); @@ -150,8 +156,18 @@ protected String getConnectionString(String database) { } protected String getTableName(String database, String schema, String table) { - return schema == null ? String.format("\"%s\".\"%s\"", database, table) - : String.format("\"%s\".\"%s\".\"%s\"", database, schema, table); + return schema == null ? quoteIdentifier(database, '"') + "." + quoteIdentifier(table, '"') + : quoteIdentifier(database, '"') + "." + quoteIdentifier(schema, '"') + "." + quoteIdentifier(table, '"'); + } + + /** + * Wraps the given identifier in the given quote character, doubling any embedded quote characters so that a + * user supplied database, schema, table or column name can never break out of the quoted identifier. + */ + protected static String quoteIdentifier(String identifier, char quote) { + Objects.requireNonNull(identifier, "identifier to quote must not be null"); + String quoteString = String.valueOf(quote); + return quoteString + identifier.replace(quoteString, quoteString + quoteString) + quoteString; } protected String getTableQuery(String database, String schema, String table) { @@ -197,15 +213,46 @@ protected String getStratifiedQuery(String tableName, int limit, String strata, protected Schema loadTableSchema(Connection connection, String query, @Nullable Integer timeoutSec, String sessionID) throws SQLException { - try (Statement statement = RetryUtils.createStatementWithRetry((RetryPolicy) retryPolicy, connection, - getErrorDetailsProvider())) { - statement.setMaxRows(1); - if (timeoutSec != null) { - statement.setQueryTimeout(timeoutSec); - } - ResultSet resultSet = RetryUtils.executeQueryWithRetry((RetryPolicy) retryPolicy, statement, query, - getErrorDetailsProvider()); + boolean rollbackOnExit = configureReadOnlyTransaction(connection); + try (Statement statement = RetryUtils.createStatementWithRetry((RetryPolicy) retryPolicy, connection, + getErrorDetailsProvider())) { + statement.setMaxRows(1); + if (timeoutSec != null) { + statement.setQueryTimeout(timeoutSec); + } + try (ResultSet resultSet = RetryUtils.executeQueryWithRetry((RetryPolicy) retryPolicy, statement, + query, getErrorDetailsProvider())) { return Schema.recordOf("outputSchema", getSchemaReader(sessionID).getSchemaFields(resultSet)); + } + } finally { + if (rollbackOnExit) { + try { + connection.rollback(); + } catch (SQLException e) { + LOG.debug("Failed to roll back read-only schema query transaction.", e); + } + } + } + } + + private boolean configureReadOnlyTransaction(@Nullable Connection connection) { + if (connection == null) { + return false; + } + try { + connection.setReadOnly(true); + } catch (SQLException e) { + LOG.debug("Driver does not support setting connection read-only; continuing.", e); + } + if (isAutoCommitEnabled()) { + return false; + } + try { + connection.setAutoCommit(false); + return true; + } catch (SQLException e) { + LOG.debug("Driver does not support disabling auto-commit; continuing.", e); + return false; } } @@ -218,8 +265,10 @@ protected void setConnectionProperties(Map properties, Connector protected Schema getTableSchema(Connection connection, String database, String schema, String table) throws SQLException { String sessionID = generateSessionID(); - return loadTableSchema(getConnection(), getTableQuery(database, schema, table), - null, sessionID); + try (Connection schemaConnection = getConnection()) { + return loadTableSchema(schemaConnection, getTableQuery(database, schema, table), + null, sessionID); + } } protected String generateSessionID() { diff --git a/database-commons/src/main/java/io/cdap/plugin/db/source/DataDrivenETLDBInputFormat.java b/database-commons/src/main/java/io/cdap/plugin/db/source/DataDrivenETLDBInputFormat.java index 1a67f09ea..d6f37d49a 100644 --- a/database-commons/src/main/java/io/cdap/plugin/db/source/DataDrivenETLDBInputFormat.java +++ b/database-commons/src/main/java/io/cdap/plugin/db/source/DataDrivenETLDBInputFormat.java @@ -23,6 +23,7 @@ import io.cdap.plugin.db.ConnectionConfigAccessor; import io.cdap.plugin.db.JDBCDriverShim; import io.cdap.plugin.db.NoOpCommitConnection; +import io.cdap.plugin.db.RollbackOnCloseConnection; import io.cdap.plugin.db.TransactionIsolationLevel; import io.cdap.plugin.util.DBUtils; import org.apache.hadoop.conf.Configuration; @@ -154,11 +155,22 @@ public Connection getConnection() { properties.putAll(connectionConfigAccessor.getConnectionArguments()); connection = DriverManager.getConnection(url, properties); + if (connectionConfigAccessor.isReadOnly()) { + try { + connection.setReadOnly(true); + } catch (SQLException e) { + LOG.debug("Driver does not support setting connection read-only; continuing.", e); + } + } + if (connectionConfigAccessor.isAutoCommitEnabled()) { // hack to work around jdbc drivers like the hive driver that throw exceptions on commit this.connection = new NoOpCommitConnection(this.connection); } else { this.connection.setAutoCommit(false); + if (connectionConfigAccessor.isReadOnly()) { + this.connection = new RollbackOnCloseConnection(this.connection); + } } if (connectionConfigAccessor.getFetchSize() > 0) { diff --git a/database-commons/src/test/java/io/cdap/plugin/db/RollbackOnCloseConnectionTest.java b/database-commons/src/test/java/io/cdap/plugin/db/RollbackOnCloseConnectionTest.java new file mode 100644 index 000000000..45c888330 --- /dev/null +++ b/database-commons/src/test/java/io/cdap/plugin/db/RollbackOnCloseConnectionTest.java @@ -0,0 +1,71 @@ +/* + * Copyright © 2026 Cask Data, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package io.cdap.plugin.db; + +import org.junit.Assert; +import org.junit.Test; +import org.mockito.InOrder; +import org.mockito.Mockito; + +import java.sql.Connection; +import java.sql.SQLException; + +/** + * Unit tests for {@link RollbackOnCloseConnection}. + */ +public class RollbackOnCloseConnectionTest { + + @Test + public void commit_delegatesToRollbackInsteadOfCommit() throws SQLException { + Connection delegate = Mockito.mock(Connection.class); + RollbackOnCloseConnection wrapper = new RollbackOnCloseConnection(delegate); + + wrapper.commit(); + + Mockito.verify(delegate).rollback(); + Mockito.verify(delegate, Mockito.never()).commit(); + } + + @Test + public void close_activeTransaction_rollsBackBeforeClose() throws SQLException { + Connection delegate = Mockito.mock(Connection.class); + Mockito.when(delegate.isClosed()).thenReturn(false); + Mockito.when(delegate.getAutoCommit()).thenReturn(false); + RollbackOnCloseConnection wrapper = new RollbackOnCloseConnection(delegate); + + wrapper.close(); + + InOrder inOrder = Mockito.inOrder(delegate); + inOrder.verify(delegate).rollback(); + inOrder.verify(delegate).close(); + Mockito.verify(delegate, Mockito.never()).commit(); + } + + @Test + public void close_rollbackThrows_stillClosesDelegate() throws SQLException { + Connection delegate = Mockito.mock(Connection.class); + Mockito.when(delegate.isClosed()).thenReturn(false); + Mockito.when(delegate.getAutoCommit()).thenReturn(false); + Mockito.doThrow(new SQLException("rollback failed")).when(delegate).rollback(); + RollbackOnCloseConnection wrapper = new RollbackOnCloseConnection(delegate); + + wrapper.close(); + + Mockito.verify(delegate).close(); + Assert.assertNotNull(wrapper.getDelegate()); + } +} diff --git a/database-commons/src/test/java/io/cdap/plugin/db/connector/AbstractDBSpecificConnectorReadOnlyTest.java b/database-commons/src/test/java/io/cdap/plugin/db/connector/AbstractDBSpecificConnectorReadOnlyTest.java new file mode 100644 index 000000000..7e4890d6e --- /dev/null +++ b/database-commons/src/test/java/io/cdap/plugin/db/connector/AbstractDBSpecificConnectorReadOnlyTest.java @@ -0,0 +1,360 @@ +/* + * Copyright © 2026 Cask Data, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package io.cdap.plugin.db.connector; + +import io.cdap.cdap.api.data.batch.InputFormatProvider; +import io.cdap.cdap.api.data.format.StructuredRecord; +import io.cdap.cdap.api.data.schema.Schema; +import io.cdap.cdap.etl.api.connector.ConnectorSpec; +import io.cdap.cdap.etl.api.connector.ConnectorSpecRequest; +import io.cdap.cdap.etl.api.connector.SampleRequest; +import io.cdap.cdap.etl.mock.common.MockConnectorConfigurer; +import io.cdap.cdap.etl.mock.common.MockConnectorContext; +import io.cdap.plugin.common.db.DBConnectorPath; +import io.cdap.plugin.common.db.DBPath; +import io.cdap.plugin.db.DBRecord; +import org.apache.hadoop.conf.Configurable; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.mapreduce.InputFormat; +import org.apache.hadoop.mapreduce.InputSplit; +import org.apache.hadoop.mapreduce.Job; +import org.apache.hadoop.mapreduce.JobID; +import org.apache.hadoop.mapreduce.RecordReader; +import org.apache.hadoop.mapreduce.TaskAttemptContext; +import org.apache.hadoop.mapreduce.TaskAttemptID; +import org.apache.hadoop.mapreduce.TaskID; +import org.apache.hadoop.mapreduce.TaskType; +import org.apache.hadoop.mapreduce.lib.db.DBWritable; +import org.apache.hadoop.mapreduce.task.TaskAttemptContextImpl; +import org.hsqldb.jdbc.JDBCDriver; +import org.junit.Assert; +import org.junit.Test; +import org.mockito.InOrder; +import org.mockito.Mockito; + +import java.io.IOException; +import java.sql.Connection; +import java.sql.Driver; +import java.sql.DriverManager; +import java.sql.ResultSet; +import java.sql.ResultSetMetaData; +import java.sql.SQLException; +import java.sql.SQLFeatureNotSupportedException; +import java.sql.Statement; +import java.sql.Types; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +/** + * Unit and embedded-JDBC tests verifying identifier escaping, read-only transactions, and rollback behavior on + * {@link AbstractDBSpecificConnector}. + */ +public class AbstractDBSpecificConnectorReadOnlyTest { + + @Test + public void loadTableSchema_defaultConnector_setsReadOnlyDisablesAutoCommitAndRollsBack() throws Exception { + Connection connection = Mockito.mock(Connection.class); + Statement statement = Mockito.mock(Statement.class); + ResultSet resultSet = Mockito.mock(ResultSet.class); + ResultSetMetaData metaData = Mockito.mock(ResultSetMetaData.class); + + Mockito.when(connection.createStatement()).thenReturn(statement); + Mockito.when(statement.executeQuery("SELECT * FROM \"db\".\"tbl\"")).thenReturn(resultSet); + Mockito.when(resultSet.getMetaData()).thenReturn(metaData); + Mockito.when(metaData.getColumnCount()).thenReturn(1); + Mockito.when(metaData.getColumnName(1)).thenReturn("id"); + Mockito.when(metaData.getColumnType(1)).thenReturn(Types.INTEGER); + Mockito.when(metaData.getColumnTypeName(1)).thenReturn("INTEGER"); + Mockito.when(metaData.isSigned(1)).thenReturn(true); + Mockito.when(metaData.isNullable(1)).thenReturn(ResultSetMetaData.columnNoNulls); + + StubConnector connector = new StubConnector(connection, false); + Schema schema = connector.loadTableSchema(connection, "SELECT * FROM \"db\".\"tbl\"", 5, "s1"); + Assert.assertNotNull(schema.getField("id")); + + InOrder inOrder = Mockito.inOrder(connection, statement, resultSet); + inOrder.verify(connection).setReadOnly(true); + inOrder.verify(connection).setAutoCommit(false); + inOrder.verify(connection).createStatement(); + inOrder.verify(statement).setMaxRows(1); + inOrder.verify(statement).setQueryTimeout(5); + inOrder.verify(statement).executeQuery("SELECT * FROM \"db\".\"tbl\""); + inOrder.verify(resultSet).close(); + inOrder.verify(statement).close(); + inOrder.verify(connection).rollback(); + Mockito.verify(connection, Mockito.never()).commit(); + } + + @Test + public void loadTableSchema_queryFails_stillRollsBackAndNeverCommits() throws Exception { + Connection connection = Mockito.mock(Connection.class); + Statement statement = Mockito.mock(Statement.class); + Mockito.when(connection.createStatement()).thenReturn(statement); + Mockito.when(statement.executeQuery(Mockito.anyString())) + .thenThrow(new SQLException("Multiple ResultSets were returned by the query.")); + + StubConnector connector = new StubConnector(connection, false); + Assert.assertThrows(RuntimeException.class, + () -> connector.loadTableSchema(connection, "SELECT * FROM \"db\".\"tbl\"", null, "s1")); + + InOrder inOrder = Mockito.inOrder(connection, statement); + inOrder.verify(connection).setReadOnly(true); + inOrder.verify(connection).setAutoCommit(false); + inOrder.verify(statement).executeQuery("SELECT * FROM \"db\".\"tbl\""); + inOrder.verify(statement).close(); + inOrder.verify(connection).rollback(); + Mockito.verify(connection, Mockito.never()).commit(); + } + + @Test + public void loadTableSchema_autoCommitConnectorAndUnsupportedReadOnly_toleratesAndSkipsRollback() throws Exception { + Connection connection = mockConnectionWithSingleIntColumn(); + Mockito.doThrow(new SQLFeatureNotSupportedException("readOnly not supported")).when(connection).setReadOnly(true); + + StubConnector connector = new StubConnector(connection, true); + Schema schema = connector.loadTableSchema(connection, "SELECT * FROM `db`.`tbl`", null, "s1"); + Assert.assertNotNull(schema.getField("id")); + + Mockito.verify(connection).setReadOnly(true); + Mockito.verify(connection, Mockito.never()).setAutoCommit(Mockito.anyBoolean()); + Mockito.verify(connection, Mockito.never()).rollback(); + Mockito.verify(connection, Mockito.never()).commit(); + } + + @Test + public void getInputFormatProvider_andGetTableSchema_closeOpenedConnections() throws Exception { + Connection sampleConnection = mockConnectionWithSingleIntColumn(); + StubConnector connector = new StubConnector(sampleConnection, false); + + SampleRequest request = SampleRequest.builder(10).setPath("db/tbl").build(); + InputFormatProvider provider = + connector.getInputFormatProvider(new MockConnectorContext(new MockConnectorConfigurer()), request); + Assert.assertNotNull(provider); + Mockito.verify(sampleConnection).rollback(); + Mockito.verify(sampleConnection).close(); + + Connection specConnection = mockConnectionWithSingleIntColumn(); + StubConnector specConnector = new StubConnector(specConnection, false); + Schema schema = specConnector.getTableSchema(null, "db", null, "tbl"); + Assert.assertNotNull(schema.getField("id")); + Mockito.verify(specConnection).rollback(); + Mockito.verify(specConnection).close(); + } + + @Test + public void sampleAndGenerateSpec_withQuoteAndStackedUpdateInPath_neverExecutesSecondStatement() throws Exception { + String url = "jdbc:hsqldb:mem:vrp_" + UUID.randomUUID().toString().replace('-', '_'); + try (Connection adminConn = DriverManager.getConnection(url, "SA", ""); + Statement stmt = adminConn.createStatement()) { + stmt.execute("CREATE TABLE \"PUBLIC\".\"target_table\" (\"id\" INT, \"name\" VARCHAR(32))"); + stmt.execute("INSERT INTO \"PUBLIC\".\"target_table\" VALUES (1, 'alice')"); + stmt.execute("CREATE TABLE \"PUBLIC\".\"write_marker\" (\"id\" INT PRIMARY KEY, \"val\" VARCHAR(64))"); + stmt.execute("INSERT INTO \"PUBLIC\".\"write_marker\" VALUES (1, 'ORIGINAL')"); + + HsqldbSchemaConnector connector = new HsqldbSchemaConnector(url); + MockConnectorContext context = new MockConnectorContext(new MockConnectorConfigurer()); + + // Benign path succeeds through both generateSpec and full InputFormat/RecordReader sampling. + ConnectorSpec benignSpec = connector.generateSpec( + context, ConnectorSpecRequest.builder().setPath("/PUBLIC/target_table").setConnection("conn").build()); + Assert.assertNotNull(benignSpec.getSchema().getField("id")); + InputFormatProvider provider = connector.getInputFormatProvider( + context, SampleRequest.builder(10).setPath("/PUBLIC/target_table").build()); + List records = readSampleRecords(connector, provider); + Assert.assertEquals(1, records.size()); + Assert.assertEquals("alice", records.get(0).get("name")); + Assert.assertEquals("ORIGINAL", readMarker(adminConn)); + + // Injection payload with embedded '"' and stacked UPDATE stays inside the quoted identifier and cannot modify DB. + String injectedPath = "/PUBLIC/target_table\" LIMIT 0; " + + "UPDATE \"PUBLIC\".\"write_marker\" SET \"val\"='INJECTED_BY_SAMPLE_PATH' WHERE \"id\"=1; " + + "SELECT * FROM \"PUBLIC\".\"target_table"; + Assert.assertThrows(RuntimeException.class, () -> connector.generateSpec( + context, ConnectorSpecRequest.builder().setPath(injectedPath).setConnection("conn").build())); + Assert.assertThrows(RuntimeException.class, () -> connector.getInputFormatProvider( + context, SampleRequest.builder(10).setPath(injectedPath).build())); + Assert.assertEquals("ORIGINAL", readMarker(adminConn)); + + // Defense-in-depth: even if a write statement were passed directly to loadTableSchema, the read-only + // transaction / rollback backstop prevents any modification from persisting. + try (Connection connectorConn = DriverManager.getConnection(url, "SA", "")) { + String updateSql = "UPDATE \"PUBLIC\".\"write_marker\" SET \"val\"='INJECTED_DIRECT' WHERE \"id\"=1"; + Assert.assertThrows(RuntimeException.class, + () -> connector.loadTableSchema(connectorConn, updateSql, null, "s1")); + } + Assert.assertEquals("ORIGINAL", readMarker(adminConn)); + } finally { + try (Connection cleanup = DriverManager.getConnection(url, "SA", ""); + Statement stmt = cleanup.createStatement()) { + stmt.execute("SHUTDOWN"); + } + } + } + + @SuppressWarnings({"rawtypes", "unchecked"}) + private static List readSampleRecords(HsqldbSchemaConnector connector, + InputFormatProvider provider) throws Exception { + Configuration hConf = new Configuration(); + hConf.setClassLoader(AbstractDBSpecificConnectorReadOnlyTest.class.getClassLoader()); + provider.getInputFormatConfiguration().forEach(hConf::set); + Job job = Job.getInstance(hConf); + job.setJobID(new JobID("sample", 0)); + InputFormat inputFormat = (InputFormat) AbstractDBSpecificConnectorReadOnlyTest.class.getClassLoader() + .loadClass(provider.getInputFormatClassName()).newInstance(); + if (inputFormat instanceof Configurable) { + ((Configurable) inputFormat).setConf(hConf); + } + List splits = inputFormat.getSplits(job); + InputSplit split = splits.get(0); + TaskID taskId = new TaskID(job.getJobID(), TaskType.MAP, 0); + TaskAttemptContext taskContext = new TaskAttemptContextImpl(hConf, new TaskAttemptID(taskId, 0)); + List sample = new ArrayList<>(); + try (RecordReader reader = inputFormat.createRecordReader(split, taskContext)) { + reader.initialize(split, taskContext); + while (reader.nextKeyValue()) { + sample.add(connector.transform(reader.getCurrentKey(), reader.getCurrentValue())); + } + } + return sample; + } + + private static String readMarker(Connection connection) throws SQLException { + try (Statement stmt = connection.createStatement(); + ResultSet rs = stmt.executeQuery("SELECT \"val\" FROM \"PUBLIC\".\"write_marker\" WHERE \"id\" = 1")) { + Assert.assertTrue(rs.next()); + return rs.getString(1); + } + } + + private static Connection mockConnectionWithSingleIntColumn() throws SQLException { + Connection connection = Mockito.mock(Connection.class); + Statement statement = Mockito.mock(Statement.class); + ResultSet resultSet = Mockito.mock(ResultSet.class); + ResultSetMetaData metaData = Mockito.mock(ResultSetMetaData.class); + + Mockito.when(connection.createStatement()).thenReturn(statement); + Mockito.when(statement.executeQuery(Mockito.anyString())).thenReturn(resultSet); + Mockito.when(resultSet.getMetaData()).thenReturn(metaData); + Mockito.when(metaData.getColumnCount()).thenReturn(1); + Mockito.when(metaData.getColumnName(1)).thenReturn("id"); + Mockito.when(metaData.getColumnType(1)).thenReturn(Types.INTEGER); + Mockito.when(metaData.getColumnTypeName(1)).thenReturn("INTEGER"); + Mockito.when(metaData.isSigned(1)).thenReturn(true); + Mockito.when(metaData.isNullable(1)).thenReturn(ResultSetMetaData.columnNoNulls); + return connection; + } + + private static class StubConnectorConfig extends AbstractDBConnectorConfig { + private final String connectionString; + + StubConnectorConfig() { + this("jdbc:stub://localhost:5432/db"); + } + + StubConnectorConfig(String connectionString) { + this.connectionString = connectionString; + this.user = "SA"; + this.password = ""; + } + + @Override + public String getConnectionString() { + return connectionString; + } + + @Override + public Integer getMaxRetryCount() { + return 0; + } + } + + private static class StubConnector extends AbstractDBSpecificConnector { + private final Connection stubConnection; + private final boolean autoCommitEnabled; + + StubConnector(Connection stubConnection, boolean autoCommitEnabled) { + super(new StubConnectorConfig()); + this.driverClass = Driver.class; + this.stubConnection = stubConnection; + this.autoCommitEnabled = autoCommitEnabled; + } + + @Override + public boolean supportSchema() { + return false; + } + + @Override + protected Class getDBRecordType() { + return DBRecord.class; + } + + @Override + public StructuredRecord transform(LongWritable key, DBRecord val) { + return null; + } + + @Override + protected Connection getConnection() { + return stubConnection; + } + + @Override + protected Connection getConnection(DBConnectorPath path) { + return stubConnection; + } + + @Override + protected boolean isAutoCommitEnabled() { + return autoCommitEnabled; + } + } + + private static class HsqldbSchemaConnector extends AbstractDBSpecificConnector { + HsqldbSchemaConnector(String url) { + super(new StubConnectorConfig(url)); + this.driverClass = JDBCDriver.class; + } + + @Override + public boolean supportSchema() { + return true; + } + + @Override + protected DBConnectorPath getDBConnectorPath(String path) throws IOException { + return new DBPath(path, true); + } + + @Override + protected String getTableName(String database, String schema, String table) { + return quoteIdentifier(schema, '"') + "." + quoteIdentifier(table, '"'); + } + + @Override + protected Class getDBRecordType() { + return DBRecord.class; + } + + @Override + public StructuredRecord transform(LongWritable key, DBRecord val) { + return val.getRecord(); + } + } +} diff --git a/database-commons/src/test/java/io/cdap/plugin/db/connector/QuoteIdentifierTest.java b/database-commons/src/test/java/io/cdap/plugin/db/connector/QuoteIdentifierTest.java new file mode 100644 index 000000000..f92c59c2e --- /dev/null +++ b/database-commons/src/test/java/io/cdap/plugin/db/connector/QuoteIdentifierTest.java @@ -0,0 +1,52 @@ +/* + * Copyright © 2026 Cask Data, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package io.cdap.plugin.db.connector; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Unit tests for {@link AbstractDBSpecificConnector#quoteIdentifier(String, char)} + */ +public class QuoteIdentifierTest { + + @Test + public void testPlainIdentifier() { + Assert.assertEquals("\"table\"", AbstractDBSpecificConnector.quoteIdentifier("table", '"')); + Assert.assertEquals("`table`", AbstractDBSpecificConnector.quoteIdentifier("table", '`')); + } + + @Test + public void testEmbeddedQuotesAreDoubled() { + Assert.assertEquals("\"my\"\"table\"", AbstractDBSpecificConnector.quoteIdentifier("my\"table", '"')); + Assert.assertEquals("`my``table`", AbstractDBSpecificConnector.quoteIdentifier("my`table", '`')); + Assert.assertEquals("\"\"\"\"\"\"", AbstractDBSpecificConnector.quoteIdentifier("\"\"", '"')); + } + + @Test + public void testOtherQuoteCharacterIsLeftAsIs() { + Assert.assertEquals("\"my`table\"", AbstractDBSpecificConnector.quoteIdentifier("my`table", '"')); + Assert.assertEquals("`my\"table`", AbstractDBSpecificConnector.quoteIdentifier("my\"table", '`')); + } + + @Test + public void testInjectionPayloadStaysInsideIdentifier() { + String payload = "pg_class\" LIMIT 0; UPDATE t SET v='x' WHERE id=1; SELECT * FROM \"pg_class"; + Assert.assertEquals("\"pg_class\"\" LIMIT 0; UPDATE t SET v='x' WHERE id=1; SELECT * FROM \"\"pg_class\"", + AbstractDBSpecificConnector.quoteIdentifier(payload, '"')); + } +} diff --git a/database-commons/src/test/java/io/cdap/plugin/db/source/DataDrivenETLDBInputFormatTest.java b/database-commons/src/test/java/io/cdap/plugin/db/source/DataDrivenETLDBInputFormatTest.java index a07d0dee5..a24b08d8d 100644 --- a/database-commons/src/test/java/io/cdap/plugin/db/source/DataDrivenETLDBInputFormatTest.java +++ b/database-commons/src/test/java/io/cdap/plugin/db/source/DataDrivenETLDBInputFormatTest.java @@ -150,6 +150,7 @@ public void testDefaultConnectorInputFormatConfiguration() throws IOException { Map conf = provider.getInputFormatConfiguration(); Assert.assertEquals("false", conf.get(ConnectionConfigAccessor.AUTO_COMMIT_ENABLED)); + Assert.assertEquals("true", conf.get(ConnectionConfigAccessor.READ_ONLY)); Assert.assertNull(conf.get(TransactionIsolationLevel.CONF_KEY)); } @@ -173,6 +174,7 @@ protected String getTransactionIsolationLevel() { Map conf = provider.getInputFormatConfiguration(); Assert.assertEquals("true", conf.get(ConnectionConfigAccessor.AUTO_COMMIT_ENABLED)); + Assert.assertEquals("true", conf.get(ConnectionConfigAccessor.READ_ONLY)); Assert.assertEquals(TransactionIsolationLevel.Level.TRANSACTION_READ_UNCOMMITTED.name(), conf.get(TransactionIsolationLevel.CONF_KEY)); } diff --git a/databricks-plugin/src/main/java/io/cdap/plugin/databricks/DatabricksConnector.java b/databricks-plugin/src/main/java/io/cdap/plugin/databricks/DatabricksConnector.java index c78ceca6f..e13369b85 100644 --- a/databricks-plugin/src/main/java/io/cdap/plugin/databricks/DatabricksConnector.java +++ b/databricks-plugin/src/main/java/io/cdap/plugin/databricks/DatabricksConnector.java @@ -45,6 +45,9 @@ import java.sql.SQLException; import java.util.HashMap; import java.util.Map; +import java.util.Objects; +import java.util.stream.Collectors; +import java.util.stream.Stream; /** * Databricks Database Connector that connects to Databricks database via JDBC. @@ -115,16 +118,10 @@ protected SchemaReader getSchemaReader(String sessionID) { @Override protected String getTableName(String database, String schema, String table) { - if (database == null && schema == null) { - return String.format("`%s`", table); - } - if (database == null) { - return String.format("`%s`.`%s`", schema, table); - } - if (schema == null) { - return String.format("`%s`.`%s`", database, table); - } - return String.format("`%s`.`%s`.`%s`", database, schema, table); + return Stream.of(database, schema, table) + .filter(Objects::nonNull) + .map(part -> quoteIdentifier(part, '`')) + .collect(Collectors.joining(".")); } @Override @@ -136,6 +133,7 @@ protected String getRandomQuery(String tableName, int limit) { @Override protected String getStratifiedQuery(String tableName, int limit, String strata, String sessionID) { + String strataColumn = quoteIdentifier(strata, '`'); return String.format("WITH t_%s AS (\n" + " SELECT *,\n" + " ROW_NUMBER() OVER (ORDER BY %s, RAND()) AS sqn_%s,\n" + @@ -146,8 +144,8 @@ protected String getStratifiedQuery(String tableName, int limit, String strata, "WHERE MOD(sqn_%s, GREATEST(1, CAST(c_%s / %d AS BIGINT))) = 1\n" + "ORDER BY %s\n" + "LIMIT %d", - sessionID, strata, sessionID, sessionID, tableName, sessionID, sessionID, sessionID, - limit, strata, limit); + sessionID, strataColumn, sessionID, sessionID, tableName, sessionID, sessionID, sessionID, + limit, strataColumn, limit); } @Override diff --git a/databricks-plugin/src/test/java/io/cdap/plugin/databricks/DatabricksConnectorUnitTest.java b/databricks-plugin/src/test/java/io/cdap/plugin/databricks/DatabricksConnectorUnitTest.java index a04dfb398..d97ec4e38 100644 --- a/databricks-plugin/src/test/java/io/cdap/plugin/databricks/DatabricksConnectorUnitTest.java +++ b/databricks-plugin/src/test/java/io/cdap/plugin/databricks/DatabricksConnectorUnitTest.java @@ -38,6 +38,21 @@ public void testGetTableName() { CONNECTOR.getTableName(null, null, "my_table")); } + @Test + public void testGetTableNameEscapesBackticks() { + Assert.assertEquals("`main`.`default`.`t``; DELETE FROM x; --`", + CONNECTOR.getTableName("main", "default", "t`; DELETE FROM x; --")); + Assert.assertEquals("`my``schema`.`my``table`", + CONNECTOR.getTableName(null, "my`schema", "my`table")); + } + + @Test + public void testGetStratifiedQueryEscapesStrata() { + String query = CONNECTOR.getStratifiedQuery("`main`.`default`.`my_table`", 10, "id`; DROP TABLE t; --", "s1"); + Assert.assertTrue(query, query.contains("ORDER BY `id``; DROP TABLE t; --`, RAND()")); + Assert.assertTrue(query, query.contains("ORDER BY `id``; DROP TABLE t; --`\n")); + } + @Test public void testGetRandomQuery() { Assert.assertEquals("SELECT * FROM `main`.`default`.`my_table`\n" + @@ -49,13 +64,13 @@ public void testGetRandomQuery() { public void testGetStratifiedQuery() { Assert.assertEquals("WITH t_s1 AS (\n" + " SELECT *,\n" + - " ROW_NUMBER() OVER (ORDER BY id, RAND()) AS sqn_s1,\n" + + " ROW_NUMBER() OVER (ORDER BY `id`, RAND()) AS sqn_s1,\n" + " COUNT(*) OVER () AS c_s1\n" + " FROM `main`.`default`.`my_table`\n" + " )\n" + "SELECT * FROM t_s1\n" + "WHERE MOD(sqn_s1, GREATEST(1, CAST(c_s1 / 10 AS BIGINT))) = 1\n" + - "ORDER BY id\n" + + "ORDER BY `id`\n" + "LIMIT 10", CONNECTOR.getStratifiedQuery("`main`.`default`.`my_table`", 10, "id", "s1")); } diff --git a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerAction.java b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerAction.java index 62c7b9252..6d7da91a2 100644 --- a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerAction.java +++ b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerAction.java @@ -125,7 +125,7 @@ public Map getDBSpecificArguments() { @Override public List getInitQueries() { if (!Strings.isNullOrEmpty(currentLanguage)) { - return Collections.singletonList(String.format(SqlServerConstants.SET_LANGUAGE_QUERY_FORMAT, currentLanguage)); + return Collections.singletonList(SqlServerConstants.buildSetLanguageQuery(currentLanguage)); } return Collections.emptyList(); diff --git a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerConnector.java b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerConnector.java index 7e86d97ce..4f3ba8963 100644 --- a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerConnector.java +++ b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerConnector.java @@ -117,7 +117,8 @@ public StructuredRecord transform(LongWritable longWritable, SqlServerSourceDBRe @Override protected String getTableName(String database, String schema, String table) { - return String.format("\"%s\".\"%s\".\"%s\"", database, schema, table); + return quoteIdentifier(database, '"') + "." + quoteIdentifier(schema, '"') + "." + + quoteIdentifier(table, '"'); } @Override @@ -137,6 +138,7 @@ protected String getRandomQuery(String tableName, int limit) { @Override protected String getStratifiedQuery(String tableName, int limit, String strata, String sessionID) { + String strataColumn = quoteIdentifier(strata, '"'); return String.format("WITH t_%s AS (\n" + " SELECT *,\n" + " ROW_NUMBER() OVER (ORDER BY %s, RAND()) AS sqn_%s,\n" + @@ -146,8 +148,8 @@ protected String getStratifiedQuery(String tableName, int limit, String strata, "SELECT TOP %d * FROM t_%s\n" + "WHERE sqn_%s %% CAST(0.5 * ((c_%s / %d + 1) + ABS(c_%s / %d - 1)) AS bigint) = 1\n" + "ORDER BY %s", - sessionID, strata, sessionID, sessionID, tableName, limit, sessionID, sessionID, sessionID, - limit, sessionID, limit, strata); + sessionID, strataColumn, sessionID, sessionID, tableName, limit, sessionID, sessionID, + sessionID, limit, sessionID, limit, strataColumn); } @Override diff --git a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerConstants.java b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerConstants.java index faa6a7fb0..62402663b 100644 --- a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerConstants.java +++ b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerConstants.java @@ -208,4 +208,13 @@ private SqlServerConstants() { */ public static final String SET_LANGUAGE_QUERY_FORMAT = "SET LANGUAGE '%s';"; + /** + * Builds the {@code SET LANGUAGE} initialization query, doubling any embedded single quotes so that a + * user-supplied language value cannot break out of the string literal. Unlike MySQL, SQL Server string literals + * treat backslashes as ordinary characters, so only single quotes need to be doubled. + */ + public static String buildSetLanguageQuery(String currentLanguage) { + return String.format(SET_LANGUAGE_QUERY_FORMAT, currentLanguage.replace("'", "''")); + } + } diff --git a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerPostAction.java b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerPostAction.java index 6540223ed..bf806d219 100644 --- a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerPostAction.java +++ b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerPostAction.java @@ -125,7 +125,7 @@ public Map getDBSpecificArguments() { @Override public List getInitQueries() { if (!Strings.isNullOrEmpty(currentLanguage)) { - return Collections.singletonList(String.format(SqlServerConstants.SET_LANGUAGE_QUERY_FORMAT, currentLanguage)); + return Collections.singletonList(SqlServerConstants.buildSetLanguageQuery(currentLanguage)); } return Collections.emptyList(); diff --git a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerSink.java b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerSink.java index 00b627139..0f5d31a26 100644 --- a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerSink.java +++ b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerSink.java @@ -206,7 +206,7 @@ protected SqlServerConnectorConfig getConnection() { @Override public List getInitQueries() { if (!Strings.isNullOrEmpty(currentLanguage)) { - return Collections.singletonList(String.format(SqlServerConstants.SET_LANGUAGE_QUERY_FORMAT, currentLanguage)); + return Collections.singletonList(SqlServerConstants.buildSetLanguageQuery(currentLanguage)); } return Collections.emptyList(); diff --git a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerSource.java b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerSource.java index d8d4cf39e..db1970549 100644 --- a/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerSource.java +++ b/mssql-plugin/src/main/java/io/cdap/plugin/mssql/SqlServerSource.java @@ -196,7 +196,7 @@ protected AbstractDBSpecificConnectorConfig getConnection() { @Override public List getInitQueries() { if (!Strings.isNullOrEmpty(currentLanguage)) { - return Collections.singletonList(String.format(SqlServerConstants.SET_LANGUAGE_QUERY_FORMAT, currentLanguage)); + return Collections.singletonList(SqlServerConstants.buildSetLanguageQuery(currentLanguage)); } return Collections.emptyList(); diff --git a/mssql-plugin/src/test/java/io/cdap/plugin/mssql/SqlServerConnectorUnitTest.java b/mssql-plugin/src/test/java/io/cdap/plugin/mssql/SqlServerConnectorUnitTest.java index 0163cd55e..493e2f0e5 100644 --- a/mssql-plugin/src/test/java/io/cdap/plugin/mssql/SqlServerConnectorUnitTest.java +++ b/mssql-plugin/src/test/java/io/cdap/plugin/mssql/SqlServerConnectorUnitTest.java @@ -34,6 +34,27 @@ public class SqlServerConnectorUnitTest { // private static final SqlServerConnector CONNECTOR = new SqlServerConnector(new SqlServerConnectorConfig()); + /** + * Unit test for getTableName() with identifiers containing double quotes + */ + @Test + public void getTableNameEscapesQuotesTest() { + Assert.assertEquals("\"db\".\"dbo\".\"t\"\"; DELETE FROM x; --\"", + CONNECTOR.getTableName("db", "dbo", "t\"; DELETE FROM x; --")); + Assert.assertEquals("\"my\"\"db\".\"my\"\"schema\".\"my\"\"table\"", + CONNECTOR.getTableName("my\"db", "my\"schema", "my\"table")); + } + + /** + * Unit test for getStratifiedQuery() with a strata column containing double quotes + */ + @Test + public void getStratifiedQueryEscapesStrataTest() { + String query = CONNECTOR.getStratifiedQuery("\"db\".\"dbo\".\"table\"", 10, "id\"; DROP TABLE t; --", "s1"); + Assert.assertTrue(query, query.contains("ORDER BY \"id\"\"; DROP TABLE t; --\", RAND()")); + Assert.assertTrue(query, query.endsWith("ORDER BY \"id\"\"; DROP TABLE t; --\"")); + } + /** * Unit tests for getTableQuery() */ diff --git a/mssql-plugin/src/test/java/io/cdap/plugin/mssql/SqlServerInitQueriesUnitTest.java b/mssql-plugin/src/test/java/io/cdap/plugin/mssql/SqlServerInitQueriesUnitTest.java new file mode 100644 index 000000000..d5ff200ec --- /dev/null +++ b/mssql-plugin/src/test/java/io/cdap/plugin/mssql/SqlServerInitQueriesUnitTest.java @@ -0,0 +1,97 @@ +/* + * Copyright © 2026 Cask Data, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package io.cdap.plugin.mssql; + +import org.junit.Assert; +import org.junit.Test; + +import java.util.Collections; + +/** + * Unit tests for {@code getInitQueries()} escaping across SQL Server plugin configs. + */ +public class SqlServerInitQueriesUnitTest { + + @Test + public void getInitQueries_emptyOrNullLanguage_returnsEmptyList() { + SqlServerSource.SqlServerSourceConfig sourceConfig = new SqlServerSource.SqlServerSourceConfig(); + SqlServerSink.SqlServerSinkConfig sinkConfig = new SqlServerSink.SqlServerSinkConfig(); + SqlServerAction.SqlServerActionConfig actionConfig = new SqlServerAction.SqlServerActionConfig(); + SqlServerPostAction.SqlServerQueryActionConfig postActionConfig = + new SqlServerPostAction.SqlServerQueryActionConfig(); + + Assert.assertEquals(Collections.emptyList(), sourceConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), sinkConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), actionConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), postActionConfig.getInitQueries()); + + sourceConfig.currentLanguage = ""; + sinkConfig.currentLanguage = ""; + actionConfig.currentLanguage = ""; + postActionConfig.currentLanguage = ""; + + Assert.assertEquals(Collections.emptyList(), sourceConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), sinkConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), actionConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), postActionConfig.getInitQueries()); + } + + @Test + public void getInitQueries_plainLanguage_formatsSetLanguageStatement() { + String expected = "SET LANGUAGE 'us_english';"; + + SqlServerSource.SqlServerSourceConfig sourceConfig = new SqlServerSource.SqlServerSourceConfig(); + sourceConfig.currentLanguage = "us_english"; + Assert.assertEquals(Collections.singletonList(expected), sourceConfig.getInitQueries()); + + SqlServerSink.SqlServerSinkConfig sinkConfig = new SqlServerSink.SqlServerSinkConfig(); + sinkConfig.currentLanguage = "us_english"; + Assert.assertEquals(Collections.singletonList(expected), sinkConfig.getInitQueries()); + + SqlServerAction.SqlServerActionConfig actionConfig = new SqlServerAction.SqlServerActionConfig(); + actionConfig.currentLanguage = "us_english"; + Assert.assertEquals(Collections.singletonList(expected), actionConfig.getInitQueries()); + + SqlServerPostAction.SqlServerQueryActionConfig postActionConfig = + new SqlServerPostAction.SqlServerQueryActionConfig(); + postActionConfig.currentLanguage = "us_english"; + Assert.assertEquals(Collections.singletonList(expected), postActionConfig.getInitQueries()); + } + + @Test + public void getInitQueries_quotesAndBackslashes_doublesSingleQuotesOnly() { + String payload = "us_english\\'; UPDATE t SET v = 'x'; --"; + String expected = "SET LANGUAGE 'us_english\\''; UPDATE t SET v = ''x''; --';"; + + SqlServerSource.SqlServerSourceConfig sourceConfig = new SqlServerSource.SqlServerSourceConfig(); + sourceConfig.currentLanguage = payload; + Assert.assertEquals(Collections.singletonList(expected), sourceConfig.getInitQueries()); + + SqlServerSink.SqlServerSinkConfig sinkConfig = new SqlServerSink.SqlServerSinkConfig(); + sinkConfig.currentLanguage = payload; + Assert.assertEquals(Collections.singletonList(expected), sinkConfig.getInitQueries()); + + SqlServerAction.SqlServerActionConfig actionConfig = new SqlServerAction.SqlServerActionConfig(); + actionConfig.currentLanguage = payload; + Assert.assertEquals(Collections.singletonList(expected), actionConfig.getInitQueries()); + + SqlServerPostAction.SqlServerQueryActionConfig postActionConfig = + new SqlServerPostAction.SqlServerQueryActionConfig(); + postActionConfig.currentLanguage = payload; + Assert.assertEquals(Collections.singletonList(expected), postActionConfig.getInitQueries()); + } +} diff --git a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlAction.java b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlAction.java index c8433b92e..f7955a995 100644 --- a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlAction.java +++ b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlAction.java @@ -115,7 +115,7 @@ public List getInitQueries() { initQueries.add(MysqlConstants.ANSI_QUOTES_QUERY); } if (!Strings.isNullOrEmpty(sqlMode)) { - initQueries.add(String.format(MysqlConstants.SET_SQL_MODE_QUERY_FORMAT, sqlMode)); + initQueries.add(MysqlConstants.buildSetSqlModeQuery(sqlMode)); } return initQueries; } diff --git a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlConnector.java b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlConnector.java index 214d8650e..0f854bc88 100644 --- a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlConnector.java +++ b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlConnector.java @@ -98,7 +98,7 @@ protected void setConnectorSpec(ConnectorSpecRequest request, DBConnectorPath pa @Override protected String getTableName(String database, String schema, String table) { - return String.format("`%s`.`%s`", database, table); + return quoteIdentifier(database, '`') + "." + quoteIdentifier(table, '`'); } @Override @@ -112,6 +112,7 @@ protected String getRandomQuery(String tableName, int limit) { @Override protected String getStratifiedQuery(String tableName, int limit, String strata, String sessionID) { + String strataColumn = quoteIdentifier(strata, '`'); return String.format("WITH t_%s AS (\n" + " SELECT *,\n" + " ROW_NUMBER() OVER (ORDER BY %s, RAND()) AS sqn_%s,\n" + @@ -122,8 +123,8 @@ protected String getStratifiedQuery(String tableName, int limit, String strata, "WHERE MOD(sqn_%s, GREATEST(1, CAST(c_%s / %d AS UNSIGNED))) = 1\n" + "ORDER BY %s\n" + "LIMIT %d", - sessionID, strata, sessionID, sessionID, tableName, sessionID, sessionID, sessionID, - limit, strata, limit); + sessionID, strataColumn, sessionID, sessionID, tableName, sessionID, sessionID, sessionID, + limit, strataColumn, limit); } @Override diff --git a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlConstants.java b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlConstants.java index a73e14e9f..3fea43949 100644 --- a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlConstants.java +++ b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlConstants.java @@ -56,4 +56,13 @@ private MysqlConstants() { * Query to append 'ANSI_QUOTES' sql mode to the current value of SQL_MODE system variable. */ public static final String ANSI_QUOTES_QUERY = "SET SESSION sql_mode = (CONCAT(@@sql_mode , ',', 'ANSI_QUOTES'));"; + + /** + * Builds the {@code SET SESSION sql_mode} initialization query, escaping backslashes and single quotes so that a + * user-supplied mode value cannot break out of the string literal. Unlike SQL Server, MySQL treats a backslash as + * an escape character inside string literals by default, so backslashes are doubled before single quotes are doubled. + */ + public static String buildSetSqlModeQuery(String sqlMode) { + return String.format(SET_SQL_MODE_QUERY_FORMAT, sqlMode.replace("\\", "\\\\").replace("'", "''")); + } } diff --git a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlPostAction.java b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlPostAction.java index 6ae62a3cf..9b3cd3990 100644 --- a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlPostAction.java +++ b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlPostAction.java @@ -115,7 +115,7 @@ public List getInitQueries() { initQueries.add(MysqlConstants.ANSI_QUOTES_QUERY); } if (!Strings.isNullOrEmpty(sqlMode)) { - initQueries.add(String.format(MysqlConstants.SET_SQL_MODE_QUERY_FORMAT, sqlMode)); + initQueries.add(MysqlConstants.buildSetSqlModeQuery(sqlMode)); } return initQueries; } diff --git a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlSink.java b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlSink.java index 6487ffae6..32b6e6c8e 100644 --- a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlSink.java +++ b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlSink.java @@ -217,7 +217,7 @@ public void validate(FailureCollector collector) { @Override public List getInitQueries() { if (!Strings.isNullOrEmpty(sqlMode)) { - return Collections.singletonList(String.format(MysqlConstants.SET_SQL_MODE_QUERY_FORMAT, sqlMode)); + return Collections.singletonList(MysqlConstants.buildSetSqlModeQuery(sqlMode)); } return Collections.emptyList(); } diff --git a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlSource.java b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlSource.java index d7d7c400b..c3e7f479b 100644 --- a/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlSource.java +++ b/mysql-plugin/src/main/java/io/cdap/plugin/mysql/MysqlSource.java @@ -191,7 +191,7 @@ public List getInitQueries() { initQueries.add(MysqlConstants.ANSI_QUOTES_QUERY); } if (!Strings.isNullOrEmpty(sqlMode)) { - initQueries.add(String.format(MysqlConstants.SET_SQL_MODE_QUERY_FORMAT, sqlMode)); + initQueries.add(MysqlConstants.buildSetSqlModeQuery(sqlMode)); } return initQueries; } diff --git a/mysql-plugin/src/test/java/io/cdap/plugin/mysql/MysqlConnectorUnitTest.java b/mysql-plugin/src/test/java/io/cdap/plugin/mysql/MysqlConnectorUnitTest.java index df731d194..d9d0d1717 100644 --- a/mysql-plugin/src/test/java/io/cdap/plugin/mysql/MysqlConnectorUnitTest.java +++ b/mysql-plugin/src/test/java/io/cdap/plugin/mysql/MysqlConnectorUnitTest.java @@ -42,6 +42,25 @@ public void getTableNameTest() { CONNECTOR.getTableName("db", "schema", "table")); } + /** + * Unit test for getTableName() with identifiers containing backticks + */ + @Test + public void getTableNameEscapesBackticksTest() { + Assert.assertEquals("`my``db`.`t``; DELETE FROM x; --`", + CONNECTOR.getTableName("my`db", "schema", "t`; DELETE FROM x; --")); + } + + /** + * Unit test for getStratifiedQuery() with a strata column containing backticks + */ + @Test + public void getStratifiedQueryEscapesStrataTest() { + String query = CONNECTOR.getStratifiedQuery("`db`.`table`", 10, "id`; DROP TABLE t; --", "s1"); + Assert.assertTrue(query, query.contains("ORDER BY `id``; DROP TABLE t; --`, RAND()")); + Assert.assertTrue(query, query.contains("ORDER BY `id``; DROP TABLE t; --`\n")); + } + /** * Unit tests for getTableQuery() */ diff --git a/mysql-plugin/src/test/java/io/cdap/plugin/mysql/MysqlInitQueriesUnitTest.java b/mysql-plugin/src/test/java/io/cdap/plugin/mysql/MysqlInitQueriesUnitTest.java new file mode 100644 index 000000000..e9151a420 --- /dev/null +++ b/mysql-plugin/src/test/java/io/cdap/plugin/mysql/MysqlInitQueriesUnitTest.java @@ -0,0 +1,104 @@ +/* + * Copyright © 2026 Cask Data, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy of + * the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations under + * the License. + */ + +package io.cdap.plugin.mysql; + +import org.junit.Assert; +import org.junit.Test; + +import java.util.Arrays; +import java.util.Collections; + +/** + * Unit tests for {@code getInitQueries()} escaping across MySQL plugin configs. + */ +public class MysqlInitQueriesUnitTest { + + @Test + public void getInitQueries_emptyOrNullSqlMode_returnsEmptyList() { + MysqlSource.MysqlSourceConfig sourceConfig = new MysqlSource.MysqlSourceConfig(); + MysqlSink.MysqlSinkConfig sinkConfig = new MysqlSink.MysqlSinkConfig(); + MysqlAction.MysqlActionConfig actionConfig = new MysqlAction.MysqlActionConfig(); + MysqlPostAction.MysqlQueryActionConfig postActionConfig = + new MysqlPostAction.MysqlQueryActionConfig(); + + Assert.assertEquals(Collections.emptyList(), sourceConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), sinkConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), actionConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), postActionConfig.getInitQueries()); + + sourceConfig.sqlMode = ""; + sinkConfig.sqlMode = ""; + actionConfig.sqlMode = ""; + postActionConfig.sqlMode = ""; + + Assert.assertEquals(Collections.emptyList(), sourceConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), sinkConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), actionConfig.getInitQueries()); + Assert.assertEquals(Collections.emptyList(), postActionConfig.getInitQueries()); + } + + @Test + public void getInitQueries_plainSqlModeAndAnsiQuotes_formatsInitQueries() { + String expectedSqlMode = "SET SESSION sql_mode = 'STRICT_TRANS_TABLES,NO_ZERO_DATE';"; + + MysqlSource.MysqlSourceConfig sourceConfig = new MysqlSource.MysqlSourceConfig(); + sourceConfig.useAnsiQuotes = true; + sourceConfig.sqlMode = "STRICT_TRANS_TABLES,NO_ZERO_DATE"; + Assert.assertEquals(Arrays.asList(MysqlConstants.ANSI_QUOTES_QUERY, expectedSqlMode), + sourceConfig.getInitQueries()); + + MysqlSink.MysqlSinkConfig sinkConfig = new MysqlSink.MysqlSinkConfig(); + sinkConfig.sqlMode = "STRICT_TRANS_TABLES,NO_ZERO_DATE"; + Assert.assertEquals(Collections.singletonList(expectedSqlMode), sinkConfig.getInitQueries()); + + MysqlAction.MysqlActionConfig actionConfig = new MysqlAction.MysqlActionConfig(); + actionConfig.useAnsiQuotes = true; + actionConfig.sqlMode = "STRICT_TRANS_TABLES,NO_ZERO_DATE"; + Assert.assertEquals(Arrays.asList(MysqlConstants.ANSI_QUOTES_QUERY, expectedSqlMode), + actionConfig.getInitQueries()); + + MysqlPostAction.MysqlQueryActionConfig postActionConfig = + new MysqlPostAction.MysqlQueryActionConfig(); + postActionConfig.useAnsiQuotes = true; + postActionConfig.sqlMode = "STRICT_TRANS_TABLES,NO_ZERO_DATE"; + Assert.assertEquals(Arrays.asList(MysqlConstants.ANSI_QUOTES_QUERY, expectedSqlMode), + postActionConfig.getInitQueries()); + } + + @Test + public void getInitQueries_quotesAndBackslashes_escapesBackslashesBeforeQuotes() { + String payload = "TRADITIONAL\\'; DELETE FROM t; --"; + String expected = "SET SESSION sql_mode = 'TRADITIONAL\\\\''; DELETE FROM t; --';"; + + MysqlSource.MysqlSourceConfig sourceConfig = new MysqlSource.MysqlSourceConfig(); + sourceConfig.sqlMode = payload; + Assert.assertEquals(Collections.singletonList(expected), sourceConfig.getInitQueries()); + + MysqlSink.MysqlSinkConfig sinkConfig = new MysqlSink.MysqlSinkConfig(); + sinkConfig.sqlMode = payload; + Assert.assertEquals(Collections.singletonList(expected), sinkConfig.getInitQueries()); + + MysqlAction.MysqlActionConfig actionConfig = new MysqlAction.MysqlActionConfig(); + actionConfig.sqlMode = payload; + Assert.assertEquals(Collections.singletonList(expected), actionConfig.getInitQueries()); + + MysqlPostAction.MysqlQueryActionConfig postActionConfig = + new MysqlPostAction.MysqlQueryActionConfig(); + postActionConfig.sqlMode = payload; + Assert.assertEquals(Collections.singletonList(expected), postActionConfig.getInitQueries()); + } +} diff --git a/oracle-plugin/src/main/java/io/cdap/plugin/oracle/OracleConnector.java b/oracle-plugin/src/main/java/io/cdap/plugin/oracle/OracleConnector.java index 469ca45f2..a59c0688e 100644 --- a/oracle-plugin/src/main/java/io/cdap/plugin/oracle/OracleConnector.java +++ b/oracle-plugin/src/main/java/io/cdap/plugin/oracle/OracleConnector.java @@ -135,7 +135,7 @@ protected String getConnectionString(@Nullable String database) { @Override protected String getTableName(String database, String schema, String table) { - return String.format("\"%s\".\"%s\"", schema, table); + return quoteIdentifier(schema, '"') + "." + quoteIdentifier(table, '"'); } @Override @@ -157,6 +157,7 @@ protected String getRandomQuery(String tableName, int limit) { @Override protected String getStratifiedQuery(String tableName, int limit, String strata, String sessionID) { + String strataColumn = quoteIdentifier(strata, '"'); return String.format("WITH t_%s AS (\n" + " SELECT %s.*,\n" + " ROW_NUMBER() OVER (ORDER BY %s, dbms_random.random) AS s_%s,\n" + @@ -166,8 +167,8 @@ protected String getStratifiedQuery(String tableName, int limit, String strata, " )\n" + "SELECT * FROM t_%s\n" + "WHERE MOD(s_%s, GREATEST(1, CAST(c_%s / %d AS INTEGER))) = 1 AND ROWNUM <= %d", - sessionID, tableName, strata, sessionID, tableName, sessionID, tableName, - strata, sessionID, sessionID, sessionID, limit, limit); + sessionID, tableName, strataColumn, sessionID, tableName, sessionID, tableName, + strataColumn, sessionID, sessionID, sessionID, limit, limit); } @Override diff --git a/oracle-plugin/src/test/java/io/cdap/plugin/oracle/OracleConnectorUnitTest.java b/oracle-plugin/src/test/java/io/cdap/plugin/oracle/OracleConnectorUnitTest.java index f89a6c1d7..c73eea17f 100644 --- a/oracle-plugin/src/test/java/io/cdap/plugin/oracle/OracleConnectorUnitTest.java +++ b/oracle-plugin/src/test/java/io/cdap/plugin/oracle/OracleConnectorUnitTest.java @@ -37,6 +37,25 @@ public void getTableNameTest() { CONNECTOR.getTableName("db", "schema", "table")); } + /** + * Unit test for getTableName() with identifiers containing double quotes + */ + @Test + public void getTableNameEscapesQuotesTest() { + Assert.assertEquals("\"MY\"\"SCHEMA\".\"T\"\" WHERE 1=1 --\"", + CONNECTOR.getTableName("db", "MY\"SCHEMA", "T\" WHERE 1=1 --")); + } + + /** + * Unit test for getStratifiedQuery() with a strata column containing double quotes + */ + @Test + public void getStratifiedQueryEscapesStrataTest() { + String query = CONNECTOR.getStratifiedQuery("\"SCHEMA\".\"TABLE\"", 10, "ID\", 1) --", "s1"); + Assert.assertTrue(query, query.contains("ORDER BY \"ID\"\", 1) --\", dbms_random.random")); + Assert.assertTrue(query, query.contains("ORDER BY \"ID\"\", 1) --\" )")); + } + /** * Unit tests for getTableQuery() */ diff --git a/postgresql-plugin/src/main/java/io/cdap/plugin/postgres/PostgresConnector.java b/postgresql-plugin/src/main/java/io/cdap/plugin/postgres/PostgresConnector.java index 5b23ce6cd..4ad703b61 100644 --- a/postgresql-plugin/src/main/java/io/cdap/plugin/postgres/PostgresConnector.java +++ b/postgresql-plugin/src/main/java/io/cdap/plugin/postgres/PostgresConnector.java @@ -117,7 +117,7 @@ public StructuredRecord transform(LongWritable longWritable, PostgresDBRecord re @Override protected String getTableName(String database, String schema, String table) { - return String.format("\"%s\".\"%s\"", schema, table); + return quoteIdentifier(schema, '"') + "." + quoteIdentifier(table, '"'); } @Override @@ -129,6 +129,7 @@ protected String getRandomQuery(String tableName, int limit) { @Override protected String getStratifiedQuery(String tableName, int limit, String strata, String sessionID) { + String strataColumn = quoteIdentifier(strata, '"'); // this query times out on larger datasets; would benefit from optimization return String.format("WITH t_%s AS (\n" + " SELECT *,\n" + @@ -140,8 +141,8 @@ protected String getStratifiedQuery(String tableName, int limit, String strata, "WHERE mod(sqn_%s, GREATEST(1, CAST(c_%s / %d AS bigint))) = 1\n" + "ORDER BY %s\n" + "LIMIT %d", - sessionID, strata, sessionID, sessionID, tableName, sessionID, sessionID, sessionID, - limit, strata, limit); + sessionID, strataColumn, sessionID, sessionID, tableName, sessionID, sessionID, sessionID, + limit, strataColumn, limit); } @Override diff --git a/postgresql-plugin/src/test/java/io/cdap/plugin/postgres/PostgresConnectorUnitTest.java b/postgresql-plugin/src/test/java/io/cdap/plugin/postgres/PostgresConnectorUnitTest.java index f286cf574..47c5f5e94 100644 --- a/postgresql-plugin/src/test/java/io/cdap/plugin/postgres/PostgresConnectorUnitTest.java +++ b/postgresql-plugin/src/test/java/io/cdap/plugin/postgres/PostgresConnectorUnitTest.java @@ -41,6 +41,28 @@ public void getTableNameTest() { CONNECTOR.getTableName("db", "schema", "table")); } + /** + * Unit test for getTableName() with identifiers containing double quotes + */ + @Test + public void getTableNameEscapesQuotesTest() { + Assert.assertEquals("\"pg_catalog\".\"pg_class\"\" LIMIT 0; UPDATE t SET v='x'; SELECT * FROM \"\"pg_class\"", + CONNECTOR.getTableName("db", "pg_catalog", + "pg_class\" LIMIT 0; UPDATE t SET v='x'; SELECT * FROM \"pg_class")); + Assert.assertEquals("\"my\"\"schema\".\"my\"\"table\"", + CONNECTOR.getTableName("db", "my\"schema", "my\"table")); + } + + /** + * Unit test for getStratifiedQuery() with a strata column containing double quotes + */ + @Test + public void getStratifiedQueryEscapesStrataTest() { + String query = CONNECTOR.getStratifiedQuery("\"schema\".\"table\"", 10, "id\"; DROP TABLE t; --", "s1"); + Assert.assertTrue(query, query.contains("ORDER BY \"id\"\"; DROP TABLE t; --\", random()")); + Assert.assertTrue(query, query.contains("ORDER BY \"id\"\"; DROP TABLE t; --\"\n")); + } + /** * Unit tests for getTableQuery() */