Java Examples for org.springframework.data.repository.query.parser.PartTree

@Test
public void should_create_corect_query_for_complex_operators() {
    final String methodName = "getByItemNameLikeOrAgeGreaterThanAndAgeLessThan";
    final PartTree tree = new PartTree(methodName, SimpleDbSampleEntity.class);
    final String query = PartTreeConverter.toIndexedQuery(tree);
    final String expected = " itemName LIKE ? OR age > ? AND age < ? ";
    assertEquals(expected, query);
}

@SuppressWarnings("unchecked")
private <T> Query<T> createQueryForMethodWithArgs(String methodName, Object... args) throws NoSuchMethodException, SecurityException {
    Class<?>[] argTypes = new Class<?>[args.length];
    if (!ObjectUtils.isEmpty(args)) {
        for (int i = 0; i < args.length; i++) {
            argTypes[i] = args[i].getClass();
        }
    }
    Method method = PersonRepository.class.getMethod(methodName, argTypes);
    PartTree partTree = new PartTree(method.getName(), Person.class);
    AerospikeQueryCreator creator = new AerospikeQueryCreator(partTree, new ParametersParameterAccessor(new QueryMethod(method, repositoryMetaData, new SpelAwareProxyProjectionFactory()).getParameters(), args));
    Query<T> q = (Query<T>) creator.createQuery();
    return q;
}

// DATAJPA-1044
@Test
public void distinctFlagOnCountQueryIssuesCountDistinct() throws Exception {
    Method method = SomeRepository.class.getMethod("findDistinctByRolesIn", List.class);
    PersistenceProvider provider = PersistenceProvider.fromEntityManager(entityManager);
    JpaQueryMethod queryMethod = new JpaQueryMethod(method, AbstractRepositoryMetadata.getMetadata(SomeRepository.class), new SpelAwareProxyProjectionFactory(), provider);
    PartTree tree = new PartTree("findDistinctByRolesIn", User.class);
    ParameterMetadataProvider metadataProvider = new ParameterMetadataProvider(entityManager.getCriteriaBuilder(), queryMethod.getParameters(), provider);
    JpaCountQueryCreator creator = new JpaCountQueryCreator(tree, queryMethod.getResultProcessor().getReturnedType(), entityManager.getCriteriaBuilder(), metadataProvider);
    TypedQuery<? extends Object> query = entityManager.createQuery(creator.createQuery());
    assertThat(HibernateUtils.getHibernateQuery(query), startsWith("select distinct count(distinct"));
}

@Test
public void createQueryBuilderWithDistinctQuery() {
    GemfirePersistentEntity<?> mockPersistentEntity = mock(GemfirePersistentEntity.class);
    PartTree mockPartTree = mock(PartTree.class);
    when(mockPersistentEntity.getRegionName()).thenReturn("Example");
    when(mockPartTree.isDistinct()).thenReturn(true);
    QueryBuilder queryBuilder = new QueryBuilder(mockPersistentEntity, mockPartTree);
    assertThat(queryBuilder.toString()).isEqualTo("SELECT DISTINCT * FROM /Example x");
    verify(mockPersistentEntity, times(1)).getRegionName();
    verify(mockPartTree, times(1)).isDistinct();
}

public KeyValueQuery<?> createQuery(ParameterAccessor accessor) {
    PartTree tree = new PartTree(getQueryMethod().getName(), getQueryMethod().getEntityInformation().getJavaType());
    Constructor<? extends AbstractQueryCreator<?, ?>> constructor = ClassUtils.getConstructorIfAvailable(queryCreator, PartTree.class, ParameterAccessor.class);
    KeyValueQuery<?> query = (KeyValueQuery<?>) BeanUtils.instantiateClass(constructor, tree, accessor).createQuery();
    if (tree.isLimiting()) {
        query.setRows(tree.getMaxResults());
    }
    return query;
}

public void validate(CompilationUnit element, SpringDataValidationContext context, IProgressMonitor monitor) {
    try {
        ITypeRoot typeRoot = element.getTypeRoot();
        IType type = typeRoot.findPrimaryType();
        if (!supports(typeRoot))
            return;
        // resolve repository information and generate problem markers
        RepositoryInformation information = new RepositoryInformation(type);
        Class<?> domainClass = information.getManagedDomainClass();
        if (domainClass == null) {
            return;
        }
        for (IMethod method : information.getMethodsToValidate()) {
            String methodName = method.getElementName();
            try {
                new PartTree(methodName, domainClass);
            } catch (PropertyReferenceException e) {
                element.setElementSourceLocation(new JavaModelSourceLocation(method));
                ValidationProblemAttribute start = new ValidationProblemAttribute(IMarker.CHAR_START, method.getNameRange().getOffset());
                ValidationProblemAttribute end = new ValidationProblemAttribute(IMarker.CHAR_END, method.getSourceRange().getOffset() + method.getSourceRange().getLength());
                context.error(element, "INVALID_DERIVED_QUERY", "Invalid derived query! " + e.getMessage(), new ValidationProblemAttribute[] { start, end });
            }
        }
    } catch (JavaModelException e) {
        SpringCore.log(e);
    } catch (Exception e) {
        SpringCore.log(e);
    } catch (Error e) {
        SpringCore.log(e);
    }
}

