Skip to content

Commit

Permalink
add support for customizing transaction start - fixes eclipse-vertx#432
Browse files Browse the repository at this point in the history 
Signed-off-by: Billy Yuan <[email protected]>
  • Loading branch information
@BillyYccc
BillyYccc committed May 18, 2020
1 parent 462d993 commit 3b744fe
Show file tree
Hide file tree
Showing 36 changed files with 933 additions and 139 deletions.
44 changes: 33 additions & 11 deletions vertx-db2-client/src/main/java/examples/SqlClientExamples.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,17 20,11 @@

import io.vertx.core.Vertx;
import io.vertx.docgen.Source;
import io.vertx.sqlclient.Cursor;
import io.vertx.sqlclient.Pool;
import io.vertx.sqlclient.PreparedStatement;
import io.vertx.sqlclient.Row;
import io.vertx.sqlclient.RowSet;
import io.vertx.sqlclient.RowStream;
import io.vertx.sqlclient.SqlClient;
import io.vertx.sqlclient.SqlConnectOptions;
import io.vertx.sqlclient.SqlConnection;
import io.vertx.sqlclient.Transaction;
import io.vertx.sqlclient.Tuple;
import io.vertx.sqlclient.*;
import io.vertx.sqlclient.transaction.Transaction;
import io.vertx.sqlclient.transaction.TransactionAccessMode;
import io.vertx.sqlclient.transaction.TransactionIsolationLevel;
import io.vertx.sqlclient.transaction.TransactionOptions;

@Source
public class SqlClientExamples {
Expand Down Expand Up @@ -311,6 305,34 @@ public void transaction03(Pool pool) {
});
}

public void transaction04(SqlConnection sqlConnection) {
TransactionOptions txOptions = new TransactionOptions();
txOptions.setIsolationLevel(TransactionIsolationLevel.REPEATABLE_READ);
txOptions.setAccessMode(TransactionAccessMode.READ_ONLY);
sqlConnection.begin(txOptions, ar -> {
if (ar.succeeded()) {
// start a transaction which is read-only
Transaction tx = ar.result();
} else {
// Failed to start a transaction
System.out.println("Transaction failed " ar.cause().getMessage());
}
});
}

public void transaction05(Pool pool) {
TransactionOptions txOptions = new TransactionOptions();
txOptions.setIsolationLevel(TransactionIsolationLevel.REPEATABLE_READ);
txOptions.setAccessMode(TransactionAccessMode.READ_ONLY);
pool.withTransaction(txOptions, client -> client
.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')")
.execute()
).onFailure(error -> {
// Failed to insert the record because the transaction is read-only
System.out.println("Transaction failed " error.getMessage());
});
}

