import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
private Expression<?> buildOrderPropertyPathFrom(JoinerQuery<?, ?> joinerQuery, Sort.Order order) {
    PathBuilder<?> builder = new PathBuilder<Object>(joinerQuery.getFrom().getType(), joinerQuery.getFrom().toString());

    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;
}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
private Criteria createLikeRegexCriteriaOrThrow(Part part, DocumentDbPersistentProperty property,
    Criteria criteria, Iterator<Object> parameters, boolean shouldNegateExpression) {
    final PropertyPath path = part.getProperty().getLeafProperty();

    switch (part.shouldIgnoreCase()) {
        case ALWAYS:
            if (path.getType() != String.class) {
                throw new IllegalArgumentException("part must be String, but: " + path.getType() + ", " + path);
            }

            /* fall through */
        case WHEN_POSSIBLE:

            return criteria;

        case NEVER:
            break;
    }

    return null;
}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
/**
 * 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;
}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
@Override
protected StructuredQuery.Filter create(Part part, Iterator<Object> parameters) {
	if (part.getType().getKeywords().contains("Equals")) {
		List<String> segments = new ArrayList<String>();
		Iterator<PropertyPath> propertyPathIter = part.getProperty().iterator();
		while (propertyPathIter.hasNext()) {
			segments.add(propertyPathIter.next().getSegment());
		}
		String property = String.join(".", segments);

		Object value = parameters.next();
		if (value == null) {
			return StructuredQuery.PropertyFilter.isNull(property);
		}
		else if (value instanceof Boolean) {
			return StructuredQuery.PropertyFilter.eq(property, (Boolean) value);
		}
		else if (value instanceof Double || value instanceof Float) {
			return StructuredQuery.PropertyFilter.eq(property,
					((Number) value).doubleValue());
		}
		else if (value instanceof Number) {
			return StructuredQuery.PropertyFilter.eq(property,
					((Number) value).longValue());
		}
		else if (value instanceof CharSequence) {
			return StructuredQuery.PropertyFilter.eq(property,
					((CharSequence) value).toString());
		}
		else {
			throw new UnsupportedOperationException(
					"Value type not supported: " + value + " : " + value.getClass());
		}
	}
	else {
		throw new UnsupportedOperationException(
				"Part type not supported: " + part.getType());
	}
}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
protected Object doExecute(Object[] parameters) {
    Class<?> domainClass = queryMethod.getEntityInformation().getJavaType();
    int paramIndex = 0;
    
    PartTree tree = new PartTree(getQueryMethod().getName(), getQueryMethod().getEntityInformation().getJavaType());
    System.out.println(tree);
    
    List<Filter> orFilters = new ArrayList<Filter>();
    for (Iterator<OrPart> orPartIter = tree.iterator(); orPartIter.hasNext();) {
        OrPart orPart = orPartIter.next();
        
        List<Filter> andFilters = new ArrayList<Filter>();
        for (Iterator<Part> partIter = orPart.iterator(); partIter.hasNext();) {
            Part part = partIter.next();
            PropertyPath propertyPath  = part.getProperty();
            String propName = propertyPath.getSegment();
            Object propValue = parameters[paramIndex++];
            
            FilterOperator operator = getFilterOperation(part);
            Filter filter = new Query.FilterPredicate(propName, operator, propValue);
            andFilters.add(filter);
        }
        if (andFilters.size() == 1) {
            orFilters.add(andFilters.get(0));
        } else if (andFilters.size() >= 2){
            orFilters.add(CompositeFilterOperator.and(andFilters));
        }
    }
    
    com.googlecode.objectify.cmd.Query q = ofy().load().type(domainClass);
    if (orFilters.size() == 1) {
        q = q.filter(orFilters.get(0));
    } else if (orFilters.size() >= 2){
        q = q.filter(CompositeFilterOperator.or(orFilters));
    }
    return q.list();
}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
/**
 * Creates a new {@link GqPart} from the given method name part, the
 * {@link Class} the part originates from and the start parameter index.
 * 
 * @param source
 *            must not be {@literal null}.
 * @param clazz
 *            must not be {@literal null}.
 * @param alwaysIgnoreCase
 */
