org.springframework.data.mapping.PropertyPath Java Examples

The following examples show how to use org.springframework.data.mapping.PropertyPath. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source File: QuerydslSQL.java    From spring-boot-practice with Apache License 2.0 6 votes vote down vote up 
private Expression<?> buildOrderPropertyPathFrom(Sort.Order order) {
    Assert.notNull(order, "Order must not be null!");

    PropertyPath path = PropertyPath.from(order.getProperty(), builder.getType());
    Expression<?> sortPropertyExpression = builder;

    while (path != null) {
        if (!path.hasNext() && order.isIgnoreCase()) {
            // if order is ignore-case we have to treat the last path segment as a String.
            sortPropertyExpression = Expressions.stringPath((Path<?>) sortPropertyExpression, path.getSegment()).lower();
        } else {
            sortPropertyExpression = Expressions.path(path.getType(), (Path<?>) sortPropertyExpression, path.getSegment());
        }

        path = path.next();
    }

    return sortPropertyExpression;
}
Example #2
Source File: QuerydslSQL.java    From spring-boot-practice with Apache License 2.0 6 votes vote down vote up 
private Expression<?> buildOrderPropertyPathFrom(Sort.Order order) {
    Assert.notNull(order, "Order must not be null!");

    PropertyPath path = PropertyPath.from(order.getProperty(), builder.getType());
    Expression<?> sortPropertyExpression = builder;

    while (path != null) {
        if (!path.hasNext() && order.isIgnoreCase()) {
            // if order is ignore-case we have to treat the last path segment as a String.
            sortPropertyExpression = Expressions.stringPath((Path<?>) sortPropertyExpression, path.getSegment()).lower();
        } else {
            sortPropertyExpression = Expressions.path(path.getType(), (Path<?>) sortPropertyExpression, path.getSegment());
        }

        path = path.next();
    }

    return sortPropertyExpression;
}
Example #3
Source File: KeyValueQuerydslUtils.java    From spring-data-keyvalue with Apache License 2.0 6 votes vote down vote up 
/**
 * Creates an {@link Expression} for the given {@link Order} property.
 *
 * @param order must not be {@literal null}.
 * @param builder must not be {@literal null}.
 * @return
 */