// DATAMONGO-469
@Test
public void createsAndQueryCorrectly() {
    Person person = new Person();
    MongoQueryCreator creator = new MongoQueryCreator(new PartTree("findByFirstNameAndFriend", Person.class), getAccessor(converter, "Oliver", person), context);
    Query query = creator.createQuery();
    assertThat(query, is(query(where("firstName").is("Oliver").and("friend").is(person))));
}

@Test
public void detectsDistinctCorrectly() throws Exception {
    for (String prefix : PREFIXES) {
        detectsDistinctCorrectly(prefix + "DistinctByLastname", true);
        detectsDistinctCorrectly(prefix + "UsersDistinctByLastname", true);
        detectsDistinctCorrectly(prefix + "DistinctUsersByLastname", true);
        detectsDistinctCorrectly(prefix + "UsersByLastname", false);
        detectsDistinctCorrectly(prefix + "ByLastname", false);
        // Check it's non-greedy (would strip everything until Order*By*
        // otherwise)
        PartTree tree = detectsDistinctCorrectly(prefix + "ByLastnameOrderByFirstnameDesc", false);
        assertThat(tree.getSort()).isEqualTo(Sort.by("firstname").descending());
    }
}

/**
     * @param mtd Method.
     * @param metadata Metadata.
     */
@NotNull
public static IgniteQuery generateSql(Method mtd, RepositoryMetadata metadata) {
    PartTree parts = new PartTree(mtd.getName(), metadata.getDomainType());
    StringBuilder sql = new StringBuilder();
    if (parts.isDelete())
        throw new UnsupportedOperationException("DELETE clause is not supported now.");
    else {
        sql.append("SELECT ");
        if (parts.isDistinct())
            throw new UnsupportedOperationException("DISTINCT clause in not supported.");
        if (parts.isCountProjection())
            sql.append("COUNT(1) ");
        else
            sql.append(" * ");
    }
    sql.append("FROM ").append(metadata.getDomainType().getSimpleName());
    if (parts.iterator().hasNext()) {
        sql.append(" WHERE ");
        for (PartTree.OrPart orPart : parts) {
            sql.append("(");
            for (Part part : orPart) {
                handleQueryPart(sql, part);
                sql.append(" AND ");
            }
            sql.delete(sql.length() - 5, sql.length());
            sql.append(") OR ");
        }
        sql.delete(sql.length() - 4, sql.length());
    }
    addSorting(sql, parts.getSort());
    if (parts.isLimiting()) {
        sql.append(" LIMIT ");
        sql.append(parts.getMaxResults().intValue());
    }
    return new IgniteQuery(sql.toString(), parts.isCountProjection(), getOptions(mtd));
}

/**
   * Splits source by Or{@literal Or} expressions and builds {@link OrPart}s which are simple conditions or expressions joined by And.
   * E.g. from the source "LastNameAndFirstNameOrAge" it will build the "LastNameAndFirstName" and "Age" OrderParts.
   *
   * @param source the source to split up into {@literal Or} parts in turn.
   */
private void buildTree(String source) {
    String[] split = PartTree.split(source, "Or", -1);
    for (int i = 0; i < split.length; i++) {
        // Validate previous expressions are correct
        if (i > 0 && StringUtils.isBlank(split[i - 1])) {
            throw new RuntimeException("ERROR: Missing expression before Or");
        }
        nodes.add(new OrPart(currentPartTreeInstance, split[i], fields));
    }
    // Validate expression before order clause is correct
    if (hasOrderClause()) {
        if (StringUtils.isBlank(split[split.length - 1])) {
            throw new RuntimeException("ERROR: Missing expression before OrderBy");
        }
        List<Part> parts = nodes.get(nodes.size() - 1).getChildren();
        if (!parts.get(parts.size() - 1).hasProperty()) {
            throw new RuntimeException("ERROR: Missing expression before OrderBy");
        }
    }
}

private String createQuery(String source, Class<?> entityClass, Object... values) {
    PartTree tree = new PartTree(source, entityClass);
    CassandraQueryCreator creator = new CassandraQueryCreator(tree, getAccessor(converter, values), context);
    StatementFactory factory = new StatementFactory(new UpdateMapper(converter));
    Query query = creator.createQuery();
    RegularStatement select = factory.select(query, context.getRequiredPersistentEntity(entityClass));
    return select.toString();
}

private Query createQueryForMethodWithArgs(Method method, Object[] args) {
    PartTree partTree = new PartTree(method.getName(), method.getReturnType());
    SolrQueryMethod queryMethod = new SolrQueryMethod(method, metadata, new SpelAwareProxyProjectionFactory(), entityInformationCreatorMock);
    SolrQueryCreator creator = new SolrQueryCreator(partTree, new SolrParametersParameterAccessor(queryMethod, args), mappingContext);
    return creator.createQuery();
}

public PartTree getTree() {
    return tree;
}

private RedisQueryCreator createQueryCreatorForMethodWithArgs(Method method, Object[] args) {
    PartTree partTree = new PartTree(method.getName(), method.getReturnType());
    RedisQueryCreator creator = new RedisQueryCreator(partTree, new ParametersParameterAccessor(new DefaultParameters(method), args));
    return creator;
}