public void addBindings(SPARQLQuery query, QueryMetadata md) { for (Map.Entry<Object, String> entry : getConstantToLabel().entrySet()) { if (entry.getKey() instanceof ParamExpression<?>) { if (md.getParams().containsKey(entry.getKey())) { query.setBinding(entry.getValue(), (NODE) md.getParams().get(entry.getKey())); } } else { query.setBinding(entry.getValue(), (NODE) entry.getKey()); } } }
private Map<String, Object> getConstants(QueryMetadata metadata, Map<Object, String> constantToLabel) { Map<String,Object> constants = new HashMap<String,Object>(); for (Map.Entry<Object,String> entry : constantToLabel.entrySet()) { if (entry.getKey() instanceof ParamExpression<?>) { Object value = metadata.getParams().get(entry.getKey()); if (value == null) { throw new ParamNotSetException((ParamExpression<?>) entry.getKey()); } constants.put(entry.getValue(), value); } else { constants.put(entry.getValue(), entry.getKey()); } } return constants; }
@Override public SQLInsertClause select(SubQueryExpression<?> sq) { subQuery = sq; for (Map.Entry<ParamExpression<?>, Object> entry : sq.getMetadata().getParams().entrySet()) { metadata.setParam((ParamExpression) entry.getKey(), entry.getValue()); } return this; }
@Override public Var visit(ParamExpression<?> expr, QueryMetadata md) { Var var = paramToVar.get(expr); if (var == null) { var = new Var(expr.getName()); if (md.getParams().containsKey(expr)) { var.setValue(dialect.getNode((NODE) md.getParams().get(expr))); } paramToVar.put(expr, var); } return var; }
@Override public Var visit(ParamExpression<?> expr, QueryMetadata md) { Var var = paramToVar.get(expr); if (var == null) { var = new Var(expr.getName()); if (md.getParams().containsKey(expr)) { var.setValue(dialect.getNode((NODE) md.getParams().get(expr))); } paramToVar.put(expr, var); } return var; }
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()); }
@SuppressWarnings("unchecked") @Override public TupleExpr visit(SubQueryExpression<?> expr, QueryMetadata md) { for (Map.Entry<ParamExpression<?>, Object> entry : md.getParams().entrySet()) { expr.getMetadata().setParam((ParamExpression) entry.getKey(), entry.getValue()); } return visit(expr.getMetadata(), QueryLanguage.TUPLE); }
@SuppressWarnings("unchecked") @Override public TupleExpr visit(SubQueryExpression<?> expr, QueryMetadata md) { for (Map.Entry<ParamExpression<?>, Object> entry : md.getParams().entrySet()){ expr.getMetadata().setParam((ParamExpression)entry.getKey(), entry.getValue()); } return visit(expr.getMetadata(), QueryLanguage.TUPLE); }
@SuppressWarnings("unchecked") @Override public TupleExpr visit(SubQueryExpression<?> expr, QueryMetadata md) { for (Map.Entry<ParamExpression<?>, Object> entry : md.getParams().entrySet()) { expr.getMetadata().setParam((ParamExpression) entry.getKey(), entry.getValue()); } return visit(expr.getMetadata(), QueryLanguage.TUPLE); }
@SuppressWarnings("unchecked") @Override public Void visit(SubQueryExpression<?> expr, Void context) { for (Map.Entry<ParamExpression<?>, Object> entry : metadata.getParams().entrySet()) { expr.getMetadata().setParam((ParamExpression) entry.getKey(), entry.getValue()); } if (!operators.isEmpty() && operators.peek() == Ops.EXISTS) { handle(expr.getMetadata().getWhere()); } else { visit(expr.getMetadata(), QueryLanguage.TUPLE); } return null; }
@Override public long execute() { HQLSerializer serializer = new HQLSerializer(templates); serializer.serializeForDelete(metadata); Map<Object,String> constants = serializer.getConstantToLabel(); Query query = entityManager.createQuery(serializer.toString()); JPAUtil.setConstants(query, constants, metadata.getParams()); return query.executeUpdate(); }
@Override public long execute() { HQLSerializer serializer = new HQLSerializer(templates); serializer.serializeForUpdate(metadata); Map<Object,String> constants = serializer.getConstantToLabel(); Query query = entityManager.createQuery(serializer.toString()); JPAUtil.setConstants(query, constants, metadata.getParams()); return query.executeUpdate(); }
@SuppressWarnings("unchecked") private Query createQuery(String queryString) { logQuery(queryString); List<? extends Expr<?>> projection = queryMixin.getMetadata().getProjection(); Query query; if (projection.get(0) instanceof EntityPath){ if (projection.size() == 1){ query = session.createSQLQuery(queryString, projection.get(0).getType()); }else{ throw new IllegalArgumentException("Only single element entity projections are supported"); } }else{ query = session.createSQLQuery(queryString); } // set constants JPAUtil.setConstants(query, constants, queryMixin.getMetadata().getParams()); return query; }
@Override public long execute() { HQLSerializer serializer = new HQLSerializer(templates); serializer.serializeForUpdate(metadata); Map<Object, String> constants = serializer.getConstantToLabel(); Query query = session.createQuery(serializer.toString()); HibernateUtil.setConstants(query, constants, metadata.getParams()); return query.executeUpdate(); }
@Override public long execute() { HQLSerializer serializer = new HQLSerializer(templates); serializer.serializeForDelete(md); Map<Object,String> constants = serializer.getConstantToLabel(); Query query = session.createQuery(serializer.toString()); HibernateUtil.setConstants(query, constants, md.getParams()); return query.executeUpdate(); }
@Override public void parse() throws RecognitionException, TokenStreamException { try { System.out.println("query : " + toString().replace('\n', ' ')); JPQLSerializer serializer = new JPQLSerializer(HQLTemplates.DEFAULT); serializer.serialize(getMetadata(), false, null); Query query = session.createQuery(serializer.toString()); HibernateUtil.setConstants(query, serializer.getConstantToLabel(), getMetadata().getParams()); query.list(); } catch (Exception e) { e.printStackTrace(); throw new RuntimeException(e); } finally { System.out.println(); } } };
@Override public void parse() throws RecognitionException, TokenStreamException { JPQLSerializer serializer = new JPQLSerializer(templates); serializer.serialize(getMetadata(), false, null); Query query = em.createQuery(serializer.toString()); JPAUtil.setConstants(query, serializer.getConstantToLabel(), getMetadata().getParams()); try { query.getResultList(); } catch (Exception e) { e.printStackTrace(); throw new RuntimeException(e); } } };
@Override public Void visit(SubQueryExpression<?> expr, QueryMetadata context) { QueryMetadata md = expr.getMetadata(); for (Map.Entry<ParamExpression<?>, Object> entry : md.getParams().entrySet()) { context.setParam((ParamExpression)entry.getKey(), entry.getValue()); } visit(md.getGroupBy(), context); visit(md.getHaving(), context); for (JoinExpression join : md.getJoins()) { visit(join.getTarget(), context); visit(join.getCondition(), context); } visit(md.getProjection(), context); visit(md.getWhere(), context); return null; }
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; }