Java StringExpression类代码示例

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
@Override
public Expression<?> visit(Substring node) {
    List<de.fraunhofer.iosb.ilt.sta.query.expression.Expression> params = node.getParameters();
    de.fraunhofer.iosb.ilt.sta.query.expression.Expression p1 = node.getParameters().get(0);
    de.fraunhofer.iosb.ilt.sta.query.expression.Expression p2 = node.getParameters().get(1);
    Expression<?> e1 = p1.accept(this);
    Expression<?> e2 = p2.accept(this);
    StringExpression s1 = getSingleOfType(StringExpression.class, e1);
    NumberExpression n2 = getSingleOfType(NumberExpression.class, e2);
    if (params.size() > 2) {
        de.fraunhofer.iosb.ilt.sta.query.expression.Expression p3 = node.getParameters().get(2);
        Expression<?> e3 = p3.accept(this);
        NumberExpression n3 = getSingleOfType(NumberExpression.class, e3);
        return s1.substring(n2, n3);
    }
    return s1.substring(n2);
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
public static <T extends Expression<?>> T checkType(Class<T> expectedClazz, Expression<?> input, boolean canCast) {
    if (expectedClazz.isAssignableFrom(input.getClass())) {
        LOGGER.debug("Is {}: {} ({} -- {})", expectedClazz.getName(), input, input.getClass().getName(), input.getType().getName());
        return expectedClazz.cast(input);
    } else {
        if (canCast && StringExpression.class.equals(expectedClazz) && input instanceof NumberPath) {
            NumberPath numberPath = (NumberPath) input;
            return (T) numberPath.stringValue();
        }
        LOGGER.debug("Not a {}: {} ({} -- {})", expectedClazz.getName(), input, input.getClass().getName(), input.getType().getName());
        throw new IllegalArgumentException("Could not convert parameter of type " + input.getClass().getName() + " to type " + expectedClazz.getName());
    }
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
public static GeometryExpression<?> createPointWithDefaultSRID(@Nonnull final NumberPath<Integer> longitude,
                                                               @Nonnull final NumberPath<Integer> latitude) {

    Objects.requireNonNull(longitude, "longitude must not be null");
    Objects.requireNonNull(latitude, "latitude must not be null");

    final StringExpression point = longitude.stringValue()
            .prepend(constant("POINT("))
            .concat(constant(" "))
            .concat(latitude.stringValue())
            .concat(constant(")"));

    return GeometryExpressions.setSRID(fromText(point), SRID.ETRS_TM35FIN.getValue());
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
@Override
    default public void customize(QuerydslBindings bindings, QCustomer cust) {

//        bindings.bind(cust.firstName).first(StringExpression::containsIgnoreCase);

        bindings
                .bind(String.class)
                .first((SingleValueBinding<StringPath, String>) StringExpression::containsIgnoreCase);

        bindings
                .bind(Long.class)
                .first((SingleValueBinding<NumberPath<Long>, Long>) NumberExpression::goe);

//        bindings.excluding(cust.lastName);
    }
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
private BooleanExpression equal(StringExpression stringPath, String valueArgument) {
    if (valueArgument.startsWith(WILDCARD) && valueArgument.endsWith(WILDCARD)) {
        return stringPath.containsIgnoreCase(sanitizeWildcard(valueArgument));
    } else if (valueArgument.endsWith(WILDCARD)) {
        return stringPath.startsWithIgnoreCase(sanitizeWildcard(valueArgument));
    } else if (valueArgument.startsWith(WILDCARD)) {
        return stringPath.endsWithIgnoreCase(sanitizeWildcard(valueArgument));
    } else {
        return stringPath.equalsIgnoreCase(valueArgument);
    }
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
public ConstantDurationExpression(final StringExpression duration) {
    this.duration = duration;
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
public StringExpression getDuration() {
    return duration;
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
private static StringTemplate replaceAll(StringExpression string, String pattern, String replacement) {
    return _replaceAll(string, pattern, replacement);
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
private Predicate handle(Expression expression, FilterOperator operator, Object value) { // NOSONAR
	// checking multiple comparision implementations is a mess, created
	// https://github.com/querydsl/querydsl/issues/2028
	if (operator == FilterOperator.EQ || operator == FilterOperator.NEQ) {
		return handleEquals(expression, operator, value);
	}
	else if (operator == FilterOperator.LIKE) {
		return ((StringExpression) expression).lower().like(value.toString().toLowerCase());
	}
	else if (operator == FilterOperator.GT) {
		if (expression instanceof FetchableSubQueryBase) {
			return ((FetchableSubQueryBase) expression).gt((Number) value);
		}
		else if (expression instanceof NumberExpression) {
			return ((NumberExpression) expression).gt((Number) value);
		}
		else {
			return ((ComparableExpression) expression).gt((Comparable) value);
		}
	}
	else if (operator == FilterOperator.LT) {
		if (expression instanceof FetchableSubQueryBase) {
			return ((FetchableSubQueryBase) expression).lt((Number) value);
		}
		else if (expression instanceof NumberExpression) {
			return ((NumberExpression) expression).lt((Number) value);
		}
		else {
			return ((ComparableExpression) expression).lt((Comparable) value);
		}
	}
	else if (operator == FilterOperator.GE) {
		if (expression instanceof FetchableSubQueryBase) {
			return ((FetchableSubQueryBase) expression).goe((Number) value);
		}
		else if (expression instanceof NumberExpression) {
			return ((NumberExpression) expression).goe((Number) value);
		}
		else {
			return ((ComparableExpression) expression).goe((Comparable) value);
		}
	}
	else if (operator == FilterOperator.LE) {
		if (expression instanceof FetchableSubQueryBase) {
			return ((FetchableSubQueryBase) expression).loe((Number) value);
		}
		else if (expression instanceof NumberExpression) {
			return ((NumberExpression) expression).loe((Number) value);
		}
		else {
			return ((ComparableExpression) expression).loe((Comparable) value);
		}
	}
	else {
		throw new IllegalStateException("unexpected operator " + operator);
	}

}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
@Override
default public void customize(QuerydslBindings bindings, QCustomer root) {
    bindings.bind(String.class).first((SingleValueBinding<StringPath, String>) StringExpression::startsWithIgnoreCase);
    bindings.bind(Long.class).first((SingleValueBinding<NumberPath<Long>, Long>) NumberExpression::in);
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
@Override
default public void customize(QuerydslBindings bindings, QContact root) {
    bindings.bind(String.class).first((SingleValueBinding<StringPath, String>) StringExpression::containsIgnoreCase);
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
@Override
default public void customize(QuerydslBindings bindings, QUser root) {
    bindings.bind(String.class).first((SingleValueBinding<StringPath, String>) StringExpression::containsIgnoreCase);
    bindings.excluding(root.password);
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
@Override
default public void customize(QuerydslBindings bindings, QGroup root) {
    bindings.bind(String.class).first((SingleValueBinding<StringPath, String>) StringExpression::containsIgnoreCase);
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
@Override
default public void customize(QuerydslBindings bindings, QRole root) {
    bindings.bind(String.class).first((SingleValueBinding<StringPath, String>) StringExpression::containsIgnoreCase);
}
 

import com.querydsl.core.types.dsl.StringExpression; //导入依赖的package包/类
@Override
default public void customize(QuerydslBindings bindings, QAuthority root) {
    bindings.bind(String.class).first((SingleValueBinding<StringPath, String>) StringExpression::containsIgnoreCase);
}