Examples with QueryResult io.micronaut.data.model.query.builder.QueryResult used on opensource projects

Example 6 with QueryResult

use of io.micronaut.data.model.query.builder.QueryResult in project micronaut-data by micronaut-projects.

the class RepositoryTypeElementVisitor method processMethodInfo.

private void processMethodInfo(MethodMatchContext methodMatchContext, MethodMatchInfo methodInfo) {
    QueryBuilder queryEncoder = methodMatchContext.getQueryBuilder();
    MethodElement element = methodMatchContext.getMethodElement();
    SourcePersistentEntity entity = methodMatchContext.getRootEntity();
    ParameterElement[] parameters = methodMatchContext.getParameters();
    // populate parameter roles
    for (Map.Entry<String, Element> entry : methodMatchContext.getParametersInRole().entrySet()) {
        methodInfo.addParameterRole(entry.getKey(), entry.getValue().getName());
    }
    List<QueryParameterBinding> parameterBinding = null;
    boolean encodeEntityParameters = false;
    boolean supportsImplicitQueries = methodMatchContext.supportsImplicitQueries();
    QueryResult queryResult = methodInfo.getQueryResult();
    if (queryResult != null) {
        if (methodInfo.isRawQuery()) {
            // no need to annotation since already annotated, just replace the
            // the computed parameter names
            parameterBinding = queryResult.getParameterBindings();
            element.annotate(Query.class, (builder) -> builder.member(DataMethod.META_MEMBER_RAW_QUERY, element.stringValue(Query.class).map(q -> addRawQueryParameterPlaceholders(queryEncoder, queryResult.getQuery(), queryResult.getQueryParts())).orElse(null)));
            ClassElement genericReturnType = methodMatchContext.getReturnType();
            if (methodMatchContext.isTypeInRole(genericReturnType, TypeRole.PAGE) || element.isPresent(Query.class, "countQuery")) {
                QueryResult countQueryResult = methodInfo.getCountQueryResult();
                if (countQueryResult == null) {
                    throw new MatchFailedException("Query returns a Page and does not specify a 'countQuery' member.", element);
                } else {
                    element.annotate(Query.class, (builder) -> builder.member(DataMethod.META_MEMBER_RAW_COUNT_QUERY, addRawQueryParameterPlaceholders(queryEncoder, countQueryResult.getQuery(), countQueryResult.getQueryParts())));
                }
            }
            encodeEntityParameters = methodInfo.isEncodeEntityParameters();
        } else {
            encodeEntityParameters = methodInfo.isEncodeEntityParameters();
            parameterBinding = queryResult.getParameterBindings();
            bindAdditionalParameters(methodMatchContext, entity, parameterBinding, parameters, queryResult.getAdditionalRequiredParameters());
            QueryResult preparedCount = methodInfo.getCountQueryResult();
            if (preparedCount != null) {
                element.annotate(Query.class, annotationBuilder -> {
                    annotationBuilder.value(queryResult.getQuery());
                    annotationBuilder.member(DataMethod.META_MEMBER_COUNT_QUERY, preparedCount.getQuery());
                });
            } else {
                element.annotate(Query.class, annotationBuilder -> {
                    annotationBuilder.value(queryResult.getQuery());
                    String update = queryResult.getUpdate();
                    if (StringUtils.isNotEmpty(update)) {
                        annotationBuilder.member("update", update);
                    }
                });
            }
        }
    }
    ClassElement runtimeInterceptor = methodInfo.getRuntimeInterceptor();
    if (runtimeInterceptor == null) {
        throw new MatchFailedException("Unable to implement Repository method: " + currentRepository.getSimpleName() + "." + element.getName() + "(..). No possible runtime implementations found.", element);
    }
    boolean finalEncodeEntityParameters = encodeEntityParameters;
    List<QueryParameterBinding> finalParameterBinding = parameterBinding;
    element.annotate(DataMethod.class, annotationBuilder -> {
        annotationBuilder.member(DataMethod.META_MEMBER_OPERATION_TYPE, methodInfo.getOperationType());
        annotationBuilder.member(DataMethod.META_MEMBER_ROOT_ENTITY, new AnnotationClassValue<>(entity.getName()));
        // include the roles
        methodInfo.getParameterRoles().forEach(annotationBuilder::member);
        if (methodInfo.isDto()) {
            annotationBuilder.member(DataMethod.META_MEMBER_DTO, true);
        }
        if (methodInfo.isOptimisticLock()) {
            annotationBuilder.member(DataMethod.META_MEMBER_OPTIMISTIC_LOCK, true);
        }
        TypedElement resultType = methodInfo.getResultType();
        if (resultType != null) {
            annotationBuilder.member(DataMethod.META_MEMBER_RESULT_TYPE, new AnnotationClassValue<>(resultType.getName()));
            ClassElement type = resultType.getType();
            if (!TypeUtils.isVoid(type)) {
                annotationBuilder.member(DataMethod.META_MEMBER_RESULT_DATA_TYPE, TypeUtils.resolveDataType(type, dataTypes));
            }
        }
        String idType = resolveIdType(entity);
        if (idType != null) {
            annotationBuilder.member(DataMethod.META_MEMBER_ID_TYPE, idType);
        }
        annotationBuilder.member(DataMethod.META_MEMBER_INTERCEPTOR, new AnnotationClassValue<>(runtimeInterceptor.getName()));
        if (queryResult != null) {
            if (finalParameterBinding.stream().anyMatch(QueryParameterBinding::isExpandable)) {
                annotationBuilder.member(DataMethod.META_MEMBER_EXPANDABLE_QUERY, queryResult.getQueryParts().toArray(new String[0]));
                QueryResult preparedCount = methodInfo.getCountQueryResult();
                if (preparedCount != null) {
                    annotationBuilder.member(DataMethod.META_MEMBER_EXPANDABLE_COUNT_QUERY, preparedCount.getQueryParts().toArray(new String[0]));
                }
            }
            int max = queryResult.getMax();
            if (max > -1) {
                annotationBuilder.member(DataMethod.META_MEMBER_PAGE_SIZE, max);
            }
            long offset = queryResult.getOffset();
            if (offset > 0) {
                annotationBuilder.member(DataMethod.META_MEMBER_PAGE_INDEX, offset);
            }
        }
        Arrays.stream(parameters).filter(p -> p.getGenericType().isAssignable(entity.getName())).findFirst().ifPresent(parameterElement -> annotationBuilder.member(DataMethod.META_MEMBER_ENTITY, parameterElement.getName()));
        if (CollectionUtils.isNotEmpty(finalParameterBinding)) {
            bindParameters(supportsImplicitQueries, finalParameterBinding, finalEncodeEntityParameters, annotationBuilder);
        }
    });
}