public void usingCursors01(SqlConnection connection) {
connection.prepare("SELECT * FROM users WHERE first_name LIKE $1", ar0 -> {
if (ar0.succeeded()) {
Expand Down
41 changes: 24 additions & 17 deletions vertx-db2-client/src/main/java/io/vertx/db2client/impl/DB2SocketConnection.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,29 28,26 @@
import io.vertx.sqlclient.impl.Connection;
import io.vertx.sqlclient.impl.QueryResultHandler;
import io.vertx.sqlclient.impl.SocketConnectionBase;
import io.vertx.sqlclient.impl.command.CommandBase;
import io.vertx.sqlclient.impl.command.CommandResponse;
import io.vertx.sqlclient.impl.command.QueryCommandBase;
import io.vertx.sqlclient.impl.command.SimpleQueryCommand;
import io.vertx.sqlclient.impl.command.TxCommand;
import io.vertx.sqlclient.impl.command.*;
import io.vertx.db2client.impl.util.TransactionSqlBuilder;

public class DB2SocketConnection extends SocketConnectionBase {

private DB2Codec codec;
private Handler<Void> closeHandler;

public DB2SocketConnection(NetSocketInternal socket,
boolean cachePreparedStatements,
public DB2SocketConnection(NetSocketInternal socket,
boolean cachePreparedStatements,
int preparedStatementCacheSize,
int preparedStatementCacheSqlLimit,
int pipeliningLimit,
int preparedStatementCacheSqlLimit,
int pipeliningLimit,
ContextInternal context) {
super(socket, cachePreparedStatements, preparedStatementCacheSize, preparedStatementCacheSqlLimit, pipeliningLimit, context);
}

void sendStartupMessage(String username,
String password,
String database,
void sendStartupMessage(String username,
String password,
String database,
Map<String, String> properties,
Promise<Connection> completionHandler) {
InitialHandshakeCommand cmd = new InitialHandshakeCommand(this, username, password, database, properties);
Expand All @@ -68,14 65,24 @@ public void init() {
@Override
protected <R> void doSchedule(CommandBase<R> cmd, Handler<AsyncResult<R>> handler) {
if (cmd instanceof TxCommand) {
cmd.handler = handler;
TxCommand<R> txCmd = (TxCommand<R>) cmd;
if (txCmd.kind == TxCommand.Kind.BEGIN) {
// DB2 always implicitly starts a transaction with each query, and does
// not support the 'BEGIN' keyword. Instead we can no-op BEGIN commands
cmd.handler = handler;
cmd.complete(CommandResponse.success(txCmd.result).toAsyncResult());
StartTxCommand<R> startTxCommand = (StartTxCommand<R>) txCmd;
if (startTxCommand.isolationLevel != null || startTxCommand.accessMode != null) {
// customized transaction
String sql = TransactionSqlBuilder.buildSetTxIsolationLevelSql(startTxCommand.isolationLevel, startTxCommand.accessMode);
SimpleQueryCommand<Void> setTxCmd = new SimpleQueryCommand<>(sql, false, false,
QueryCommandBase.NULL_COLLECTOR, QueryResultHandler.NOOP_HANDLER);

super.doSchedule(setTxCmd, ar -> handler.handle(ar.map(txCmd.result)));
} else {
// DB2 always implicitly starts a transaction with each query, and does
// not support the 'BEGIN' keyword. Instead we can no-op BEGIN commands
cmd.complete(CommandResponse.success(txCmd.result).toAsyncResult());
}
} else {
SimpleQueryCommand<Void> cmd2 = new SimpleQueryCommand<>(txCmd.kind.sql, false, false,
SimpleQueryCommand<Void> cmd2 = new SimpleQueryCommand<>(txCmd.kind.name(), false, false,
QueryCommandBase.NULL_COLLECTOR, QueryResultHandler.NOOP_HANDLER);
super.doSchedule(cmd2, ar -> handler.handle(ar.map(txCmd.result)));

Expand Down
58 changes: 58 additions & 0 deletions vertx-db2-client/src/main/java/io/vertx/db2client/impl/util/TransactionSqlBuilder.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 1,58 @@
package io.vertx.db2client.impl.util;

import io.vertx.sqlclient.transaction.TransactionAccessMode;
import io.vertx.sqlclient.transaction.TransactionIsolationLevel;

public class TransactionSqlBuilder {
private static final String SET_ISOLATION = "SET TRANSACTION";

private static final String PREDEFINED_TX_REPEATABLE_READ = " ISOLATION LEVEL REPEATABLE READ";
private static final String PREDEFINED_TX_SERIALIZABLE = " ISOLATION LEVEL SERIALIZABLE";
private static final String PREDEFINED_TX_READ_COMMITTED = " ISOLATION LEVEL READ COMMITTED";
private static final String PREDEFINED_TX_READ_UNCOMMITTED = " ISOLATION LEVEL READ UNCOMMITTED";


private static final String PREDEFINED_TX_RW = " READ WRITE";
private static final String PREDEFINED_TX_RO = " READ ONLY";

public static String buildSetTxIsolationLevelSql(TransactionIsolationLevel isolationLevel, TransactionAccessMode accessMode) {
boolean isCharacteristicExisted = false;
StringBuilder sqlBuilder = new StringBuilder(SET_ISOLATION);

if (isolationLevel != null) {
switch (isolationLevel) {
case READ_UNCOMMITTED:
sqlBuilder.append(PREDEFINED_TX_READ_UNCOMMITTED);
break;
case READ_COMMITTED:
sqlBuilder.append(PREDEFINED_TX_READ_COMMITTED);
break;
case REPEATABLE_READ:
sqlBuilder.append(PREDEFINED_TX_REPEATABLE_READ);
break;
case SERIALIZABLE:
sqlBuilder.append(PREDEFINED_TX_SERIALIZABLE);
break;
}
isCharacteristicExisted = true;
}

if (accessMode != null) {
if (isCharacteristicExisted) {
sqlBuilder.append(',');
} else {
isCharacteristicExisted = true;
}
switch (accessMode) {
case READ_ONLY:
sqlBuilder.append(PREDEFINED_TX_RO);
break;
case READ_WRITE:
sqlBuilder.append(PREDEFINED_TX_RW);
break;
}
}

return sqlBuilder.toString();
}
}
22 changes: 17 additions & 5 deletions vertx-db2-client/src/test/java/io/vertx/db2client/tck/DB2TransactionTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,10 17,7 @@

import static org.junit.Assume.assumeFalse;

import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.junit.*;
import org.junit.rules.TestName;
import org.junit.runner.RunWith;

Expand All @@ -38,7 35,7 @@ public class DB2TransactionTest extends TransactionTestBase {

@ClassRule
public static DB2Resource rule = DB2Resource.SHARED_INSTANCE;

@Rule
public TestName testName = new TestName();

Expand Down Expand Up @@ -74,4 71,19 @@ public void testDelayedCommit(TestContext ctx) {
super.testDelayedCommit(ctx);
}

@Override
@Ignore
@Test
public void testStartReadOnlyTransaction(TestContext ctx) {
// FIXME
super.testStartReadOnlyTransaction(ctx);
}

@Override
@Ignore
@Test
public void testWithReadOnlyTransactionStart(TestContext ctx) {
// FIXME
super.testWithReadOnlyTransactionStart(ctx);
}
}
27 changes: 27 additions & 0 deletions vertx-db2-client/src/test/java/io/vertx/db2client/util/TransactionSqlBuilderTest.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 1,27 @@
package io.vertx.db2client.util;

import io.vertx.db2client.impl.util.TransactionSqlBuilder;
import io.vertx.sqlclient.transaction.TransactionAccessMode;
import io.vertx.sqlclient.transaction.TransactionIsolationLevel;
import org.junit.Assert;
import org.junit.Test;

public class TransactionSqlBuilderTest {
@Test
public void testSetReadCommitted() {
String sql = TransactionSqlBuilder.buildSetTxIsolationLevelSql(TransactionIsolationLevel.READ_COMMITTED, null);
Assert.assertEquals("SET TRANSACTION ISOLATION LEVEL READ COMMITTED" ,sql);
}

@Test
public void testSetReadOnly() {
String sql = TransactionSqlBuilder.buildSetTxIsolationLevelSql(null, TransactionAccessMode.READ_ONLY);
Assert.assertEquals("SET TRANSACTION READ ONLY" ,sql);
}

@Test
public void testSerializableReadOnly() {
String sql = TransactionSqlBuilder.buildSetTxIsolationLevelSql(TransactionIsolationLevel.SERIALIZABLE, TransactionAccessMode.READ_ONLY);
Assert.assertEquals("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY" ,sql);
}
}
32 changes: 32 additions & 0 deletions vertx-mssql-client/src/main/java/examples/SqlClientExamples.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,6 19,10 @@
import io.vertx.core.Vertx;
import io.vertx.docgen.Source;
import io.vertx.sqlclient.*;
import io.vertx.sqlclient.transaction.Transaction;
import io.vertx.sqlclient.transaction.TransactionAccessMode;
import io.vertx.sqlclient.transaction.TransactionIsolationLevel;
import io.vertx.sqlclient.transaction.TransactionOptions;

import java.util.ArrayList;
import java.util.List;
Expand Down Expand Up @@ -298,6 302,34 @@ public void transaction03(Pool pool) {
});
}

public void transaction04(SqlConnection sqlConnection) {
TransactionOptions txOptions = new TransactionOptions();
txOptions.setIsolationLevel(TransactionIsolationLevel.REPEATABLE_READ);
txOptions.setAccessMode(TransactionAccessMode.READ_ONLY);
sqlConnection.begin(txOptions, ar -> {
if (ar.succeeded()) {
// start a transaction which is read-only
Transaction tx = ar.result();
} else {
// Failed to start a transaction
System.out.println("Transaction failed " ar.cause().getMessage());
}
});
}

public void transaction05(Pool pool) {
TransactionOptions txOptions = new TransactionOptions();
txOptions.setIsolationLevel(TransactionIsolationLevel.REPEATABLE_READ);
txOptions.setAccessMode(TransactionAccessMode.READ_ONLY);
pool.withTransaction(txOptions, client -> client
.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')")
.execute()
).onFailure(error -> {
// Failed to insert the record because the transaction is read-only
System.out.println("Transaction failed " error.getMessage());
});
}

public void usingCursors01(SqlConnection connection) {
connection.prepare("SELECT * FROM users WHERE age > @p1", ar1 -> {
if (ar1.succeeded()) {
Expand Down
2 changes: 0 additions & 2 deletions vertx-mssql-client/src/main/java/io/vertx/mssqlclient/impl/MSSQLPoolImpl.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,11 19,9 @@
import io.vertx.core.Handler;
import io.vertx.sqlclient.PoolOptions;
import io.vertx.sqlclient.SqlClient;
import io.vertx.sqlclient.Transaction;
import io.vertx.sqlclient.impl.Connection;
import io.vertx.sqlclient.impl.PoolBase;
import io.vertx.sqlclient.impl.SqlConnectionImpl;
import io.vertx.sqlclient.impl.pool.ConnectionPool;

import java.util.function.Function;

Expand Down
45 changes: 33 additions & 12 deletions vertx-mysql-client/src/main/java/examples/SqlClientExamples.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,18 18,11 @@

import io.vertx.core.Vertx;
import io.vertx.docgen.Source;
import io.vertx.sqlclient.Cursor;
import io.vertx.sqlclient.Pool;
import io.vertx.sqlclient.PoolOptions;
import io.vertx.sqlclient.PreparedStatement;
import io.vertx.sqlclient.Row;
import io.vertx.sqlclient.RowSet;
import io.vertx.sqlclient.RowStream;
import io.vertx.sqlclient.SqlClient;
import io.vertx.sqlclient.SqlConnectOptions;
import io.vertx.sqlclient.SqlConnection;
import io.vertx.sqlclient.Transaction;
import io.vertx.sqlclient.Tuple;
import io.vertx.sqlclient.*;
import io.vertx.sqlclient.transaction.Transaction;
import io.vertx.sqlclient.transaction.TransactionAccessMode;
import io.vertx.sqlclient.transaction.TransactionIsolationLevel;
import io.vertx.sqlclient.transaction.TransactionOptions;

import java.util.ArrayList;
import java.util.List;
Expand Down Expand Up @@ -311,6 304,34 @@ public void transaction03(Pool pool) {
});
}

public void transaction04(SqlConnection sqlConnection) {
TransactionOptions txOptions = new TransactionOptions();
txOptions.setIsolationLevel(TransactionIsolationLevel.REPEATABLE_READ);
txOptions.setAccessMode(TransactionAccessMode.READ_ONLY);
sqlConnection.begin(txOptions, ar -> {
if (ar.succeeded()) {
// start a transaction which is read-only
Transaction tx = ar.result();
} else {
// Failed to start a transaction
System.out.println("Transaction failed " ar.cause().getMessage());
}
});
}

public void transaction05(Pool pool) {
TransactionOptions txOptions = new TransactionOptions();
txOptions.setIsolationLevel(TransactionIsolationLevel.REPEATABLE_READ);
txOptions.setAccessMode(TransactionAccessMode.READ_ONLY);
pool.withTransaction(txOptions, client -> client
.query("INSERT INTO Users (first_name,last_name) VALUES ('Julien','Viet')")
.execute()
).onFailure(error -> {
// Failed to insert the record because the transaction is read-only
System.out.println("Transaction failed " error.getMessage());
});
}

public void usingCursors01(SqlConnection connection) {
connection.prepare("SELECT * FROM users WHERE age > ?", ar1 -> {
if (ar1.succeeded()) {
Expand Down
Loading

0 comments on commit 3b744fe

Please sign in to comment.