private static Expression<?> buildOrderPropertyPathFrom(Order order, PathBuilder<?> builder) {

	Assert.notNull(order, "Order must not be null!");
	Assert.notNull(builder, "Builder must not be null!");

	PropertyPath path = PropertyPath.from(order.getProperty(), builder.getType());
	Expression<?> sortPropertyExpression = builder;

	while (path != null) {

		if (!path.hasNext() && order.isIgnoreCase()) {
			// if order is ignore-case we have to treat the last path segment as a String.
			sortPropertyExpression = Expressions.stringPath((Path<?>) sortPropertyExpression, path.getSegment()).lower();
		} else {
			sortPropertyExpression = Expressions.path(path.getType(), (Path<?>) sortPropertyExpression, path.getSegment());
		}

		path = path.next();
	}

	return sortPropertyExpression;
}
Example #4
Source File: DerivedQueryCreator.java    From spring-data with Apache License 2.0 5 votes vote down vote up 
private void collectWithCollections(final PropertyPath propertyPath) {
	propertyPath.stream().map(property -> {
		return property.isCollection() ? property.getTypeInformation().getComponentType()
				: property.getTypeInformation();
	}).map(type -> {
		return context.getPersistentEntity(type);
	}).filter(entity -> {
		return entity != null;
	}).map(entity -> {
		return AqlUtils.buildCollectionName(entity.getCollection());
	}).forEach(withCollections::add);
}
Example #5
Source File: PartTreeDatastoreQuery.java    From spring-cloud-gcp with Apache License 2.0 5 votes vote down vote up 
private List<DatastorePersistentProperty> getPropertiesChain(Part part) {
	Iterable<PropertyPath> iterable = () -> part.getProperty().iterator();

	return StreamSupport.stream(iterable.spliterator(), false)
			.map(propertyPath ->
					this.datastoreMappingContext
							.getPersistentEntity(propertyPath.getOwningType())
							.getPersistentProperty(propertyPath.getSegment())
			).collect(Collectors.toList());
}
Example #6
Source File: PartTreeFirestoreQuery.java    From spring-cloud-gcp with Apache License 2.0 5 votes vote down vote up 
private String buildName(Part part) {
	Iterable<PropertyPath> iterable = () -> part.getProperty().iterator();

	return StreamSupport
			.stream(iterable.spliterator(), false)
			.map(propertyPath -> {
				FirestorePersistentEntity<?> persistentEntity = this.mappingContext.getPersistentEntity(propertyPath.getOwningType());
				return persistentEntity.getPersistentProperty(propertyPath.getSegment()).getFieldName();
			})
			.collect(Collectors.joining("."));
}
Example #7
Source File: JpaSpecificationExecutorWithProjectionImpl.java    From specification-with-projection with MIT License 5 votes vote down vote up 
protected TypedQuery<Tuple> getTupleQuery(@Nullable Specification spec, Sort sort, ReturnedType returnedType) {
    if (!returnedType.needsCustomConstruction()){
        return getQuery(spec,sort);
    }
    CriteriaBuilder builder = this.entityManager.getCriteriaBuilder();
    CriteriaQuery<Tuple> query = builder.createQuery(Tuple.class);
    Root<T> root = this.applySpecificationToCriteria(spec, getDomainClass(), query);
    Predicate predicate = spec.toPredicate(root, query, builder);

    if (predicate != null) {
        query.where(predicate);
    }
    if (returnedType.needsCustomConstruction()) {
        List<Selection<?>> selections = new ArrayList<>();

        for (String property : returnedType.getInputProperties()) {
            PropertyPath path = PropertyPath.from(property, returnedType.getReturnedType());
            selections.add(toExpressionRecursively(root, path, true).alias(property));
        }

        query.multiselect(selections);
    } else {
        throw new IllegalArgumentException("only except projection");
    }
    if (sort.isSorted()) {
        query.orderBy(QueryUtils.toOrders(sort, root, builder));
    }

    return this.applyRepositoryMethodMetadata(this.entityManager.createQuery(query));
}
Example #8
Source File: JpaSpecificationExecutorWithProjectionImpl.java    From specification-with-projection with MIT License 5 votes vote down vote up 
static <T> Expression<T> toExpressionRecursively(From<?, ?> from, PropertyPath property, boolean isForSelection) {

        Bindable<?> propertyPathModel;
        Bindable<?> model = from.getModel();
        String segment = property.getSegment();

        if (model instanceof ManagedType) {

            /*
             *  Required to keep support for EclipseLink 2.4.x. TODO: Remove once we drop that (probably Dijkstra M1)
             *  See: https://bugs.eclipse.org/bugs/show_bug.cgi?id=413892
             */
            propertyPathModel = (Bindable<?>) ((ManagedType<?>) model).getAttribute(segment);
        } else {
            propertyPathModel = from.get(segment).getModel();
        }

        if (requiresJoin(propertyPathModel, model instanceof PluralAttribute, !property.hasNext(), isForSelection)
                && !isAlreadyFetched(from, segment)) {
            Join<?, ?> join = getOrCreateJoin(from, segment);
            return (Expression<T>) (property.hasNext() ? toExpressionRecursively(join, property.next(), isForSelection)
                    : join);
        } else {
            Path<Object> path = from.get(segment);
            return (Expression<T>) (property.hasNext() ? toExpressionRecursively(path, property.next()) : path);
        }
    }
