io.vertx.sqlclient.PreparedQuery Java Examples

private void processConnection(int queries, long conId, long seqCode) {
	
	//only process after we have the prepared statements built.
	PreparedQuery query = selectableQuery();
	if (query==null) {
		return;
	}
	
	PreparedQuery update= updateQuery();
	if (update==null) {
		return;
	}
	
	List<ResultObject> objs = new ArrayList<ResultObject>(queries);
	int q = queries;
	while (--q >= 0) {
			processSingleUpdate(queries, conId, seqCode, objs, query, update);
	
	}
}
 

public SqlTemplateImpl(SqlClient client,
                       SqlTemplate sqlTemplate,
                       Function<PreparedQuery<RowSet<Row>>,
                       PreparedQuery<R>> queryMapper,
                       Function<T, Map<String, Object>> paramsMapper) {
  this.client = client;
  this.sqlTemplate = sqlTemplate;
  this.queryMapper = queryMapper;
  this.paramsMapper = paramsMapper;
}
 

private PreparedQuery selectableQuery() {
	
	if (null!=selectQuery || building) {
		return selectQuery;		
	} else {
		building = true;
		pm.pool().getConnection(h -> {
			
			if (h.succeeded()) {
				SqlConnection connection = h.result();
				
				connection.prepare("SELECT * FROM world WHERE id=$1", ph -> {
					if (ph.succeeded()) {							
						selectQuery = ph.result();	
						
						building = false;
						if (updateQuery==null) {
							updateQuery();
						}
						
					} else {							
						ph.cause().printStackTrace();
					}
				});
				
				connection.close();
			} else {
				h.cause().printStackTrace();
			}
		});
		return null;
	}
}
 

private PreparedQuery updateQuery() {
	
	if (null!=updateQuery || building) {
		return updateQuery;		
	} else {
		building = true;
		pm.pool().getConnection(h -> {
			
			if (h.succeeded()) {
				SqlConnection connection = h.result();
				
				connection.prepare("UPDATE world SET randomnumber=$1 WHERE id=$2", ph -> {
					if (ph.succeeded()) {							
						updateQuery = ph.result();	
						building = false;
						if (selectQuery == null) {
							selectableQuery();
						}
					} 
				});
				
				connection.close();
			} 
			
			
		});
		return null;
	}
}
 

@Override
public PreparedQuery<RowSet<Row>> preparedQuery(String sql) {
    return pool().preparedQuery(sql);
}
 

@Override
public PreparedQuery<RowSet<Row>> preparedQuery(String sql) {
  throw new UnsupportedOperationException();
}
 

@Override
public PreparedQuery<RowSet<Row>> preparedQuery(String sql) {
  QueryExecutor<RowSet<Row>, RowSetImpl<Row>, RowSet<Row>> builder = new QueryExecutor<>(tracer, metrics, RowSetImpl.FACTORY, RowSetImpl.COLLECTOR);
  return new PreparedQueryImpl<>(autoCommit(), false, sql, builder);
}
 

@Override
public <U> PreparedQuery<SqlResult<U>> collecting(Collector<Row, ?, U> collector) {
  return (PreparedQuery<SqlResult<U>>) super.collecting(collector);
}
 

@Override
public <U> PreparedQuery<RowSet<U>> mapping(Function<Row, U> mapper) {
  return (PreparedQuery<RowSet<U>>) super.mapping(mapper);
}
 

@Override
public PreparedQuery<RowSet<Row>> query() {
  QueryExecutor<RowSet<Row>, RowSetImpl<Row>, RowSet<Row>> builder = new QueryExecutor<>(tracer, metrics, RowSetImpl.FACTORY, RowSetImpl.COLLECTOR);
  return new PreparedStatementQuery<>(builder);
}
 

@Override
public <U> PreparedQuery<SqlResult<U>> collecting(Collector<Row, ?, U> collector) {
  return (PreparedQuery<SqlResult<U>>) super.collecting(collector);
}
 

@Override
public <U> PreparedQuery<RowSet<U>> mapping(Function<Row, U> mapper) {
  return (PreparedQuery<RowSet<U>>) super.mapping(mapper);
}
 

@Override
public SqlConnection prepare(String string, Handler<AsyncResult<PreparedQuery>> hndlr) {
  throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
 

@Override
public Future<PreparedQuery> prepare(String string) {
  throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
 

@Override
public PreparedQuery<RowSet<Row>> preparedQuery(String s) {
  return null;
}