@Test public void visitTemplateExpressionOfQVoid() { validator.visit((TemplateExpression) Expressions.template(Object.class, "XXX"), known); }
@Test public void template() { assertEquals("a && b", Expressions.template(Object.class, "{0} && {1}", a, b).toString()); }
@Test public void factoryMethods() { String template = ""; Expression<Boolean> arg = ConstantImpl.create(true); Expressions.booleanTemplate(template, arg); Expressions.comparableTemplate(String.class, template, arg); Expressions.dateTemplate(Date.class, template, arg); Expressions.dateTimeTemplate(Date.class, template, arg); Expressions.enumTemplate(PropertyType.class, template, arg); Expressions.numberTemplate(Integer.class, template, arg); Expressions.template(Object.class, template, arg); Expressions.stringTemplate(template, arg); Expressions.timeTemplate(Time.class, template, arg); }
@Test public void factoryMethods2() { Template template = TemplateFactory.DEFAULT.create(""); Expression<Boolean> arg = ConstantImpl.create(true); Expressions.booleanTemplate(template, arg); Expressions.comparableTemplate(String.class, template, arg); Expressions.dateTemplate(Date.class, template, arg); Expressions.dateTimeTemplate(Date.class, template, arg); Expressions.enumTemplate(PropertyType.class, template, arg); Expressions.numberTemplate(Integer.class, template, arg); Expressions.template(Object.class, template, arg); Expressions.stringTemplate(template, arg); Expressions.timeTemplate(Time.class, template, arg); } }
SimpleExpression<T> getValue() { if (value == null) { if (orderBy.isEmpty()) { // TODO this check should be static throw new IllegalStateException("No order by arguments given"); } ImmutableList.Builder<Expression<?>> args = ImmutableList.builder(); StringBuilder builder = new StringBuilder(); builder.append("{0} keep (dense_rank "); args.add(target); builder.append(first ? "first " : "last "); builder.append(ORDER_BY); builder.append("{1}"); args.add(ExpressionUtils.orderBy(orderBy)); builder.append(")"); value = Expressions.template(target.getType(), builder.toString(), args.build()); } return value; }
private AbstractSQLInsertClause<?> onDuplicateUpdates(AbstractSQLInsertClause<?> insert, Collection<Path<?>> duplicates) { if (duplicates != null && !duplicates.isEmpty()) { insert.addFlag(QueryFlag.Position.END, " ON DUPLICATE KEY UPDATE "); boolean first = true; for (Path<?> duplicate : duplicates) { insert.addFlag(QueryFlag.Position.END, Expressions.template(Object.class, first ? "{0} = VALUES({0})" : ", {0} = VALUES({0})", duplicate)); first = false; } } return insert; }
/** * adds a DISTINCT ON clause * * @param exprs * @return */ @WithBridgeMethods(value = PostgreSQLQuery.class, castRequired = true) public C distinctOn(Expression<?>... exprs) { return addFlag(Position.AFTER_SELECT, Expressions.template(Object.class, "distinct on({0}) ", ExpressionUtils.list(Object.class, exprs))); }
/** * Add the given prefix and expression as a general query flag * * @param position position of the flag * @param prefix prefix for the flag * @param expr expression of the flag * @return the current object */ @Override public Q addFlag(Position position, String prefix, Expression<?> expr) { Expression<?> flag = Expressions.template(expr.getType(), prefix + "{0}", expr); return queryMixin.addFlag(new QueryFlag(position, flag)); }
@Override public void serializeDelete(QueryMetadata metadata, RelationalPath<?> entity, SQLSerializer context) { // limit QueryModifiers mod = metadata.getModifiers(); if (mod.isRestricting()) { metadata = metadata.clone(); metadata.addFlag(new QueryFlag(QueryFlag.Position.AFTER_SELECT, Expressions.template(Integer.class, topTemplate, mod.getLimit()))); } context.serializeForDelete(metadata, entity); if (!metadata.getFlags().isEmpty()) { context.serialize(Position.END, metadata.getFlags()); } }
@Override public void serializeDelete(QueryMetadata metadata, RelationalPath<?> entity, SQLSerializer context) { // limit QueryModifiers mod = metadata.getModifiers(); if (mod.isRestricting()) { metadata = metadata.clone(); metadata.addFlag(new QueryFlag(QueryFlag.Position.AFTER_SELECT, Expressions.template(Integer.class, topTemplate, mod.getLimit()))); } context.serializeForDelete(metadata, entity); if (!metadata.getFlags().isEmpty()) { context.serialize(Position.END, metadata.getFlags()); } }
@Override @SuppressWarnings("unchecked") @Test public void union() { SimpleExpression<Integer> one = Expressions.template(Integer.class, "1"); SimpleExpression<Integer> two = Expressions.template(Integer.class,"2"); SimpleExpression<Integer> three = Expressions.template(Integer.class,"3"); NumberPath<Integer> col1 = Expressions.numberPath(Integer.class, "col1"); Union union = query.union( select(one.as(col1)), select(two), select(three)); assertEquals( "(select 1 col1 from dual)\n" + "union\n" + "(select 2 from dual)\n" + "union\n" + "(select 3 from dual)", union.toString()); }
@Test @IncludeIn(POSTGRESQL) // TODO generalize array literal projections public void array() { Expression<Integer[]> expr = Expressions.template(Integer[].class, "'{1,2,3}'::int[]"); Integer[] result = firstResult(expr); assertEquals(3, result.length); assertEquals(1, result[0].intValue()); assertEquals(2, result[1].intValue()); assertEquals(3, result[2].intValue()); }
@Override public void serializeUpdate(QueryMetadata metadata, RelationalPath<?> entity, Map<Path<?>, Expression<?>> updates, SQLSerializer context) { // limit QueryModifiers mod = metadata.getModifiers(); if (mod.isRestricting()) { metadata = metadata.clone(); metadata.addFlag(new QueryFlag(QueryFlag.Position.AFTER_SELECT, Expressions.template(Integer.class, topTemplate, mod.getLimit()))); } context.serializeForUpdate(metadata, entity, updates); if (!metadata.getFlags().isEmpty()) { context.serialize(Position.END, metadata.getFlags()); } }
@Override public void serializeUpdate(QueryMetadata metadata, RelationalPath<?> entity, Map<Path<?>, Expression<?>> updates, SQLSerializer context) { // limit QueryModifiers mod = metadata.getModifiers(); if (mod.isRestricting()) { metadata = metadata.clone(); metadata.addFlag(new QueryFlag(QueryFlag.Position.AFTER_SELECT, Expressions.template(Integer.class, topTemplate, mod.getLimit()))); } context.serializeForUpdate(metadata, entity, updates); if (!metadata.getFlags().isEmpty()) { context.serialize(Position.END, metadata.getFlags()); } }
@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) { // select top ... metadata = metadata.clone(); metadata.addFlag(new QueryFlag(QueryFlag.Position.AFTER_SELECT, Expressions.template(Integer.class, topTemplate, mod.getLimit()))); context.serializeForQuery(metadata, forCountRow); } else { throw new IllegalStateException("offset not supported"); } } else { context.serializeForQuery(metadata, forCountRow); } if (!metadata.getFlags().isEmpty()) { context.serialize(Position.END, metadata.getFlags()); } }
@Test @ExcludeIn({DERBY, HSQLDB}) public void array_null() { Expression<Integer[]> expr = Expressions.template(Integer[].class, "null"); assertNull(firstResult(expr)); }
@Override public void serialize(QueryMetadata metadata, boolean forCountRow, SQLSerializer context) { if (!forCountRow && metadata.getModifiers().isRestricting() && metadata.getOrderBy().isEmpty() && !metadata.getJoins().isEmpty()) { metadata = metadata.clone(); QueryModifiers mod = metadata.getModifiers(); // use top if order by is empty if (mod.getOffset() == null) { // select top ... metadata.addFlag(new QueryFlag(QueryFlag.Position.AFTER_SELECT, Expressions.template(Integer.class, topTemplate, mod.getLimit()))); } else { // order by first column metadata.addOrderBy(Expressions.ONE.asc()); } } context.serializeForQuery(metadata, forCountRow); if (!metadata.getFlags().isEmpty()) { context.serialize(Position.END, metadata.getFlags()); } }
@Test @IncludeIn(POSTGRESQL) // TODO generalize array literal projections public void array2() { Expression<int[]> expr = Expressions.template(int[].class, "'{1,2,3}'::int[]"); int[] result = firstResult(expr); assertEquals(3, result.length); assertEquals(1, result[0]); assertEquals(2, result[1]); assertEquals(3, result[2]); }
@Test public void from_function() { SQLQuery<?> query = query(); query.from(Expressions.template(Survey.class, "functionCall()")).join(survey); query.where(survey.name.isNotNull()); assertEquals("from functionCall()\njoin SURVEY SURVEY\nwhere SURVEY.NAME is not null", query.toString()); }
@Test public void test() { Template template = TemplateFactory.DEFAULT.create("fetch first {0s} rows only"); assertTrue(template.getElements().get(1) instanceof Template.AsString); SQLSerializer serializer = new SQLSerializer(new Configuration(new DerbyTemplates())); serializer.handle(Expressions.template(Object.class, template, ConstantImpl.create(5))); assertEquals("fetch first 5 rows only", serializer.toString()); }