Example #9
Source File: EbeanQueryCreator.java    From spring-data-ebean with Apache License 2.0 4 votes vote down vote up 
/**
         * Builds a Ebean {@link Expression} from the underlying {@link Part}.
         *
         * @return
         */
        public Expression build() {
            PropertyPath property = part.getProperty();
            Part.Type type = part.getType();

            switch (type) {
                case BETWEEN:
                    ParameterMetadataProvider.ParameterMetadata<Comparable> first = provider.next(part);
                    ParameterMetadataProvider.ParameterMetadata<Comparable> second = provider.next(part);
                    return Expr.between(property.toDotPath(), first.getParameterValue(), second.getParameterValue());
                case AFTER:
                case GREATER_THAN:
                    return Expr.gt(property.toDotPath(), provider.next(part).getParameterValue());
                case GREATER_THAN_EQUAL:
                    return Expr.ge(property.toDotPath(), provider.next(part).getParameterValue());
                case BEFORE:
                case LESS_THAN:
                    return Expr.lt(property.toDotPath(), provider.next(part).getParameterValue());
                case LESS_THAN_EQUAL:
                    return Expr.le(property.toDotPath(), provider.next(part).getParameterValue());
                case IS_NULL:
                    return Expr.isNull(property.toDotPath());
                case IS_NOT_NULL:
                    return Expr.isNotNull(property.toDotPath());
                case NOT_IN:
                    ParameterMetadataProvider.ParameterMetadata<? extends Collection> pmNotIn = provider.next(part, Collection.class);
                    return Expr.not(Expr.in(property.toDotPath(), ParameterMetadataProvider.ParameterMetadata.toCollection(pmNotIn.getParameterValue())));
                case IN:
                    ParameterMetadataProvider.ParameterMetadata<? extends Collection> pmIn = provider.next(part, Collection.class);
                    return Expr.in(property.toDotPath(), ParameterMetadataProvider.ParameterMetadata.toCollection(pmIn.getParameterValue()));
                case STARTING_WITH:
                    return Expr.startsWith(property.toDotPath(), (String) provider.next(part).getParameterValue());
                case ENDING_WITH:
                    return Expr.endsWith(property.toDotPath(), (String) provider.next(part).getParameterValue());
                case CONTAINING:
                    return Expr.contains(property.toDotPath(), (String) provider.next(part).getParameterValue());
                case NOT_CONTAINING:
                    return Expr.not(Expr.contains(property.toDotPath(), (String) provider.next(part).getParameterValue()));
                case LIKE:
                    return Expr.like(property.toDotPath(), (String) provider.next(part).getParameterValue());
                case NOT_LIKE:
                    return Expr.not(Expr.like(property.toDotPath(), (String) provider.next(part).getParameterValue()));
                case TRUE:
                    return Expr.eq(property.toDotPath(), true);
                case FALSE:
                    return Expr.eq(property.toDotPath(), false);
                case SIMPLE_PROPERTY:
                    ParameterMetadataProvider.ParameterMetadata<Object> pmEquals = provider.next(part);
                    return pmEquals.isIsNullParameter() ? Expr.isNull(property.toDotPath())
                            : Expr.eq(property.toDotPath(), pmEquals.getParameterValue());
                case NEGATING_SIMPLE_PROPERTY:
                    ParameterMetadataProvider.ParameterMetadata<Object> pmNot = provider.next(part);
                    return pmNot.isIsNullParameter() ? Expr.isNull(property.toDotPath())
                            : Expr.ne(property.toDotPath(), pmNot.getParameterValue());
//        case IS_EMPTY:
//          return Expr.isEmpty(property.toDotPath());
//        case IS_NOT_EMPTY:
//          return Expr.isNotEmpty(property.toDotPath());
                default:
                    throw new IllegalArgumentException("Unsupported keyword " + type);
            }
        }
Example #10
Source File: JpaSpecificationExecutorWithProjectionImpl.java    From specification-with-projection with MIT License 4 votes vote down vote up 
static Expression<Object> toExpressionRecursively(Path<Object> path, PropertyPath property) {

        Path<Object> result = path.get(property.getSegment());
        return property.hasNext() ? toExpressionRecursively(result, property.next()) : result;
    }