Example 7 with QueryResult

use of io.micronaut.data.model.query.builder.QueryResult in project micronaut-data by micronaut-projects.

the class UpdateCriteriaMethodMatch method build.

@Override
protected MethodMatchInfo build(MethodMatchContext matchContext) {
    MethodMatchSourcePersistentEntityCriteriaBuilderImpl cb = new MethodMatchSourcePersistentEntityCriteriaBuilderImpl(matchContext);
    PersistentEntityCriteriaUpdate<Object> criteriaQuery = cb.createCriteriaUpdate(null);
    apply(matchContext, criteriaQuery.from(matchContext.getRootEntity()), criteriaQuery, cb);
    Map.Entry<ClassElement, Class<? extends DataInterceptor>> entry = resolveReturnTypeAndInterceptor(matchContext);
    ClassElement resultType = entry.getKey();
    Class<? extends DataInterceptor> interceptorType = entry.getValue();
    AbstractPersistentEntityCriteriaUpdate<?> criteriaUpdate = (AbstractPersistentEntityCriteriaUpdate<?>) criteriaQuery;
    boolean optimisticLock = criteriaUpdate.hasVersionRestriction();
    final AnnotationMetadataHierarchy annotationMetadataHierarchy = new AnnotationMetadataHierarchy(matchContext.getRepositoryClass().getAnnotationMetadata(), matchContext.getAnnotationMetadata());
    QueryBuilder queryBuilder = matchContext.getQueryBuilder();
    Map<String, Object> propertiesToUpdate = criteriaUpdate.getUpdateValues();
    QueryModel queryModel = ((AbstractPersistentEntityCriteriaUpdate) criteriaQuery).getQueryModel();
    QueryResult queryResult = queryBuilder.buildUpdate(annotationMetadataHierarchy, queryModel, propertiesToUpdate);
    return new MethodMatchInfo(DataMethod.OperationType.UPDATE, resultType, getInterceptorElement(matchContext, interceptorType)).optimisticLock(optimisticLock).queryResult(queryResult);
}

