in grails-data-mongodb/bson/src/main/groovy/org/grails/datastore/bson/query/BsonQuery.java [89:499]
static {
queryHandlers.put(IdEquals.class, new QueryHandler<IdEquals>() {
public void handle(EmbeddedQueryEncoder queryEncoder, IdEquals criterion, Document query, PersistentEntity entity) {
Object value = criterion.getValue();
MappingContext mappingContext = entity.getMappingContext();
PersistentProperty identity = entity.getIdentity();
Object converted = mappingContext.getConversionService().convert(value, identity.getType());
Property mappedForm = identity.getMapping().getMappedForm();
String targetProperty = mappedForm.getTargetName();
if(targetProperty == null) {
targetProperty = identity.getName();
}
query.put(targetProperty, converted);
}
});
queryHandlers.put(Equals.class, new QueryHandler<Equals>() {
public void handle(EmbeddedQueryEncoder queryEncoder, Equals criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
PersistentProperty persistentProperty = entity.getPropertyByName(criterion.getProperty());
Object value;
if ((persistentProperty instanceof Embedded) && criterion.getValue() != null) {
value = queryEncoder.encode((Embedded) persistentProperty, criterion.getValue());
} else {
value = criterion.getValue();
}
if (value instanceof Pattern) {
Pattern pattern = (Pattern) value;
query.put(propertyName, new Document(REGEX_OPERATOR, pattern.toString()));
} else {
query.put(propertyName, value);
}
}
});
queryHandlers.put(IsNull.class, new QueryHandler<IsNull>() {
@SuppressWarnings("unchecked")
public void handle(EmbeddedQueryEncoder queryEncoder, IsNull criterion, Document query, PersistentEntity entity) {
queryHandlers.get(Equals.class).handle(queryEncoder, new Equals(criterion.getProperty(), null), query, entity);
}
});
queryHandlers.put(IsNotNull.class, new QueryHandler<IsNotNull>() {
@SuppressWarnings("unchecked")
public void handle(EmbeddedQueryEncoder queryEncoder, IsNotNull criterion, Document query, PersistentEntity entity) {
queryHandlers.get(NotEquals.class).handle(queryEncoder, new NotEquals(criterion.getProperty(), null), query, entity);
}
});
queryHandlers.put(EqualsProperty.class, new QueryHandler<EqualsProperty>() {
public void handle(EmbeddedQueryEncoder queryEncoder, EqualsProperty criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
String otherPropertyName = getPropertyName(entity, criterion.getOtherProperty());
addWherePropertyComparison(query, propertyName, otherPropertyName, "==");
}
});
queryHandlers.put(NotEqualsProperty.class, new QueryHandler<NotEqualsProperty>() {
public void handle(EmbeddedQueryEncoder queryEncoder, NotEqualsProperty criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
String otherPropertyName = getPropertyName(entity, criterion.getOtherProperty());
addWherePropertyComparison(query, propertyName, otherPropertyName, "!=");
}
});
queryHandlers.put(GreaterThanProperty.class, new QueryHandler<GreaterThanProperty>() {
public void handle(EmbeddedQueryEncoder queryEncoder, GreaterThanProperty criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
String otherPropertyName = getPropertyName(entity, criterion.getOtherProperty());
addWherePropertyComparison(query, propertyName, otherPropertyName, ">");
}
});
queryHandlers.put(LessThanProperty.class, new QueryHandler<LessThanProperty>() {
public void handle(EmbeddedQueryEncoder queryEncoder, LessThanProperty criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
String otherPropertyName = getPropertyName(entity, criterion.getOtherProperty());
addWherePropertyComparison(query, propertyName, otherPropertyName, "<");
}
});
queryHandlers.put(GreaterThanEqualsProperty.class, new QueryHandler<GreaterThanEqualsProperty>() {
public void handle(EmbeddedQueryEncoder queryEncoder, GreaterThanEqualsProperty criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
String otherPropertyName = getPropertyName(entity, criterion.getOtherProperty());
addWherePropertyComparison(query, propertyName, otherPropertyName, ">=");
}
});
queryHandlers.put(LessThanEqualsProperty.class, new QueryHandler<LessThanEqualsProperty>() {
public void handle(EmbeddedQueryEncoder queryEncoder, LessThanEqualsProperty criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
String otherPropertyName = getPropertyName(entity, criterion.getOtherProperty());
addWherePropertyComparison(query, propertyName, otherPropertyName, "<=");
}
});
queryHandlers.put(NotEquals.class, new QueryHandler<NotEquals>() {
public void handle(EmbeddedQueryEncoder queryEncoder, NotEquals criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Document notEqualQuery = getOrCreatePropertyQuery(query, propertyName);
notEqualQuery.put(NE_OPERATOR, criterion.getValue());
query.put(propertyName, notEqualQuery);
}
});
queryHandlers.put(Like.class, new QueryHandler<Like>() {
public void handle(EmbeddedQueryEncoder queryEncoder, Like like, Document query, PersistentEntity entity) {
handleLike(entity, like, query, true);
}
});
queryHandlers.put(ILike.class, new QueryHandler<ILike>() {
public void handle(EmbeddedQueryEncoder queryEncoder, ILike like, Document query, PersistentEntity entity) {
handleLike(entity, like, query, false);
}
});
queryHandlers.put(RLike.class, new QueryHandler<RLike>() {
public void handle(EmbeddedQueryEncoder queryEncoder, RLike like, Document query, PersistentEntity entity) {
Object value = like.getValue();
if (value == null) value = "null";
final String expr = value.toString();
Pattern regex = Pattern.compile(expr);
String propertyName = getPropertyName(entity, like);
query.put(propertyName, regex);
}
});
queryHandlers.put(In.class, new QueryHandler<In>() {
public void handle(EmbeddedQueryEncoder queryEncoder, In in, Document query, PersistentEntity entity) {
Document inQuery = new Document();
List values = getInListQueryValues(entity, in);
inQuery.put(IN_OPERATOR, values);
String propertyName = getPropertyName(entity, in);
query.put(propertyName, inQuery);
}
});
queryHandlers.put(Between.class, new QueryHandler<Between>() {
public void handle(EmbeddedQueryEncoder queryEncoder, Between between, Document query, PersistentEntity entity) {
Document betweenQuery = new Document();
betweenQuery.put(GTE_OPERATOR, between.getFrom());
betweenQuery.put(LTE_OPERATOR, between.getTo());
String propertyName = getPropertyName(entity, between);
query.put(propertyName, betweenQuery);
}
});
queryHandlers.put(GreaterThan.class, new QueryHandler<GreaterThan>() {
public void handle(EmbeddedQueryEncoder queryEncoder, GreaterThan criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Document greaterThanQuery = getOrCreatePropertyQuery(query, propertyName);
greaterThanQuery.put(GT_OPERATOR, criterion.getValue());
query.put(propertyName, greaterThanQuery);
}
});
queryHandlers.put(GreaterThanEquals.class, new QueryHandler<GreaterThanEquals>() {
public void handle(EmbeddedQueryEncoder queryEncoder, GreaterThanEquals criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Document greaterThanQuery = getOrCreatePropertyQuery(query, propertyName);
greaterThanQuery.put(GTE_OPERATOR, criterion.getValue());
query.put(propertyName, greaterThanQuery);
}
});
queryHandlers.put(LessThan.class, new QueryHandler<LessThan>() {
public void handle(EmbeddedQueryEncoder queryEncoder, LessThan criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Document lessThanQuery = getOrCreatePropertyQuery(query, propertyName);
lessThanQuery.put(LT_OPERATOR, criterion.getValue());
query.put(propertyName, lessThanQuery);
}
});
queryHandlers.put(LessThanEquals.class, new QueryHandler<LessThanEquals>() {
public void handle(EmbeddedQueryEncoder queryEncoder, LessThanEquals criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Document lessThanQuery = getOrCreatePropertyQuery(query, propertyName);
lessThanQuery.put(LTE_OPERATOR, criterion.getValue());
query.put(propertyName, lessThanQuery);
}
});
queryHandlers.put(Conjunction.class, new QueryHandler<Conjunction>() {
public void handle(EmbeddedQueryEncoder queryEncoder, Conjunction criterion, Document query, PersistentEntity entity) {
populateBsonQuery(queryEncoder, query, criterion, entity);
}
});
queryHandlers.put(Negation.class, new QueryHandler<Negation>() {
@SuppressWarnings("unchecked")
public void handle(EmbeddedQueryEncoder queryEncoder, Negation criteria, Document query, PersistentEntity entity) {
List nor = new ArrayList();
query.put(NOR_OPERATOR, nor);
for (Criterion criterion : criteria.getCriteria()) {
Document negatedQuery = new Document();
nor.add(negatedQuery);
if(criterion instanceof PropertyCriterion) {
PropertyCriterion pc = (PropertyCriterion) criterion;
PersistentProperty property = entity.getPropertyByName(pc.getProperty());
if (property instanceof Custom) {
CustomTypeMarshaller customTypeMarshaller = ((Custom) property).getCustomTypeMarshaller();
customTypeMarshaller.query(property, pc, query);
continue;
}
}
final QueryHandler queryHandler = queryHandlers.get(criterion.getClass());
if (queryHandler != null) {
queryHandler.handle(queryEncoder, criterion, negatedQuery, entity);
} else {
throw new UnsupportedOperationException("Query of type " + criterion.getClass().getSimpleName() + " cannot be negated");
}
}
}
});
queryHandlers.put(Disjunction.class, new QueryHandler<Disjunction>() {
@SuppressWarnings("unchecked")
public void handle(EmbeddedQueryEncoder queryEncoder, Disjunction criterion, Document query, PersistentEntity entity) {
populateBsonQuery(queryEncoder, query, criterion, entity);
}
});
queryHandlers.put(SizeEquals.class, new QueryHandler<SizeEquals>() {
@SuppressWarnings("unchecked")
public void handle(EmbeddedQueryEncoder queryEncoder, SizeEquals criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Document sizeEqualsQuery = getOrCreatePropertyQuery(query, propertyName);
sizeEqualsQuery.put(SIZE_OPERATOR, getNumber(criterion));
query.put(propertyName, sizeEqualsQuery);
}
});
queryHandlers.put(SizeNotEquals.class, new QueryHandler<SizeNotEquals>() {
public void handle(EmbeddedQueryEncoder queryEncoder, SizeNotEquals criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Document sizeNotEqualsQuery = getOrCreatePropertyQuery(query, propertyName);
sizeNotEqualsQuery.put(NOT_OPERATOR, new Document(SIZE_OPERATOR, getNumber(criterion)));
query.put(propertyName, sizeNotEqualsQuery);
}
});
queryHandlers.put(SizeGreaterThan.class, new QueryHandler<SizeGreaterThan>() {
@SuppressWarnings("unchecked")
public void handle(EmbeddedQueryEncoder queryEncoder, SizeGreaterThan criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Integer greaterThanValue = getNumber(criterion);
query.put(propertyName + '.' + greaterThanValue, new Document(EXISTS_OPERATOR, true));
}
});
queryHandlers.put(SizeLessThan.class, new QueryHandler<SizeLessThan>() {
@SuppressWarnings("unchecked")
public void handle(EmbeddedQueryEncoder queryEncoder, SizeLessThan criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Integer lessThanValue = getNumber(criterion);
query.put(propertyName + '.' + (lessThanValue - 1), new Document(EXISTS_OPERATOR, 0));
}
});
queryHandlers.put(SizeLessThanEquals.class, new QueryHandler<SizeLessThanEquals>() {
@SuppressWarnings("unchecked")
public void handle(EmbeddedQueryEncoder queryEncoder, SizeLessThanEquals criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Integer lessThanValue = getNumber(criterion);
query.put(propertyName + '.' + lessThanValue, new Document(EXISTS_OPERATOR, 0));
}
});
queryHandlers.put(SizeGreaterThanEquals.class, new QueryHandler<SizeGreaterThanEquals>() {
@SuppressWarnings("unchecked")
public void handle(EmbeddedQueryEncoder queryEncoder, SizeGreaterThanEquals criterion, Document query, PersistentEntity entity) {
String propertyName = getPropertyName(entity, criterion);
Integer greaterThanValue = getNumber(criterion);
query.put(propertyName + '.' + (greaterThanValue - 1), new Document(EXISTS_OPERATOR, true));
}
});
operatorHandlers.put(GT_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Object value = readBsonValue(queryReader, queryReader.getCurrentBsonType());
if(value != null && !(value instanceof NullObject)) {
criteria.add(new Query.GreaterThan(attributeName, value));
}
}
});
operatorHandlers.put(GTE_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Object value = readBsonValue(queryReader, queryReader.getCurrentBsonType());
if(value != null && !(value instanceof NullObject)) {
criteria.add(new Query.GreaterThanEquals(attributeName, value));
}
}
});
operatorHandlers.put(LT_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Object value = readBsonValue(queryReader, queryReader.getCurrentBsonType());
if(value != null && !(value instanceof NullObject)) {
criteria.add(new Query.LessThan(attributeName, value));
}
}
});
operatorHandlers.put(LTE_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Object value = readBsonValue(queryReader, queryReader.getCurrentBsonType());
if(value != null && !(value instanceof NullObject)) {
criteria.add(new Query.LessThanEquals(attributeName, value));
}
}
});
operatorHandlers.put(NE_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Object value = readBsonValue(queryReader, queryReader.getCurrentBsonType());
if(value != null && !(value instanceof NullObject)) {
criteria.add(new Query.NotEquals(attributeName, value));
}
}
});
operatorHandlers.put(EQ_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Object value = readBsonValue(queryReader, queryReader.getCurrentBsonType());
if(value != null) {
criteria.add(new Query.Equals(attributeName, value));
}
}
});
operatorHandlers.put(REGEX_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Object value = readBsonValue(queryReader, queryReader.getCurrentBsonType());
if(value != null && !(value instanceof NullObject)) {
criteria.add(new Query.RLike(attributeName, value.toString()));
}
}
});
operatorHandlers.put(OR_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Disjunction disjunction = new Disjunction();
criteria.add(disjunction);
queryReader.readStartArray();
BsonType bsonType = queryReader.readBsonType();
parseJunctionDocuments(disjunction, attributeName, queryReader, bsonType);
queryReader.readEndArray();
}
});
operatorHandlers.put(IN_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
List values = readArrayOfValues(queryReader);
criteria.add(new Query.In(attributeName, values));
}
});
operatorHandlers.put(NIN_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Negation negation = new Negation();
List values = readArrayOfValues(queryReader);
negation.add(new Query.In(attributeName, values));
criteria.add(negation);
}
});
operatorHandlers.put(NOT_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Negation negation = new Negation();
criteria.add(negation);
queryReader.readStartArray();
BsonType bsonType = queryReader.readBsonType();
parseJunctionDocuments(negation, attributeName, queryReader, bsonType);
queryReader.readEndArray();
}
});
operatorHandlers.put(AND_OPERATOR, new OperatorHandler() {
@Override
public void handle(Junction criteria, String attributeName, BsonReader queryReader) {
Conjunction conj = new Conjunction();
criteria.add(conj);
queryReader.readStartArray();
BsonType bsonType = queryReader.readBsonType();
parseJunctionDocuments(conj, attributeName, queryReader, bsonType);
queryReader.readEndArray();
}
});
}