Example #11
Source File: HazelcastQueryCreator.java    From spring-data-hazelcast with Apache License 2.0 4 votes vote down vote up 
private boolean canUpperCase(PropertyPath path) {
    return String.class.equals(path.getType());
}
Example #12
Source File: AbstractDynamoDBQueryCreator.java    From spring-data-dynamodb with Apache License 2.0 4 votes vote down vote up 
protected DynamoDBQueryCriteria<T, ID> addCriteria(DynamoDBQueryCriteria<T, ID> criteria, Part part, Iterator<Object> iterator) {
	if (part.shouldIgnoreCase().equals(IgnoreCaseType.ALWAYS))
		throw new UnsupportedOperationException("Case insensitivity not supported");

	Class<?> leafNodePropertyType = part.getProperty().getLeafProperty().getType();
	
	PropertyPath leafNodePropertyPath = part.getProperty().getLeafProperty();
	String leafNodePropertyName = leafNodePropertyPath.toDotPath();
	if (leafNodePropertyName.indexOf(".") != -1)
	{
		int index = leafNodePropertyName.lastIndexOf(".");
		leafNodePropertyName = leafNodePropertyName.substring(index);
	}

	switch (part.getType()) {
	
	case IN:
		Object in = iterator.next();
		Assert.notNull(in, "Creating conditions on null parameters not supported: please specify a value for '"
				+ leafNodePropertyName + "'");
		boolean isIterable = ClassUtils.isAssignable(in.getClass(), Iterable.class);
		boolean isArray = ObjectUtils.isArray(in);
		Assert.isTrue(isIterable || isArray, "In criteria can only operate with Iterable or Array parameters");
		Iterable<?> iterable = isIterable ? ((Iterable<?>) in) : Arrays.asList(ObjectUtils.toObjectArray(in));
		return criteria.withPropertyIn(leafNodePropertyName, iterable, leafNodePropertyType);
	case CONTAINING:
		return criteria.withSingleValueCriteria(leafNodePropertyName, ComparisonOperator.CONTAINS,
				iterator.next(), leafNodePropertyType);
	case STARTING_WITH:
		return criteria.withSingleValueCriteria(leafNodePropertyName, ComparisonOperator.BEGINS_WITH,
				iterator.next(), leafNodePropertyType);
	case BETWEEN:
		Object first = iterator.next();
		Object second = iterator.next();
		return criteria.withPropertyBetween(leafNodePropertyName, first, second, leafNodePropertyType);
	case AFTER:
	case GREATER_THAN:
		return criteria.withSingleValueCriteria(leafNodePropertyName, ComparisonOperator.GT, iterator.next(),
				leafNodePropertyType);
	case BEFORE:
	case LESS_THAN:
		return criteria.withSingleValueCriteria(leafNodePropertyName, ComparisonOperator.LT, iterator.next(),
				leafNodePropertyType);
	case GREATER_THAN_EQUAL:
		return criteria.withSingleValueCriteria(leafNodePropertyName, ComparisonOperator.GE, iterator.next(),
				leafNodePropertyType);
	case LESS_THAN_EQUAL:
		return criteria.withSingleValueCriteria(leafNodePropertyName, ComparisonOperator.LE, iterator.next(),
				leafNodePropertyType);
	case IS_NULL:
		return criteria.withNoValuedCriteria(leafNodePropertyName, ComparisonOperator.NULL);
	case IS_NOT_NULL:
		return criteria.withNoValuedCriteria(leafNodePropertyName, ComparisonOperator.NOT_NULL);
	case TRUE:
		return criteria.withSingleValueCriteria(leafNodePropertyName, ComparisonOperator.EQ, Boolean.TRUE,
				leafNodePropertyType);
	case FALSE:
		return criteria.withSingleValueCriteria(leafNodePropertyName, ComparisonOperator.EQ, Boolean.FALSE,
				leafNodePropertyType);
	case SIMPLE_PROPERTY:
		return criteria.withPropertyEquals(leafNodePropertyName, iterator.next(), leafNodePropertyType);
	case NEGATING_SIMPLE_PROPERTY:
		return criteria.withSingleValueCriteria(leafNodePropertyName, ComparisonOperator.NE, iterator.next(),
				leafNodePropertyType);
	default:
		throw new IllegalArgumentException("Unsupported keyword " + part.getType());
	}

}