Example 8 with QueryResult

use of io.micronaut.data.model.query.builder.QueryResult in project micronaut-data by micronaut-projects.

the class RawQueryMethodMatcher method getQueryResult.

private QueryResult getQueryResult(MethodMatchContext matchContext, String queryString, List<ParameterElement> parameters, boolean namedParameters, ParameterElement entityParam, SourcePersistentEntity persistentEntity) {
    java.util.regex.Matcher matcher = VARIABLE_PATTERN.matcher(queryString.replace("\\:", ""));
    List<QueryParameterBinding> parameterBindings = new ArrayList<>(parameters.size());
    List<String> queryParts = new ArrayList<>();
    int index = 1;
    int lastOffset = 0;
    while (matcher.find()) {
        String prefix = queryString.substring(lastOffset, matcher.start(3) - 1);
        if (!prefix.isEmpty()) {
            queryParts.add(prefix);
        }
        lastOffset = matcher.end(3);
        String name = matcher.group(3);
        if (namedParameters) {
            Optional<ParameterElement> element = parameters.stream().filter(p -> p.stringValue(Parameter.class).orElse(p.getName()).equals(name)).findFirst();
            if (element.isPresent()) {
                PersistentPropertyPath propertyPath = matchContext.getRootEntity().getPropertyPath(name);
                BindingContext bindingContext = BindingContext.create().name(name).incomingMethodParameterProperty(propertyPath).outgoingQueryParameterProperty(propertyPath);
                parameterBindings.add(bindingParameter(matchContext, element.get()).bind(bindingContext));
            } else if (persistentEntity != null) {
                PersistentPropertyPath propertyPath = persistentEntity.getPropertyPath(name);
                if (propertyPath == null) {
                    throw new MatchFailedException("Cannot update non-existent property: " + name);
                } else {
                    BindingContext bindingContext = BindingContext.create().name(name).incomingMethodParameterProperty(propertyPath).outgoingQueryParameterProperty(propertyPath);
                    parameterBindings.add(bindingParameter(matchContext, entityParam, true).bind(bindingContext));
                }
            } else {
                throw new MatchFailedException("No method parameter found for named Query parameter: " + name);
            }
        } else {
            Optional<ParameterElement> element = parameters.stream().filter(p -> p.stringValue(Parameter.class).orElse(p.getName()).equals(name)).findFirst();
            if (element.isPresent()) {
                PersistentPropertyPath propertyPath = matchContext.getRootEntity().getPropertyPath(name);
                BindingContext bindingContext = BindingContext.create().index(index++).incomingMethodParameterProperty(propertyPath).outgoingQueryParameterProperty(propertyPath);
                parameterBindings.add(bindingParameter(matchContext, element.get()).bind(bindingContext));
            } else if (persistentEntity != null) {
                PersistentPropertyPath propertyPath = persistentEntity.getPropertyPath(name);
                if (propertyPath == null) {
                    matchContext.fail("Cannot update non-existent property: " + name);
                } else {
                    BindingContext bindingContext = BindingContext.create().index(index++).incomingMethodParameterProperty(propertyPath).outgoingQueryParameterProperty(propertyPath);
                    parameterBindings.add(bindingParameter(matchContext, entityParam, true).bind(bindingContext));
                }
            } else {
                throw new MatchFailedException("No method parameter found for named Query parameter: " + name);
            }
        }
    }
    queryString = queryString.replace("\\:", ":");
    if (queryParts.isEmpty()) {
        queryParts.add(queryString);
    } else if (lastOffset > 0) {
        queryParts.add(queryString.substring(lastOffset));
    }
    String finalQueryString = queryString;
    return new QueryResult() {

        @Override
        public String getQuery() {
            return finalQueryString;
        }

        @Override
        public List<String> getQueryParts() {
            return queryParts;
        }

        @Override
        public List<QueryParameterBinding> getParameterBindings() {
            return parameterBindings;
        }

        @Override
        public Map<String, String> getAdditionalRequiredParameters() {
            return Collections.emptyMap();
        }
    };
}

