Skip to content

Commit f9792f8

Browse files
vietjvietj
committed
Move all query command execution method in SqlResultBuilder
1 parent 82532d4 commit f9792f8

File tree

4 files changed

+70
-66
lines changed

4 files changed

+70
-66
lines changed

‎vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/CursorImpl.java

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -67,12 +67,11 @@ public void read(int count, Handler<AsyncResult<RowSet<Row>>> handler) {
6767
public synchronized Future<RowSet<Row>> read(int count) {
6868
Promise<RowSet<Row>> promise = context.promise();
6969
SqlResultBuilder<RowSet<Row>, RowSetImpl<Row>, RowSet<Row>> builder = new SqlResultBuilder<>(RowSetImpl.FACTORY, RowSetImpl.COLLECTOR);
70-
SqlResultHandler<RowSet<Row>, RowSetImpl<Row>, RowSet<Row>> handler = builder.createHandler(promise);
7170
if (id == null) {
7271
id = UUID.randomUUID().toString();
73-
result = builder.execute(ps.conn, ps.ps, ps.autoCommit, params, count, id, false, handler);
72+
result = builder.executeExtendedQuery(ps.conn, ps.ps, ps.autoCommit, params, count, id, false, promise);
7473
} else if (result.isSuspended()) {
75-
result = builder.execute(ps.conn, ps.ps, ps.autoCommit, params, count, id, true, handler);
74+
result = builder.executeExtendedQuery(ps.conn, ps.ps, ps.autoCommit, params, count, id, true, promise);
7675
} else {
7776
throw new IllegalStateException();
7877
}

‎vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/PreparedStatementImpl.java

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -70,16 +70,15 @@ <R, F extends SqlResult<R>> void execute(Tuple args,
7070
SqlResultBuilder<R, ?, F> builder,
7171
Promise<F> p) {
7272
if (context == Vertx.currentContext()) {
73-
SqlResultHandler handler = builder.createHandler(p);
74-
builder.execute(
73+
builder.executeExtendedQuery(
7574
conn,
7675
ps,
7776
autoCommit,
7877
args,
7978
fetch,
8079
cursorId,
8180
suspended,
82-
handler);
81+
p);
8382
} else {
8483
context.runOnContext(v -> execute(args, fetch, cursorId, suspended, builder, p));
8584
}
@@ -114,8 +113,7 @@ <R, F extends SqlResult<R>> void executeBatch(List<Tuple> argsList,
114113
SqlResultBuilder<R, ?, F> builder,
115114
Promise<F> p) {
116115
if (context == Vertx.currentContext()) {
117-
SqlResultHandler handler = builder.createHandler(p);
118-
builder.executeBatch(conn, ps, autoCommit, argsList, handler);
116+
builder.executeBatchQuery(conn, ps, autoCommit, argsList, p);
119117
} else {
120118
context.runOnContext(v -> executeBatch(argsList, builder, p));
121119
}

‎vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/SqlClientBase.java

Lines changed: 3 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -20,10 +20,7 @@
2020
import io.vertx.core.Promise;
2121
import io.vertx.sqlclient.PreparedQuery;
2222
import io.vertx.sqlclient.Query;
23-
import io.vertx.sqlclient.impl.command.BiCommand;
2423
import io.vertx.sqlclient.impl.command.CommandScheduler;
25-
import io.vertx.sqlclient.impl.command.ExtendedBatchQueryCommand;
26-
import io.vertx.sqlclient.impl.command.PrepareStatementCommand;
2724
import io.vertx.sqlclient.SqlResult;
2825
import io.vertx.sqlclient.RowSet;
2926
import io.vertx.sqlclient.Row;
@@ -96,8 +93,7 @@ public Future<R> execute() {
9693
}
9794

9895
protected void execute(Promise<R> promise) {
99-
SqlResultHandler handler = builder.createHandler(promise);
100-
builder.execute(SqlClientBase.this, sql, autoCommit, singleton, handler);
96+
builder.executeSimpleQuery(SqlClientBase.this, sql, autoCommit, singleton, promise);
10197
}
10298
}
10399

@@ -128,15 +124,7 @@ protected void execute(Promise<R> promise) {
128124
}
129125

130126
private void execute(Tuple arguments, Promise<R> promise) {
131-
SqlResultHandler handler = builder.createHandler(promise);
132-
BiCommand<PreparedStatement, Boolean> abc = new BiCommand<>(new PrepareStatementCommand(sql, true), ps -> {
133-
String msg = ps.prepare((TupleInternal) arguments);
134-
if (msg != null) {
135-
return Future.failedFuture(msg);
136-
}
137-
return Future.succeededFuture(builder.createCommand(ps, autoCommit, arguments, handler));
138-
});
139-
schedule(abc, handler);
127+
builder.executeExtendedQuery(SqlClientBase.this, sql, autoCommit, arguments, promise);
140128
}
141129

142130
@Override
@@ -164,17 +152,7 @@ public Future<R> executeBatch(List<Tuple> batch) {
164152
}
165153

166154
private void executeBatch(List<Tuple> batch, Promise<R> promise) {
167-
SqlResultHandler handler = builder.createHandler(promise);
168-
BiCommand<PreparedStatement, Boolean> abc = new BiCommand<>(new PrepareStatementCommand(sql, true), ps -> {
169-
for (Tuple args : batch) {
170-
String msg = ps.prepare((TupleInternal) args);
171-
if (msg != null) {
172-
return Future.failedFuture(msg);
173-
}
174-
}
175-
return Future.succeededFuture(builder.createBatchCommand(ps, autoCommit, batch, handler));
176-
});
177-
schedule(abc, handler);
155+
builder.executeBatchQuery(SqlClientBase.this, sql, autoCommit, batch, promise);
178156
}
179157
}
180158
}

‎vertx-sql-client/src/main/java/io/vertx/sqlclient/impl/SqlResultBuilder.java

Lines changed: 62 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -17,13 +17,16 @@
1717

1818
package io.vertx.sqlclient.impl;
1919

20+
import io.vertx.core.Future;
2021
import io.vertx.core.Promise;
2122
import io.vertx.sqlclient.Row;
2223
import io.vertx.sqlclient.SqlResult;
2324
import io.vertx.sqlclient.Tuple;
25+
import io.vertx.sqlclient.impl.command.BiCommand;
2426
import io.vertx.sqlclient.impl.command.CommandScheduler;
2527
import io.vertx.sqlclient.impl.command.ExtendedBatchQueryCommand;
2628
import io.vertx.sqlclient.impl.command.ExtendedQueryCommand;
29+
import io.vertx.sqlclient.impl.command.PrepareStatementCommand;
2730
import io.vertx.sqlclient.impl.command.SimpleQueryCommand;
2831

2932
import java.util.List;
@@ -44,27 +47,28 @@ public SqlResultBuilder(Function<T, R> factory,
4447
this.collector = collector;
4548
}
4649

47-
SqlResultHandler<T, R, L> createHandler(Promise<L> resultHandler) {
48-
return new SqlResultHandler<>(factory, resultHandler);
50+
private SqlResultHandler<T, R, L> createHandler(Promise<L> promise) {
51+
return new SqlResultHandler<>(factory, promise);
4952
}
5053

51-
void execute(CommandScheduler scheduler,
52-
String sql,
53-
boolean autoCommit,
54-
boolean singleton,
55-
SqlResultHandler<T, R, L> handler) {
56-
SimpleQueryCommand<T> cmd = new SimpleQueryCommand<>(sql, singleton, autoCommit, collector, handler);
57-
scheduler.schedule(cmd, handler);
54+
void executeSimpleQuery(CommandScheduler scheduler,
55+
String sql,
56+
boolean autoCommit,
57+
boolean singleton,
58+
Promise<L> promise) {
59+
SqlResultHandler handler = createHandler(promise);
60+
scheduler.schedule(new SimpleQueryCommand<>(sql, singleton, autoCommit, collector, handler), handler);
5861
}
5962

60-
SqlResultHandler<T, R, L> execute(CommandScheduler scheduler,
61-
PreparedStatement preparedStatement,
62-
boolean autoCommit,
63-
Tuple args,
64-
int fetch,
65-
String cursorId,
66-
boolean suspended,
67-
SqlResultHandler<T, R, L> handler) {
63+
SqlResultHandler<T, R, L> executeExtendedQuery(CommandScheduler scheduler,
64+
PreparedStatement preparedStatement,
65+
boolean autoCommit,
66+
Tuple args,
67+
int fetch,
68+
String cursorId,
69+
boolean suspended,
70+
Promise<L> promise) {
71+
SqlResultHandler handler = createHandler(promise);
6872
String msg = preparedStatement.prepare((TupleInternal) args);
6973
if (msg != null) {
7074
handler.fail(msg);
@@ -83,10 +87,22 @@ SqlResultHandler<T, R, L> execute(CommandScheduler scheduler,
8387
return handler;
8488
}
8589

86-
ExtendedQueryCommand<T> createCommand(PreparedStatement preparedStatement,
87-
boolean autoCommit,
88-
Tuple args,
89-
SqlResultHandler<T, R, L> handler) {
90+
void executeExtendedQuery(CommandScheduler scheduler, String sql, boolean autoCommit, Tuple arguments, Promise<L> promise) {
91+
SqlResultHandler handler = this.createHandler(promise);
92+
BiCommand<PreparedStatement, Boolean> cmd = new BiCommand<>(new PrepareStatementCommand(sql, true), ps -> {
93+
String msg = ps.prepare((TupleInternal) arguments);
94+
if (msg != null) {
95+
return Future.failedFuture(msg);
96+
}
97+
return Future.succeededFuture(createExtendedQueryCommand(ps, autoCommit, arguments, handler));
98+
});
99+
scheduler.schedule(cmd, handler);
100+
}
101+
102+
private ExtendedQueryCommand<T> createExtendedQueryCommand(PreparedStatement preparedStatement,
103+
boolean autoCommit,
104+
Tuple args,
105+
SqlResultHandler<T, R, L> handler) {
90106
return new ExtendedQueryCommand<>(
91107
preparedStatement,
92108
args,
@@ -95,12 +111,12 @@ ExtendedQueryCommand<T> createCommand(PreparedStatement preparedStatement,
95111
handler);
96112
}
97113

98-
99-
void executeBatch(CommandScheduler scheduler,
100-
PreparedStatement preparedStatement,
101-
boolean autoCommit,
102-
List<Tuple> argsList,
103-
SqlResultHandler<T, R, L> handler) {
114+
void executeBatchQuery(CommandScheduler scheduler,
115+
PreparedStatement preparedStatement,
116+
boolean autoCommit,
117+
List<Tuple> argsList,
118+
Promise<L> promise) {
119+
SqlResultHandler handler = createHandler(promise);
104120
for (Tuple args : argsList) {
105121
String msg = preparedStatement.prepare((TupleInternal)args);
106122
if (msg != null) {
@@ -112,10 +128,23 @@ void executeBatch(CommandScheduler scheduler,
112128
scheduler.schedule(cmd, handler);
113129
}
114130

115-
ExtendedBatchQueryCommand<T> createBatchCommand(PreparedStatement preparedStatement,
116-
boolean autoCommit,
117-
List<Tuple> argsList,
118-
SqlResultHandler<T, R, L> handler) {
119-
return new ExtendedBatchQueryCommand<>(preparedStatement, argsList, autoCommit, collector, handler);
131+
void executeBatchQuery(CommandScheduler scheduler, String sql, boolean autoCommit, List<Tuple> batch, Promise<L> promise) {
132+
SqlResultHandler handler = this.createHandler(promise);
133+
BiCommand<PreparedStatement, Boolean> cmd = new BiCommand<>(new PrepareStatementCommand(sql, true), ps -> {
134+
for (Tuple args : batch) {
135+
String msg = ps.prepare((TupleInternal) args);
136+
if (msg != null) {
137+
return Future.failedFuture(msg);
138+
}
139+
}
140+
return Future.succeededFuture(createBatchQueryCommand(ps, autoCommit, batch, handler));
141+
});
142+
scheduler.schedule(cmd, handler);
120143
}
121-
}
144+
145+
private ExtendedBatchQueryCommand<T> createBatchQueryCommand(PreparedStatement preparedStatement,
146+
boolean autoCommit,
147+
List<Tuple> argsList,
148+
SqlResultHandler<T, R, L> handler) {
149+
return new ExtendedBatchQueryCommand<>(preparedStatement, argsList, autoCommit, collector, handler);
150+
}}

0 commit comments

Comments
 (0)