@Override public void logBeforeExecution(StatementContext context) { context.getBinding().findForPosition(0).ifPresent(value -> positional = Objects.toString(value)); context.getBinding().findForName(NAME, context).ifPresent(value -> named = Objects.toString(value)); } });
private Binding positionalBinding(int size) { Binding b = new Binding(); for (int i = 0; i < size; i++) { b.addPositional(i, NOP); } return b; }
@Override public void beforeTemplating(PreparedStatement stmt, StatementContext ctx) throws SQLException { final Set<String> alreadyDefined = ctx.getAttributes().keySet(); final Binding binding = ctx.getBinding(); binding.getNames().stream() .filter(name -> !alreadyDefined.contains(name)) .forEach(name -> binding.findForName(name, ctx).ifPresent( a -> ctx.define(name, a instanceof NullArgument ? false : true))); } }
@Override public void logBeforeExecution(StatementContext ctx) { String toString = ctx.getBinding() .findForName(name, ctx) .orElseThrow(AssertionError::new) .toString(); insertedTimestamp = OffsetDateTime.parse(toString); insertedSqlTimestamp = Timestamp.from(insertedTimestamp.toInstant()); }
private static void bindNamed(ParsedParameters params, Binding binding, PreparedStatement statement, StatementContext context) { List<String> paramNames = params.getParameterNames(); // best effort: compare empty to non-empty because we can't list the individual binding names (unless we expose a method to do so) boolean argumentsProvidedButNoneDeclared = paramNames.isEmpty() && !binding.isEmpty(); if (argumentsProvidedButNoneDeclared && !context.getConfig(SqlStatements.class).isUnusedBindingAllowed()) { throw new UnableToCreateStatementException(String.format( "Superfluous named parameters provided while the query " + "declares none: '%s'. This check may be disabled by calling " + "getConfig(SqlStatements.class).setUnusedBindingAllowed(true) " + "or using @AllowUnusedBindings in SQL object.", binding), context); } for (int i = 0; i < paramNames.size(); i++) { final String name = paramNames.get(i); try { binding.findForName(name, context) .orElseThrow(() -> new UnableToCreateStatementException(String.format("Missing named parameter '%s'.", name), context)) .apply(i + 1, statement, context); } catch (SQLException e) { throw new UnableToCreateStatementException(String.format("Exception while binding named parameter '%s'", name), e, context); } } } }
/** * Add the current binding as a saved batch and clear the binding. * @return this */ public PreparedBatch add() { final Binding currentBinding = getBinding(); if (currentBinding.isEmpty()) { throw new IllegalStateException("Attempt to add() an empty batch, you probably didn't mean to do this " + "- call add() *after* setting batch parameters"); } bindings.add(currentBinding); getContext().setBinding(new Binding()); return this; }
@Override public void logBeforeExecution(StatementContext context) { attributes.add(context.getAttributes()); context.getBinding().findForPosition(0).ifPresent(a -> bindings.add(a.toString())); }
/** * Used if you need to have some exotic parameter bound. * * @param name name to bindBinaryStream this argument * @param argument exotic argument factory * * @return the same Query instance */ public This bind(String name, Argument argument) { getBinding().addNamed(name, argument); return typedThis; }
/** * Used if you need to have some exotic parameter bound. * * @param position position to bindBinaryStream this argument, starting at 0 * @param argument exotic argument factory * * @return the same Query instance */ @SuppressWarnings("unchecked") public This bind(int position, Argument argument) { getBinding().addPositional(position, argument); return (This) this; }
/** * Add the current binding as a saved batch and clear the binding. * @return this */ public PreparedBatch add() { bindings.add(getBinding()); getContext().setBinding(new Binding()); return this; }
/** * Binds a new {@link NamedArgumentFinder}. * * @param namedArgumentFinder A NamedArgumentFinder to bind. Can be null. * * @return the same Query instance */ public This bindNamedArgumentFinder(final NamedArgumentFinder namedArgumentFinder) { if (namedArgumentFinder != null) { getBinding().addNamedArgumentFinder(namedArgumentFinder); } return typedThis; }
private ExecutedBatch internalBatchExecute() { if (!getBinding().isEmpty()) { add();
@Test public void testContextGetsBinding() { try { h.prepareBatch("insert into something (id, name) values (:id, :name)") .bind("id", 0) .bind("name", "alice") .add() .bind("id", 0) .bind("name", "bob") .add() .execute(); fail("expected exception"); } catch (UnableToExecuteStatementException e) { final StatementContext ctx = e.getStatementContext(); assertThat(ctx.getBinding().findForName("name", ctx).toString()).contains("bob"); } }
@Override public void logException(StatementContext context, SQLException ex) { attributes.add(context.getAttributes()); context.getBinding().findForPosition(0).ifPresent(a -> bindings.add(a.toString())); }
/** * Register a named output parameter * @param name the parameter name * @param sqlType an SQL type constant as defined by {@link java.sql.Types} or by the JDBC vendor. * @param mapper a mapper which converts the {@link CallableStatement} to a desired output type. * @return self */ public Call registerOutParameter(String name, int sqlType, CallableStatementMapper mapper) { getBinding().addNamed(name, new OutParamArgument(sqlType, mapper, name)); return this; }
/** * Register a positional output parameter * @param position the parameter position (zero-based) * @param sqlType an SQL type constant as defined by {@link java.sql.Types} or by the JDBC vendor. * @param mapper a mapper which converts the {@link CallableStatement} to a desired output type. * @return self */ public Call registerOutParameter(int position, int sqlType, CallableStatementMapper mapper) { getBinding().addPositional(position, new OutParamArgument(sqlType, mapper, null)); return this; }
/** * Binds a new {@link NamedArgumentFinder}. * * @param namedArgumentFinder A NamedArgumentFinder to bind. Can be null. * * @return the same Query instance */ public This bindNamedArgumentFinder(final NamedArgumentFinder namedArgumentFinder) { if (namedArgumentFinder != null) { getBinding().addNamedArgumentFinder(namedArgumentFinder); } return typedThis; }
private static void bindNamed(List<String> parameterNames, Binding binding, PreparedStatement statement, StatementContext context) { for (int i = 0; i < parameterNames.size(); i++) { String param = parameterNames.get(i); try { binding.findForName(param, context) .orElseThrow(() -> new UnableToExecuteStatementException( String.format("Unable to execute, no named parameter matches '%s'.", param), context)) .apply(i + 1, statement, context); } catch (SQLException e) { throw new UnableToCreateStatementException( String.format("Exception while binding named parameter '%s'", param), e, context); } } } }