Example 9 with QueryResult

use of io.micronaut.data.model.query.builder.QueryResult in project micronaut-data by micronaut-projects.

the class MongoRawQueryMethodMatcher method getUpdateQueryResult.

private QueryResult getUpdateQueryResult(MethodMatchContext matchContext, List<ParameterElement> parameters, ParameterElement entityParam, SourcePersistentEntity persistentEntity) {
    String filterQueryString = matchContext.getMethodElement().stringValue(MongoAnnotations.FILTER).orElseThrow(() -> new MatchFailedException("Filter query is missing!"));
    String updateQueryString = matchContext.getMethodElement().stringValue(MongoAnnotations.UPDATE_QUERY, "update").orElseThrow(() -> new MatchFailedException("Update query is missing!"));
    // Mapped to query
    removeAnnotation(matchContext.getAnnotationMetadata(), MongoAnnotations.FILTER);
    // Mapped to query
    removeAnnotation(matchContext.getAnnotationMetadata(), MongoAnnotations.UPDATE_QUERY);
    List<QueryParameterBinding> parameterBindings = new ArrayList<>(parameters.size());
    String filterQuery = processCustomQuery(matchContext, filterQueryString, parameters, entityParam, persistentEntity, parameterBindings);
    String updateQuery = processCustomQuery(matchContext, updateQueryString, parameters, entityParam, persistentEntity, parameterBindings);
    return new QueryResult() {

        @Override
        public String getQuery() {
            return filterQuery;
        }

        @Override
        public String getUpdate() {
            return updateQuery;
        }

        @Override
        public List<String> getQueryParts() {
            return Collections.emptyList();
        }

        @Override
        public List<QueryParameterBinding> getParameterBindings() {
            return parameterBindings;
        }

        @Override
        public Map<String, String> getAdditionalRequiredParameters() {
            return Collections.emptyMap();
        }
    };
}

Example 10 with QueryResult

use of io.micronaut.data.model.query.builder.QueryResult in project micronaut-data by micronaut-projects.

the class AbstractSqlRepositoryOperations method resolveEntityInsert.

/**
 * Resolves a stored insert for the given entity.
 *
 * @param annotationMetadata The repository annotation metadata
 * @param repositoryType     The repository type
 * @param rootEntity         The root entity
 * @param persistentEntity   The persistent entity
 * @return The insert
 */
@NonNull
protected DBOperation resolveEntityInsert(AnnotationMetadata annotationMetadata, Class<?> repositoryType, @NonNull Class<?> rootEntity, @NonNull RuntimePersistentEntity<?> persistentEntity) {
    // noinspection unchecked
    return entityInserts.computeIfAbsent(new QueryKey(repositoryType, rootEntity), (queryKey) -> {
        final SqlQueryBuilder queryBuilder = queryBuilders.getOrDefault(repositoryType, DEFAULT_SQL_BUILDER);
        final QueryResult queryResult = queryBuilder.buildInsert(annotationMetadata, persistentEntity);
        return new QueryResultSqlOperation(queryBuilder, queryResult);
    });
}