public GqPart(String source, Class<?> clazz, boolean alwaysIgnoreCase) {

    Assert.hasText(source, "Part source must not be null or emtpy!");
    Assert.notNull(clazz, "Type must not be null!");

    String partToUse = detectAndSetIgnoreCase(source);
    if (alwaysIgnoreCase && ignoreCase != IgnoreCaseType.ALWAYS) {
        this.ignoreCase = IgnoreCaseType.WHEN_POSSIBLE;
    }
    this.type = Type.fromProperty(partToUse);
    this.propertyPath = PropertyPath.from(type.extractProperty(partToUse), clazz);
}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
/**
     * 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 root.isEmpty(part.getProperty().getSegment());
//				case IS_NOT_EMPTY:
//					return root.isEmpty(part.getProperty().getSegment());
        default:
          throw new IllegalArgumentException("Unsupported keyword " + type);
      }
    }
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
private String buildQueryCondition(boolean basic) {

        StringBuilder builder = new StringBuilder();
        builder.append("<trim prefix=\" where \" prefixOverrides=\"and |or \">");
        int c = 0;
        for (Iterator<PartTree.OrPart> iterator = tree.iterator(); iterator.hasNext(); ) {
            PartTree.OrPart orPart = iterator.next();
            builder.append(" or (");
            builder.append("<trim prefix=\"\" prefixOverrides=\"and |or \">");

            for (Iterator<Part> it = orPart.iterator(); it.hasNext(); ) {
                String columnName = null;
                Part part = it.next();
                MybatisPersistentProperty property = persistentEntity.getPersistentProperty(part.getProperty().getSegment());
                if (null == property) {
                    throw new MybatisQueryException("can not find property: " + part.getProperty().getSegment() + " from entity: " + persistentEntity.getName());
                }
                if (!property.isEntity()) {
                    columnName = quota(persistentEntity.getEntityName()) + "." + dialect.wrapColumnName(property.getColumnName());
                } else if (!basic) {
                    if (property.isAssociation()) {
                        Association<MybatisPersistentProperty> ass = property.getAssociation();
                        if (ass instanceof MybatisManyToOneAssociation) {
                            MybatisManyToOneAssociation association = (MybatisManyToOneAssociation) ass;

                            MybatisPersistentEntity<?> obversePersistentEntity = association.getObversePersistentEntity();
                            if (null == obversePersistentEntity) {
                                throw new MybatisQueryException("can not find obverse persistent entity.");
                            }

                            PropertyPath leaf = part.getProperty().getLeafProperty();

                            if (obversePersistentEntity.getType() == leaf.getType()) {

                                //columnName = quota(persistentEntity.getEntityName() + "." + part.getProperty().getSegment()) + "." + dialect.wrapColumnName(obversePersistentEntity.getIdProperty().getColumnName());
                                throw new UnsupportedOperationException("findBy{Association Model} Style is not support now.");

                            } else {
                                MybatisPersistentProperty leafProperty = obversePersistentEntity.getPersistentProperty(leaf.getSegment());
                                if (null == leafProperty) {
                                    throw new MybatisQueryException("can not find property: " + leaf.getSegment() + " from entity: " + obversePersistentEntity.getName());
                                }
                                columnName = quota(persistentEntity.getEntityName() + "." + part.getProperty().getSegment()) + "." + dialect.wrapColumnName(leafProperty.getColumnName());
                            }
                        } else if (ass instanceof MybatisEmbeddedAssociation) {
                            columnName = quota(persistentEntity.getEntityName()) + "." + dialect.wrapColumnName(ass.getObverse().getColumnName());
                        }
                    }
                }

                if (null == columnName) {
                    throw new MybatisQueryException("can not find property: " + part.getProperty().getSegment() + " in " + method.getName());
                }

                builder.append(" and ");

                IgnoreCaseType ignoreCaseType = part.shouldIgnoreCase();
                if (ignoreCaseType == ALWAYS || ignoreCaseType == WHEN_POSSIBLE) {
                    builder.append("upper(").append(columnName).append(")");
                } else {
                    builder.append(columnName);
                }

                builder.append(generator.buildConditionOperate(part.getType()));
                String[] properties = new String[part.getType().getNumberOfArguments()];
                for (int i = 0; i < properties.length; i++) {
                    properties[i] = resolveParameterName(c++);
                }
                builder.append(generator.buildConditionCaluse(part.getType(), ignoreCaseType, properties));
            }

            builder.append("</trim>");

            builder.append(" )");

        }
        builder.append("</trim>");
        return builder.toString();
    }
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
/**
 * @return the propertyPath
 */
public PropertyPath getProperty() {

    return propertyPath;
}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
private Query<?> createQuery(Object[] values, boolean withPageSort) {
	Query<?> q = QB.create(metadata);
	ParametersParameterAccessor accessor = new ParametersParameterAccessor(
			parameters, values);
	Or or = new Or();
	int index = 0;
	for (GqOrPart node : tree) {
		And and = new And();
		for (GqPart part : node) {
			PropertyPath path = part.getProperty();
			if (path.getOwningType().getType() != metadata.getThisType()) {
				throw new IllegalArgumentException("PathType:"
						+ path.getOwningType().getType() + "  metadata:"
						+ metadata.getThisType());
			}
			String fieldName = path.getSegment();
			ColumnMapping field = metadata.findField(fieldName);
			PairIO<GqParameter> paramInfo = getBindParamIndex(index++,
					fieldName);
			Object obj = accessor.getBindableValue(paramInfo.first);
			if (field != null) {
				IgnoreIf ignore = paramInfo.second.getIgnoreIf();
				if (ignore == null || !QueryUtils.isIgnore(ignore, obj)) {
					add(and, part, field.field(), obj);
				}
			}
		}
		or.addCondition(and);
	}
	q.addCondition(or);

	if (withPageSort) {
		Sort sort = tree.getSort();
		if (accessor.getSort() != null) {
			sort = accessor.getSort();
		}
		Pageable page = accessor.getPageable();
		if (page != null && page.getSort() != null) {
			sort = page.getSort();
		}
		if (sort != null)
			setSortToSpec(q, sort, metadata);
	}
	return q;
}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
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());
	}

}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
/**
 * Creates an {@link Order} instance from the given property source, direction and domain class. If the domain class
 * is given, we will use it for nested property traversal checks.
 * 
 * @param propertySource
 * @param direction
 * @param domainClass can be {@literal null}.
 * @return
 * @see PropertyPath#from(String, Class)
 */
private Order createOrder(String propertySource, Direction direction, Class<?> domainClass) {

    if (null == domainClass) {
        return new Order(direction, StringUtils.uncapitalize(propertySource));
    }
    PropertyPath propertyPath = PropertyPath.from(propertySource, domainClass);
    return new Order(direction, propertyPath.toDotPath());
}
 

import org.springframework.data.mapping.PropertyPath; //导入依赖的package包/类
/**
 * Gets persistent property path.
 *
 * @param propertyPath
 *     the property path
 * @return the persistent property path
 */
@Override
public PersistentPropertyPath<MongoPersistentProperty> getPersistentPropertyPath(PropertyPath propertyPath) {
  return getPersistentPropertyPath(propertyPath.toDotPath(), propertyPath.getOwningType().getType());
}