private Query createQuery(boolean forCount) { SQLSerializer serializer = new SQLSerializer(configuration); if (union != null) { serializer.serializeUnion(union, queryMixin.getMetadata(), unionAll); } else { serializer.serialize(queryMixin.getMetadata(), forCount); } // create Query if (logger.isDebugEnabled()) { logger.debug(serializer.toString()); } Query query = persistenceManager.newQuery("javax.jdo.query.SQL",serializer.toString()); orderedConstants = serializer.getConstants(); queries.add(query); if (!forCount) { List<? extends Expression<?>> projection = queryMixin.getMetadata().getProjection(); if (projection.get(0) instanceof FactoryExpression) { this.projection = (FactoryExpression<?>)projection.get(0); } } else { query.setResultClass(Long.class); } return query; }
void serializeForDelete(QueryMetadata metadata, RelationalPath<?> entity) { serialize(Position.START, metadata.getFlags()); if (!serialize(Position.START_OVERRIDE, metadata.getFlags())) { append(templates.getDelete()); } serialize(Position.AFTER_SELECT, metadata.getFlags()); append("from "); dmlWithSchema = true; handle(entity); dmlWithSchema = false; if (metadata.getWhere() != null) { append(templates.getWhere()).handle(metadata.getWhere()); } }
protected SQLSerializer createSerializer() { SQLSerializer serializer = new SQLSerializer(configuration); serializer.setUseLiterals(useLiterals); return serializer; }
@Override public String toString() { SQLSerializer serializer = createSerializer(); serializer.serializeInsert(metadata, entity, columns, values, subQuery); return serializer.toString(); }
@Override public String toString() { SQLSerializer serializer = createSerializer(); serializer.serializeDelete(metadata, entity); return serializer.toString(); }
private PreparedStatement prepareStatementAndSetParameters(SQLSerializer serializer, boolean withKeys) throws SQLException { listeners.prePrepare(context); queryString = serializer.toString(); constants = serializer.getConstants(); logQuery(logger, queryString, constants); PreparedStatement stmt; if (withKeys) { String[] target = new String[keys.size()]; for (int i = 0; i < target.length; i++) { target[i] = ColumnMetadata.getName(getKeys().get(i)); } stmt = connection.prepareStatement(queryString, target); } else { stmt = connection.prepareStatement(queryString); } setParameters(stmt, serializer.getConstants(), serializer.getConstantPaths(), metadata.getParams()); context.addPreparedStatement(stmt); listeners.prepared(context); return stmt; }
@Override public void serialize(QueryMetadata metadata, boolean forCountRow, SQLSerializer context) { if (!forCountRow && metadata.getModifiers().isRestricting() && !metadata.getJoins().isEmpty()) { QueryModifiers mod = metadata.getModifiers(); if (mod.getOffset() == null) { context.append(limitQueryStart); context.serializeForQuery(metadata, forCountRow); context.handle(limitQueryEnd, mod.getLimit()); } else { context.append(outerQueryStart); context.serializeForQuery(metadata, forCountRow); context.append(outerQueryEnd); if (mod.getLimit() == null) { context.handle(offsetTemplate, mod.getOffset()); } else { context.handle(limitOffsetTemplate, mod.getOffset(), mod.getLimit()); } } } else { context.serializeForQuery(metadata, forCountRow); } if (!metadata.getFlags().isEmpty()) { context.serialize(Position.END, metadata.getFlags()); } }
@Override public String toString() { if (!queryMixin.getMetadata().getJoins().isEmpty()) { SQLSerializer serializer = new SQLSerializer(configuration); serializer.serialize(queryMixin.getMetadata(), false); return serializer.toString().trim(); } else { return super.toString(); } }
private PreparedStatement createStatement() throws SQLException{ listeners.preRender(context); SQLSerializer serializer = createSerializer(); serializer.serializeUpdate(metadata, entity, updates); queryString = serializer.toString(); constants = serializer.getConstants(); logQuery(logger, queryString, constants); context.addSQL(queryString); listeners.prepared(context); listeners.prePrepare(context); PreparedStatement stmt = connection.prepareStatement(queryString); setParameters(stmt, serializer.getConstants(), serializer.getConstantPaths(), metadata.getParams()); context.addPreparedStatement(stmt); listeners.prepared(context); return stmt; }
private PreparedStatement createStatement() throws SQLException{ listeners.preRender(context); SQLSerializer serializer = createSerializer(); serializer.serializeDelete(metadata, entity); queryString = serializer.toString(); constants = serializer.getConstants(); logQuery(logger, queryString, constants); context.addSQL(queryString); listeners.rendered(context); listeners.prePrepare(context); PreparedStatement stmt = connection.prepareStatement(queryString); setParameters(stmt, serializer.getConstants(), serializer.getConstantPaths(), metadata.getParams()); context.addPreparedStatement(stmt); listeners.prepared(context); return stmt; }
serializer.serializeMerge(metadata, entity, batches.get(0).getKeys(), batches.get(0).getColumns(), batches.get(0).getValues(), batches.get(0).getSubQuery()); context.addSQL(serializer.toString()); listeners.rendered(context); stmts.put(serializer.toString(), stmt); if (addBatches) { stmt.addBatch(); SQLMergeBatch batch = batches.get(i); serializer = createSerializer(); serializer.serializeMerge(metadata, entity, batch.getKeys(), batch.getColumns(), batch.getValues(), batch.getSubQuery()); stmt = stmts.get(serializer.toString()); if (stmt == null) { stmt = prepareStatementAndSetParameters(serializer, withKeys); stmts.put(serializer.toString(), stmt); } else { setParameters(stmt, serializer.getConstants(), serializer.getConstantPaths(), metadata.getParams());
append(templates.getWithRecursive()); } else { append(templates.getWith()); handle(", ", withFlags); append("\n"); serialize(Position.START, flags); stage = Stage.SELECT; if (forCountRow) { append(templates.getSelect()); if (hasFlags) { serialize(Position.AFTER_SELECT, flags); append(templates.getCountStar()); if (!groupBy.isEmpty()) { append(templates.getFrom()); append("("); append(templates.getSelect()); append("1 as one "); suffix = ") internal"; List<? extends Expression<?>> columns; if (sqlSelect.isEmpty()) { columns = getIdentifierColumns(joins, !templates.isCountDistinctMultipleColumns()); } else { columns = sqlSelect;
protected SQLBindings createBindings(QueryMetadata metadata, SQLSerializer serializer) { String queryString = serializer.toString(); ImmutableList.Builder<Object> args = ImmutableList.builder(); Map<ParamExpression<?>, Object> params = metadata.getParams(); for (Object o : serializer.getConstants()) { if (o instanceof ParamExpression) { if (!params.containsKey(o)) { throw new ParamNotSetException((ParamExpression<?>) o); } o = metadata.getParams().get(o); } args.add(o); } return new SQLBindings(queryString, args.build()); }
if (dml) { if (path.equals(entity) && path instanceof RelationalPath<?>) { SchemaAndTable schemaAndTable = getSchemaAndTable((RelationalPath<?>) path); boolean precededByDot; if (dmlWithSchema && templates.isPrintSchema()) { appendSchemaName(schemaAndTable.getSchema()); append("."); precededByDot = true; } else { precededByDot = false; appendTableName(schemaAndTable.getTable(), precededByDot); return null; } else if (entity.equals(path.getMetadata().getParent()) && skipParent) { appendAsColumnName(path, false); return null; boolean precededByDot; if (metadata.getParent() != null && (!skipParent || dml)) { visit(metadata.getParent(), context); append("."); precededByDot = true; } else { precededByDot = false; appendAsColumnName(path, precededByDot); return null;
append(", "); handle(flag.getFlag()); handled = true; prepend(templates.getWithRecursive()); } else { prepend(templates.getWith()); append("\n"); handle(union); stage = Stage.GROUP_BY; if (hasFlags) { serialize(Position.BEFORE_GROUP_BY, flags); append(templates.getGroupBy()).handle(COMMA, groupBy); if (hasFlags) { serialize(Position.AFTER_GROUP_BY, flags); stage = Stage.HAVING; if (hasFlags) { serialize(Position.BEFORE_HAVING, flags); append(templates.getHaving()).handle(having); if (hasFlags) { serialize(Position.AFTER_HAVING, flags);
serializer.serializeInsert(metadata, entity, batches.get(0).getColumns(), batches .get(0).getValues(), batches.get(0).getSubQuery()); PreparedStatement stmt = prepareStatementAndSetParameters(serializer, withKeys); stmt.addBatch(); stmts.put(serializer.toString(), stmt); context.addSQL(serializer.toString()); listeners.rendered(context); serializer.serializeInsert(metadata, entity, batch.getColumns(), batch.getValues(), batch.getSubQuery()); context.addSQL(serializer.toString()); listeners.rendered(context); stmt = stmts.get(serializer.toString()); if (stmt == null) { stmt = prepareStatementAndSetParameters(serializer, withKeys); stmts.put(serializer.toString(), stmt); } else { setParameters(stmt, serializer.getConstants(), serializer.getConstantPaths(), metadata.getParams());
String dummyTable = templates.getDummyTable(); if (!Strings.isNullOrEmpty(dummyTable)) { append(templates.getFrom()); append(dummyTable); append(templates.getFrom()); for (int i = 0; i < joins.size(); i++) { final JoinExpression je = joins.get(i); if (je.getFlags().isEmpty()) { if (i > 0) { append(templates.getJoinSymbol(je.getType())); handleJoinTarget(je); if (je.getCondition() != null) { append(templates.getOn()).handle(je.getCondition()); serialize(JoinFlag.Position.START, je.getFlags()); if (!serialize(JoinFlag.Position.OVERRIDE, je.getFlags()) && i > 0) { append(templates.getJoinSymbol(je.getType())); serialize(JoinFlag.Position.BEFORE_TARGET, je.getFlags()); handleJoinTarget(je); serialize(JoinFlag.Position.BEFORE_CONDITION, je.getFlags()); if (je.getCondition() != null) { append(templates.getOn()).handle(je.getCondition()); serialize(JoinFlag.Position.END, je.getFlags());
@Override public void serializeUpdate(QueryMetadata metadata, RelationalPath<?> entity, List<Pair<Path<?>, Expression<?>>> updates, SQLSerializer context) { context.serializeForUpdate(metadata, entity, updates); // limit if (metadata.getModifiers().isRestricting()) { serializeModifiersForDML(metadata, context); } if (!metadata.getFlags().isEmpty()) { context.serialize(Position.END, metadata.getFlags()); } }
@Override public void serializeDelete(QueryMetadata metadata, RelationalPath<?> entity, SQLSerializer context) { context.serializeForDelete(metadata, entity); // limit if (metadata.getModifiers().isRestricting()) { serializeModifiersForDML(metadata, context); } if (!metadata.getFlags().isEmpty()) { context.serialize(Position.END, metadata.getFlags()); } }