@Override public Path<String> createStringPath(PathMetadata metadata) { return Expressions.stringPath(metadata); }
/** * Create a new variable path * * @param arg alias * @return expression */ public static StringPath var(String arg) { return Expressions.stringPath(arg.replace(' ', '_')); }
@Test public void newInstance() { QList qList = new QList(Expressions.stringPath("a"), Expressions.stringPath("b")); List<?> list = qList.newInstance("a", null); assertEquals(2, list.size()); assertEquals("a", list.get(0)); assertNull(list.get(1)); }
@Test public void operation() { Expression<String> str = Expressions.stringPath(ExpressionUtils.path(Object.class, "customer"), "name"); Expression<String> str2 = Expressions.stringPath("str"); Expression<String> concat = Expressions.stringOperation(Ops.CONCAT, str, str2); assertEquals("customer.name + str", concat.toString()); assertEquals("customer_.name + str_", concat.accept(visitor, null).toString()); }
@Test public void templateExpression() { Expression<String> str = Expressions.stringPath(ExpressionUtils.path(Object.class, "customer"), "name"); Expression<String> str2 = Expressions.stringPath("str"); Expression<String> concat = Expressions.stringTemplate("{0} + {1}", str, str2); assertEquals("customer.name + str", concat.toString()); assertEquals("customer_.name + str_", concat.accept(visitor, null).toString()); } }
@Test public void order() { OrderSpecifier<?> order = new OrderSpecifier<String>(Order.ASC, Expressions.stringPath("str")); assertEquals(order, Serialization.serialize(order)); }
@Test public void compile() { StringExpression str = Expressions.stringPath("str"); GroupExpression<String, String> strGroup = new GOne<String>(str); GroupBy.sortedMap(strGroup, str, null); GroupBy.sortedMap(str, strGroup, null); }
@Test public void stringPathPathOfQString() { assertEquals("variable.property", Expressions.stringPath(Expressions.path(Object.class, "variable"), "property").toString()); }
@Test(expected = IllegalArgumentException.class) public void illegal() { StringPath string = Expressions.stringPath("path"); EnumConversion<String> conv = new EnumConversion<String>(string); fail("EnumConversion successfully created for a non-enum type"); conv.newInstance(0); } }
@Test public void number_conversion() { StringPath strPath = Expressions.stringPath("strPath"); NumberPath<Integer> intPath = Expressions.numberPath(Integer.class, "intPath"); QTuple qTuple = Projections.tuple(strPath, intPath); NumberConversions<Tuple> conversions = new NumberConversions<Tuple>(qTuple); Tuple tuple = conversions.newInstance("a", Long.valueOf(3)); assertEquals("a", tuple.get(strPath)); assertEquals(Integer.valueOf(3), tuple.get(intPath)); }
@Test public void deep_population_via_qBean() { StringPath name = Expressions.stringPath("name"); StringPath id = Expressions.stringPath("id"); QBean<Entity2> entity2Bean = new QBean<Entity2>(Entity2.class, name, id); QBean<Entity1> entity1Bean = new QBean<Entity1>(Entity1.class, Collections.singletonMap("entity2", entity2Bean)); Entity1 entity1 = FactoryExpressionUtils.wrap(entity1Bean).newInstance("nameX","idX"); assertEquals("nameX", entity1.getEntity2().getName()); assertEquals("idX", entity1.getEntity2().getId()); }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Before public void setUp() { num = Expressions.numberPath(Integer.class, "num"); str = Expressions.stringPath("str"); date = Expressions.datePath(Date.class, "date"); QueryMixin<?> query = new QueryMixin<Void>(); query.from(num, str); // TODO sub }
@Test public void signature() { StringPath str = Expressions.stringPath("str"); NumberPath<BigDecimal> bigd = Expressions.numberPath(BigDecimal.class, "bigd"); ResultTransformer<Map<String, SortedMap<BigDecimal, SortedMap<BigDecimal, Map<String, String>>>>> resultTransformer = GroupBy.groupBy(str).as( GroupBy.sortedMap(bigd, GroupBy.sortedMap(bigd, GroupBy.map(str, str), Ordering.natural().nullsLast()), Ordering.natural().nullsFirst())); assertNotNull(resultTransformer); }
@Test public void deep_population_via_qTuple() { StringPath name = Expressions.stringPath("name"); StringPath id = Expressions.stringPath("id"); QBean<Entity2> entity2Bean = new QBean<Entity2>(Entity2.class, name, id); QTuple tupleExpr = new QTuple(entity2Bean); Tuple tuple = FactoryExpressionUtils.wrap(tupleExpr).newInstance("nameX","idX"); assertEquals("nameX", tuple.get(entity2Bean).getName()); assertEquals("idX", tuple.get(entity2Bean).getId()); }
@Test public void serialize() throws ClassNotFoundException, IOException { QTuple e = new QTuple(Expressions.stringPath("x"), Expressions.numberPath(Integer.class, "y")); serialize(e); serialize(e.newInstance("a",1)); }
@Test public void safe_number_conversion() { StringPath strPath = Expressions.stringPath("strPath"); NumberPath<Integer> intPath = Expressions.numberPath(Integer.class, "intPath"); QTuple qTuple = Projections.tuple(strPath, intPath); NumberConversions<Tuple> conversions = new NumberConversions<Tuple>(qTuple); assertNotNull(conversions.newInstance(1, 2)); }
@Test public void alias() { Expression<?> expr = str1.as("s"); QTuple qTuple = new QTuple(expr); Tuple tuple = qTuple.newInstance("arg"); assertEquals("arg", tuple.get(expr)); assertEquals("arg", tuple.get(Expressions.stringPath("s"))); }
@Test public void with_class_and_alias_using_fields() { StringPath name2 = Expressions.stringPath("name2"); QBean<Entity> beanProjection = new QBean<Entity>(Entity.class, true, name.as(name2), age, married); Entity bean = beanProjection.newInstance("Fritz", 30, true); assertNull(bean.name); assertEquals("Fritz", bean.name2); assertEquals(30, bean.age); assertEquals(true, bean.married); }
@Test public void regexToLike() { assertEquals("%", like(ConstantImpl.create(".*"))); assertEquals("_", like(ConstantImpl.create("."))); assertEquals(".", like(ConstantImpl.create("\\."))); StringPath path = Expressions.stringPath("path"); assertEquals("path + %", like(path.append(".*"))); assertEquals("% + path", like(path.prepend(".*"))); assertEquals("path + _", like(path.append("."))); assertEquals("_ + path", like(path.prepend("."))); }
@Test public void likeToRegex() { assertEquals(".*", regex(ConstantImpl.create("%"))); assertEquals("^abc.*", regex(ConstantImpl.create("abc%"))); assertEquals(".*abc$", regex(ConstantImpl.create("%abc"))); assertEquals("^.$", regex(ConstantImpl.create("_"))); StringPath path = Expressions.stringPath("path"); assertEquals("path + .*", regex(path.append("%"))); assertEquals(".* + path", regex(path.prepend("%"))); assertEquals("path + .", regex(path.append("_"))); assertEquals(". + path", regex(path.prepend("_"))); }