Skip to content

Commit b2c5edc

Browse files
SanneDavideD
Sanne
authored and
DavideD
committed
Prefer postprocessing of SQL parameter style at the connection level
1 parent 8375a3b commit b2c5edc

File tree

6 files changed

+104
-55
lines changed

6 files changed

+104
-55
lines changed

‎hibernate-reactive-core/src/main/java/org/hibernate/reactive/pool/impl/DefaultSqlClientPool.java

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,8 @@
1313
import java.util.concurrent.CompletionStage;
1414

1515
import org.hibernate.HibernateError;
16+
import org.hibernate.dialect.Dialect;
17+
import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
1618
import org.hibernate.engine.jdbc.spi.JdbcServices;
1719
import org.hibernate.engine.jdbc.spi.SqlStatementLogger;
1820
import org.hibernate.internal.util.config.ConfigurationException;
@@ -110,6 +112,7 @@ public static VertxDriver findByClassName(String className) {
110112
private SqlStatementLogger sqlStatementLogger;
111113
private URI uri;
112114
private ServiceRegistryImplementor serviceRegistry;
115+
private Parameters parameters;
113116

114117
//Asynchronous shutdown promise: we can't return it from #close as we implement a
115118
//blocking interface.
@@ -120,7 +123,9 @@ public DefaultSqlClientPool() {}
120123
@Override
121124
public void injectServices(ServiceRegistryImplementor serviceRegistry) {
122125
this.serviceRegistry = serviceRegistry;
123-
sqlStatementLogger = serviceRegistry.getService(JdbcServices.class).getSqlStatementLogger();
126+
this.sqlStatementLogger = serviceRegistry.getService(JdbcServices.class).getSqlStatementLogger();
127+
final Dialect dialect = serviceRegistry.getService( JdbcEnvironment.class ).getDialect();
128+
parameters = Parameters.instance( dialect );
124129
}
125130

126131
@Override
@@ -145,6 +150,11 @@ protected Pool getPool() {
145150
return pools;
146151
}
147152

153+
@Override
154+
protected Parameters getParameters() {
155+
return parameters;
156+
}
157+
148158
@Override
149159
protected SqlStatementLogger getSqlStatementLogger() {
150160
return sqlStatementLogger;

‎hibernate-reactive-core/src/main/java/org/hibernate/reactive/pool/impl/ExternalSqlClientPool.java

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -47,23 +47,24 @@ public final class ExternalSqlClientPool extends SqlClientPool {
4747

4848
private final Pool pool;
4949
private final SqlStatementLogger sqlStatementLogger;
50+
private final Parameters parameters;
5051

51-
public ExternalSqlClientPool(Pool pool, SqlStatementLogger sqlStatementLogger) {
52-
this.pool = pool;
53-
this.sqlStatementLogger = sqlStatementLogger;
54-
}
55-
56-
@Deprecated
57-
public ExternalSqlClientPool(Pool pool, SqlStatementLogger sqlStatementLogger, boolean usePostgresStyleParameters) {
52+
public ExternalSqlClientPool(Pool pool, SqlStatementLogger sqlStatementLogger, Parameters parameters) {
5853
this.pool = pool;
5954
this.sqlStatementLogger = sqlStatementLogger;
55+
this.parameters = parameters;
6056
}
6157

6258
@Override
6359
protected Pool getPool() {
6460
return pool;
6561
}
6662

63+
@Override
64+
protected Parameters getParameters() {
65+
return parameters;
66+
}
67+
6768
@Override
6869
protected SqlStatementLogger getSqlStatementLogger() {
6970
return sqlStatementLogger;

‎hibernate-reactive-core/src/main/java/org/hibernate/reactive/pool/impl/Parameters.java

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77

88
import org.hibernate.dialect.CockroachDialect;
99
import org.hibernate.dialect.Dialect;
10+
import org.hibernate.dialect.DialectDelegateWrapper;
1011
import org.hibernate.dialect.PostgreSQLDialect;
1112
import org.hibernate.dialect.SQLServerDialect;
1213

@@ -36,6 +37,9 @@ public String processLimit(String sql, Object[] parameterArray, boolean hasOffse
3637
};
3738

3839
public static Parameters instance(Dialect dialect) {
40+
if ( dialect instanceof DialectDelegateWrapper ) {
41+
dialect = ( (DialectDelegateWrapper) dialect ).getWrappedDialect();
42+
}
3943
if (dialect instanceof PostgreSQLDialect || dialect instanceof CockroachDialect ) return PostgresParameters.INSTANCE;
4044
if (dialect instanceof SQLServerDialect) return SQLServerParameters.INSTANCE;
4145
return NO_PARSING;

‎hibernate-reactive-core/src/main/java/org/hibernate/reactive/pool/impl/ProxyConnection.java

Lines changed: 32 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -29,19 +29,22 @@ final class ProxyConnection implements ReactiveConnection {
2929
private static final Log LOG = LoggerFactory.make( Log.class, MethodHandles.lookup() );
3030

3131
private final ReactiveConnectionPool sqlClientPool;
32+
private final Parameters sqlCleaner;
3233
private ReactiveConnection connection;
3334
private boolean connected;
3435
private boolean closed;
3536
private final String tenantId;
3637

37-
public ProxyConnection(ReactiveConnectionPool sqlClientPool) {
38+
public ProxyConnection(ReactiveConnectionPool sqlClientPool, Parameters parameters) {
3839
this.sqlClientPool = sqlClientPool;
39-
tenantId = null;
40+
this.sqlCleaner = parameters;
41+
this.tenantId = null;
4042
}
4143

42-
public ProxyConnection(ReactiveConnectionPool sqlClientPool, String tenantId) {
44+
public ProxyConnection(ReactiveConnectionPool sqlClientPool, String tenantId, Parameters parameters) {
4345
this.sqlClientPool = sqlClientPool;
4446
this.tenantId = tenantId;
47+
this.sqlCleaner = parameters;
4548
}
4649

4750
private <T> CompletionStage<T> withConnection(Function<ReactiveConnection, CompletionStage<T>> operation) {
@@ -72,27 +75,32 @@ private <T> CompletionStage<T> withConnection(Function<ReactiveConnection, Compl
7275

7376
@Override
7477
public CompletionStage<Void> execute(String sql) {
75-
return withConnection( conn -> conn.execute( sql ) );
78+
final String processedSql = sqlCleaner.process( sql );
79+
return withConnection( conn -> conn.execute( processedSql ) );
7680
}
7781

7882
@Override
7983
public CompletionStage<Void> executeUnprepared(String sql) {
80-
return withConnection( conn -> conn.executeUnprepared( sql ) );
84+
final String processedSql = sqlCleaner.process( sql );
85+
return withConnection( conn -> conn.executeUnprepared( processedSql ) );
8186
}
8287

8388
@Override
8489
public CompletionStage<Void> executeOutsideTransaction(String sql) {
85-
return withConnection( conn -> conn.executeOutsideTransaction( sql ) );
90+
final String processedSql = sqlCleaner.process( sql );
91+
return withConnection( conn -> conn.executeOutsideTransaction( processedSql ) );
8692
}
8793

8894
@Override
8995
public CompletionStage<Integer> update(String sql) {
90-
return withConnection( conn -> conn.update( sql ) );
96+
final String processedSql = sqlCleaner.process( sql );
97+
return withConnection( conn -> conn.update( processedSql ) );
9198
}
9299

93100
@Override
94101
public CompletionStage<Integer> update(String sql, Object[] paramValues) {
95-
return withConnection( conn -> conn.update( sql, paramValues ) );
102+
final String processedSql = sqlCleaner.process( sql );
103+
return withConnection( conn -> conn.update( processedSql, paramValues ) );
96104
}
97105

98106
@Override
@@ -101,42 +109,50 @@ public CompletionStage<Void> update(
101109
Object[] paramValues,
102110
boolean allowBatching,
103111
Expectation expectation) {
104-
return withConnection( conn -> conn.update( sql, paramValues, allowBatching, expectation ) );
112+
final String processedSql = sqlCleaner.process( sql );
113+
return withConnection( conn -> conn.update( processedSql, paramValues, allowBatching, expectation ) );
105114
}
106115

107116
@Override
108117
public CompletionStage<int[]> update(String sql, List<Object[]> paramValues) {
109-
return withConnection( conn -> conn.update( sql, paramValues ) );
118+
final String processedSql = sqlCleaner.process( sql );
119+
return withConnection( conn -> conn.update( processedSql, paramValues ) );
110120
}
111121

112122
@Override
113123
public <T> CompletionStage<T> insertAndSelectIdentifier(String sql, Object[] paramValues, Class<T> idClass, String idColumnName) {
114-
return withConnection( conn -> conn.insertAndSelectIdentifier( sql, paramValues, idClass, idColumnName ) );
124+
final String processedSql = sqlCleaner.process( sql );
125+
return withConnection( conn -> conn.insertAndSelectIdentifier( processedSql, paramValues, idClass, idColumnName ) );
115126
}
116127

117128
@Override
118129
public CompletionStage<Result> select(String sql) {
119-
return withConnection( conn -> conn.select( sql ) );
130+
final String processedSql = sqlCleaner.process( sql );
131+
return withConnection( conn -> conn.select( processedSql ) );
120132
}
121133

122134
@Override
123135
public CompletionStage<Result> select(String sql, Object[] paramValues) {
124-
return withConnection( conn -> conn.select( sql, paramValues ) );
136+
final String processedSql = sqlCleaner.process( sql );
137+
return withConnection( conn -> conn.select( processedSql, paramValues ) );
125138
}
126139

127140
@Override
128141
public CompletionStage<ResultSet> selectJdbc(String sql, Object[] paramValues) {
129-
return withConnection( conn -> conn.selectJdbc( sql, paramValues ) );
142+
final String processedSql = sqlCleaner.process( sql );
143+
return withConnection( conn -> conn.selectJdbc( processedSql, paramValues ) );
130144
}
131145

132146
@Override
133147
public CompletionStage<ResultSet> selectJdbcOutsideTransaction(String sql, Object[] paramValues) {
134-
return withConnection( conn -> conn.selectJdbcOutsideTransaction( sql, paramValues ) );
148+
final String processedSql = sqlCleaner.process( sql );
149+
return withConnection( conn -> conn.selectJdbcOutsideTransaction( processedSql, paramValues ) );
135150
}
136151

137152
@Override
138153
public <T> CompletionStage<T> selectIdentifier(String sql, Object[] paramValues, Class<T> idClass) {
139-
return withConnection( conn -> conn.selectIdentifier( sql, paramValues, idClass ) );
154+
final String processedSql = sqlCleaner.process( sql );
155+
return withConnection( conn -> conn.selectIdentifier( processedSql, paramValues, idClass ) );
140156
}
141157

142158
@Override

‎hibernate-reactive-core/src/main/java/org/hibernate/reactive/pool/impl/SqlClientConnection.java

Lines changed: 40 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -59,12 +59,15 @@ public class SqlClientConnection implements ReactiveConnection {
5959

6060
private final Pool pool;
6161
private final SqlConnection connection;
62+
private final Parameters sqlCleaner;
6263
private Transaction transaction;
6364

64-
SqlClientConnection(SqlConnection connection, Pool pool, SqlStatementLogger sqlStatementLogger) {
65+
SqlClientConnection(SqlConnection connection, Pool pool, SqlStatementLogger sqlStatementLogger,
66+
Parameters parameters) {
6567
this.pool = pool;
6668
this.sqlStatementLogger = sqlStatementLogger;
6769
this.connection = connection;
70+
this.sqlCleaner = parameters;
6871
LOG.tracef( "Connection created: %s", connection );
6972
}
7073

@@ -86,15 +89,17 @@ public CompletionStage<int[]> update(String sql, List<Object[]> batchParamValues
8689

8790
@Override
8891
public CompletionStage<Void> update(String sql, Object[] paramValues, boolean allowBatching, Expectation expectation) {
89-
return update( sql, paramValues )
90-
.thenAccept( rowCount -> expectation.verifyOutcome( rowCount,-1, sql ) );
92+
final String readySql = sqlCleaner.process( sql );
93+
return update( readySql, paramValues )
94+
.thenAccept( rowCount -> expectation.verifyOutcome( rowCount,-1, readySql ) );
9195
}
9296

9397
@Override
9498
public <T> CompletionStage<T> selectIdentifier(String sql, Object[] paramValues, Class<T> idClass) {
99+
final String readySql = sqlCleaner.process( sql );
95100
translateNulls( paramValues );
96-
return preparedQuery( sql, Tuple.wrap( paramValues ) )
97-
.handle( (rows, throwable) -> convertException( rows, sql, throwable ) )
101+
return preparedQuery( readySql, Tuple.wrap( paramValues ) )
102+
.handle( (rows, throwable) -> convertException( rows, readySql, throwable ) )
98103
.thenApply( rowSet -> {
99104
for (Row row: rowSet) {
100105
return row.get(idClass, 0);
@@ -137,9 +142,10 @@ public CompletionStage<Void> execute(String sql) {
137142

138143
@Override
139144
public CompletionStage<Void> executeUnprepared(String sql) {
140-
feedback( sql );
141-
return client().query( sql ).execute().toCompletionStage()
142-
.handle( (rows, throwable) -> convertException( rows, sql, throwable ) )
145+
final String readySql = sqlCleaner.process( sql );
146+
feedback( readySql );
147+
return client().query( readySql ).execute().toCompletionStage()
148+
.handle( (rows, throwable) -> convertException( rows, readySql, throwable ) )
143149
.thenCompose( CompletionStages::voidFuture );
144150
}
145151

@@ -166,7 +172,7 @@ public CompletionStage<Void> executeOutsideTransaction(String sql) {
166172

167173
@Override
168174
public CompletionStage<Integer> update(String sql) {
169-
return preparedQuery( sql ).thenApply(SqlResult::rowCount);
175+
return preparedQuery( sql ).thenApply( SqlResult::rowCount );
170176
}
171177

172178
public CompletionStage<Integer> update(String sql, Tuple parameters) {
@@ -225,43 +231,49 @@ public <T> CompletionStage<T> insertAndSelectIdentifier(String sql, Tuple parame
225231
}
226232

227233
public CompletionStage<RowSet<Row>> preparedQuery(String sql, Tuple parameters) {
228-
feedback( sql );
229-
return client().preparedQuery( sql ).execute( parameters ).toCompletionStage()
230-
.handle( (rows, throwable) -> convertException( rows, sql, throwable ) );
234+
final String readySql = sqlCleaner.process( sql );
235+
feedback( readySql );
236+
return client().preparedQuery( readySql ).execute( parameters ).toCompletionStage()
237+
.handle( (rows, throwable) -> convertException( rows, readySql, throwable ) );
231238
}
232239

233240
public CompletionStage<RowSet<Row>> preparedQuery(String sql, Tuple parameters, PrepareOptions options) {
234-
feedback( sql );
235-
return client().preparedQuery( sql, options ).execute( parameters ).toCompletionStage()
236-
.handle( (rows, throwable) -> convertException( rows, sql, throwable ) );
241+
final String readySql = sqlCleaner.process( sql );
242+
feedback( readySql );
243+
return client().preparedQuery( readySql, options ).execute( parameters ).toCompletionStage()
244+
.handle( (rows, throwable) -> convertException( rows, readySql, throwable ) );
237245
}
238246

239247
public CompletionStage<RowSet<Row>> preparedQueryBatch(String sql, List<Tuple> parameters) {
240-
feedback( sql );
241-
return client().preparedQuery( sql ).executeBatch( parameters ).toCompletionStage()
242-
.handle( (rows, throwable) -> convertException( rows, sql, throwable ) );
248+
final String readySql = sqlCleaner.process( sql );
249+
feedback( readySql );
250+
return client().preparedQuery( readySql ).executeBatch( parameters ).toCompletionStage()
251+
.handle( (rows, throwable) -> convertException( rows, readySql, throwable ) );
243252
}
244253

245254
public CompletionStage<RowSet<Row>> preparedQuery(String sql) {
246-
feedback( sql );
247-
return client().preparedQuery( sql ).execute().toCompletionStage()
248-
.handle( (rows, throwable) -> convertException( rows, sql, throwable ) );
255+
final String readySql = sqlCleaner.process( sql );
256+
feedback( readySql );
257+
return client().preparedQuery( readySql ).execute().toCompletionStage()
258+
.handle( (rows, throwable) -> convertException( rows, readySql, throwable ) );
249259
}
250260

251261
public CompletionStage<RowSet<Row>> preparedQueryOutsideTransaction(String sql) {
252-
feedback( sql );
253-
return pool.preparedQuery( sql ).execute().toCompletionStage()
254-
.handle( (rows, throwable) -> convertException( rows, sql, throwable ) );
262+
final String readySql = sqlCleaner.process( sql );
263+
feedback( readySql );
264+
return pool.preparedQuery( readySql ).execute().toCompletionStage()
265+
.handle( (rows, throwable) -> convertException( rows, readySql, throwable ) );
255266
}
256267

257268
public CompletionStage<RowSet<Row>> preparedQueryOutsideTransaction(String sql, Tuple parameters) {
258-
feedback( sql );
259-
return pool.preparedQuery( sql ).execute( parameters ).toCompletionStage()
260-
.handle( (rows, throwable) -> convertException( rows, sql, throwable ) );
269+
final String readySql = sqlCleaner.process( sql );
270+
feedback( readySql );
271+
return pool.preparedQuery( readySql ).execute( parameters ).toCompletionStage()
272+
.handle( (rows, throwable) -> convertException( rows, readySql, throwable ) );
261273
}
262274

263275
private void feedback(String sql) {
264-
Objects.requireNonNull(sql, "SQL query cannot be null");
276+
Objects.requireNonNull( sql, "SQL query cannot be null" );
265277
// DDL already gets formatted by the client, so don't reformat it
266278
FormatStyle formatStyle =
267279
sqlStatementLogger.isFormat() && !sql.contains( System.lineSeparator() )

‎hibernate-reactive-core/src/main/java/org/hibernate/reactive/pool/impl/SqlClientPool.java

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,12 @@ public abstract class SqlClientPool implements ReactiveConnectionPool {
3838
*/
3939
protected abstract Pool getPool();
4040

41+
/**
42+
* Provide a reference to the Parameters instance matching the current Dialect
43+
* @return
44+
*/
45+
protected abstract Parameters getParameters();
46+
4147
/**
4248
* @return a Hibernate {@link SqlStatementLogger} for logging SQL
4349
* statements as they are executed
@@ -76,17 +82,17 @@ private CompletionStage<ReactiveConnection> getConnectionFromPool(Pool pool) {
7682
}
7783

7884
private SqlClientConnection newConnection(SqlConnection connection) {
79-
return new SqlClientConnection( connection, getPool(), getSqlStatementLogger() );
85+
return new SqlClientConnection( connection, getPool(), getSqlStatementLogger(), getParameters() );
8086
}
8187

8288
@Override
8389
public ReactiveConnection getProxyConnection() {
84-
return new ProxyConnection( this );
90+
return new ProxyConnection( this, getParameters() );
8591
}
8692

8793
@Override
8894
public ReactiveConnection getProxyConnection(String tenantId) {
89-
return new ProxyConnection( this, tenantId );
95+
return new ProxyConnection( this, tenantId, getParameters() );
9096
}
9197

9298
}

0 commit comments

Comments
 (0)