JavaNeo4JAdaptor - bug fix and refactoring

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/QueryConverter.java

@@ -14,6 +14,7 @@
 
 import er.extensions.eof.qualifiers.ERXInQualifier;
 import er.neo4jadaptor.ersatz.webobjects.NSTranslator;
+import er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator;
 
 /**
  * Converts {@link EOQualifier}s to custom type of queries.
@@ -24,36 +25,6 @@
  */
 public abstract class QueryConverter <ClauseType> {
 
-	public static enum ComparisonOperator {
-		LESS_THAN("<"),
-		LESS_OR_EQUAL("<="),
-		GREATER_THAN(">"),
-		GREATER_OR_EQUAL(">="), 
-		EQUAL("="),
-		/**
-		 * Case sensitive match using wildcards
-		 */
-		LIKE("like"),
-		/**
-		 * Case insensitive match using wildcards
-		 */
-		ILIKE("ilike"),
-		/**
-		 * Regular expression match
-		 */
-		MATCHES("matches");
-
-		private final String asString;
-
-		private ComparisonOperator(String asString) {
-			this.asString = asString;
-		}
-
-		@Override
-		public String toString() {
-			return asString;
-		}
-	}
 
 	/**
 	 * @param entity

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/Results.java

@@ -7,12 +7,11 @@
 
 
 /**
- * Provides iterator for the search results.
+ * Marker interface for the search results cursor.
  * 
  * @author Jedrzej Sobanski
  *
  * @param <T>
  */
-public interface Results <T extends PropertyContainer> {
-	public Cursor<T> iterator();
+public interface Results <T extends PropertyContainer> extends Cursor<T> {
 }

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/all_of_type/results/ObjectsOfType.java

@@ -1,34 +1,19 @@
 package er.neo4jadaptor.query.all_of_type.results;
 
-import java.util.Iterator;
-
-import org.apache.lucene.search.Query;
 import org.neo4j.graphdb.PropertyContainer;
 import org.neo4j.graphdb.index.Index;
 
 import com.webobjects.eoaccess.EOEntity;
 
 import er.neo4jadaptor.query.Results;
 import er.neo4jadaptor.query.lucene.LuceneQueryConverter;
-import er.neo4jadaptor.utils.cursor.Cursor;
 import er.neo4jadaptor.utils.cursor.IteratorCursor;
 
-public class ObjectsOfType <Type extends PropertyContainer> implements Results<Type> {
+public class ObjectsOfType <Type extends PropertyContainer> extends IteratorCursor<Type> implements Results<Type> {
 	@SuppressWarnings("unused")
 	private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(ObjectsOfType.class);
 
-	private final Index<Type> typeIndex;
-	private final EOEntity entity;
-
 	public ObjectsOfType(Index<Type> nodeIndex, EOEntity entity) {
-		this.typeIndex = nodeIndex;
-		this.entity = entity;
-	}
-
-	public Cursor<Type> iterator() {
-		Query q = LuceneQueryConverter.matchAllOfEntity(entity);
-		Iterator<Type> it = typeIndex.query(q).iterator();
-
-		return new IteratorCursor<Type>(it);
+		super(nodeIndex.query(LuceneQueryConverter.matchAllOfEntity(entity)).iterator());
 	}
 }

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/expression/Converter.java

@@ -0,0 +1,138 @@
+package er.neo4jadaptor.query.expression;
+
+import static er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator.EQUAL;
+import static er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator.GREATER_OR_EQUAL;
+import static er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator.GREATER_THAN;
+import static er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator.ILIKE;
+import static er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator.LESS_OR_EQUAL;
+import static er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator.LESS_THAN;
+import static er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator.LIKE;
+import static er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator.MATCHES;
+import static er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator.NOT_EQUAL;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import com.webobjects.eoaccess.EOAttribute;
+import com.webobjects.eoaccess.EOEntity;
+import com.webobjects.eoaccess.EORelationship;
+import com.webobjects.eocontrol.EOAndQualifier;
+import com.webobjects.eocontrol.EOKeyValueQualifier;
+import com.webobjects.eocontrol.EONotQualifier;
+import com.webobjects.eocontrol.EOOrQualifier;
+import com.webobjects.eocontrol.EOQualifier;
+import com.webobjects.foundation.NSKeyValueCoding;
+import com.webobjects.foundation.NSSelector;
+
+import er.neo4jadaptor.ersatz.webobjects.NSTranslator;
+import er.neo4jadaptor.query.expression.sentence.BinaryJoined;
+import er.neo4jadaptor.query.expression.sentence.Comparison;
+import er.neo4jadaptor.query.expression.sentence.Negation;
+import er.neo4jadaptor.query.expression.sentence.Sentence;
+import er.neo4jadaptor.query.expression.sentence.operators.BinaryOperator;
+import er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator;
+
+public class Converter {
+	private final EOEntity entity;
+
+	public Converter(EOEntity entity) {
+		this.entity = entity;
+	}
+
+	public Sentence convert(EOQualifier q) {
+		if (q instanceof EOAndQualifier) {
+			Collection<Sentence> components = convertCollection(((EOAndQualifier) q).qualifiers());
+
+			return new BinaryJoined(BinaryOperator.AND, components);
+		} else if (q instanceof EOOrQualifier) {
+			Collection<Sentence> components = convertCollection(((EOOrQualifier) q).qualifiers());
+
+			return new BinaryJoined(BinaryOperator.OR, components);
+		} else if (q instanceof EONotQualifier) {
+			Sentence component = convert(((EONotQualifier) q).qualifier());
+
+			return new Negation(component);
+		} else if (q instanceof EOKeyValueQualifier) {
+			return convertComparison((EOKeyValueQualifier) q);
+		} else {
+			throw new IllegalArgumentException();
+		}
+	}
+
+	private Collection<Sentence> convertCollection(Collection<EOQualifier> qualifiers) {
+		Collection<Sentence> components = new ArrayList<Sentence>();
+
+		for (EOQualifier q : qualifiers) {
+			components.add(convert(q));
+		}
+		return components;
+	}
+
+	private ComparisonOperator operator(NSSelector<?> operator) {
+		if (operator.equals(EOKeyValueQualifier.QualifierOperatorEqual)) {
+			return EQUAL;
+		} else if (operator.equals(EOKeyValueQualifier.QualifierOperatorNotEqual)) {
+			return NOT_EQUAL;
+		} else if (operator.equals(EOKeyValueQualifier.QualifierOperatorLessThanOrEqualTo)) {
+			return LESS_OR_EQUAL;
+		} else if (operator.equals(EOKeyValueQualifier.QualifierOperatorLessThan)) {
+			return LESS_THAN;
+		} else if (operator.equals(EOKeyValueQualifier.QualifierOperatorGreaterThanOrEqualTo)) {
+			return GREATER_OR_EQUAL;
+		} else if (operator.equals(EOKeyValueQualifier.QualifierOperatorGreaterThan)) {
+			return GREATER_THAN;
+		} else if (operator.equals(EOKeyValueQualifier.QualifierOperatorLike)) {
+			return LIKE;
+		} else if (operator.equals(EOKeyValueQualifier.QualifierOperatorCaseInsensitiveLike)) {
+			return ILIKE;
+		} else if (ComparisonOperator.MATCHES.asString.equals(operator.name())) {
+			return MATCHES;
+		} else {
+			// case not covered
+			throw new UnsupportedOperationException(operator.toString());
+		}
+	}
+
+	private Comparison convertComparison(EOKeyValueQualifier qual) {
+		ComparisonOperator operator = operator(qual.selector());
+		String key = qual.key();
+		Object value = NSTranslator.instance.toNeutralValue(qual.value(), entity.attributeNamed(key));
+		EOEntity currentEntity = entity;
+		String [] splits = key.split("\\.");
+		Collection<EORelationship> rels = new ArrayList<EORelationship>();
+
+		for (int i=0; i<splits.length - 1; i++) {
+			EORelationship rel = currentEntity.relationshipNamed(splits[i]);
+
+			rels.add(rel);
+			currentEntity = rel.destinationEntity();
+		}
+
+		// now process the last bit
+		String last = splits[splits.length-1];
+
+		if (entity.attributeNamed(last) != null) {
+			// it's a plain attribute value comparison 
+			return new Comparison(rels, entity.attributeNamed(last), operator, value);
+		} else {
+			// it's a relationship value comparison, let's represent it as attribute comparison
+			EORelationship lastRel = entity.relationshipNamed(last);
+			EOAttribute srcAtt = asOne(lastRel.sourceAttributes());
+			EOAttribute dstAtt = asOne(lastRel.destinationAttributes());
+
+			rels.add(lastRel);
+			if (value != null) {
+				value = ((NSKeyValueCoding) value).valueForKey(dstAtt.name());
+			}
+			return new Comparison(rels, srcAtt, operator, value);
+		}
+	}
+
+	private <T> T asOne(Collection<T> col) {
+		if (col.size() != 1) {
+			throw new IllegalArgumentException();
+		} else {
+			return col.iterator().next();
+		}
+	}
+}

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/expression/sentence/BinaryJoined.java

@@ -0,0 +1,15 @@
+package er.neo4jadaptor.query.expression.sentence;
+
+import java.util.Collection;
+
+import er.neo4jadaptor.query.expression.sentence.operators.BinaryOperator;
+
+public class BinaryJoined extends Sentence {
+	private final Collection<Sentence> components;
+	private final BinaryOperator operator;
+
+	public BinaryJoined(BinaryOperator op, Collection<Sentence> components) {
+		this.operator = op;
+		this.components = components;
+	}
+}

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/expression/sentence/Comparison.java

@@ -0,0 +1,24 @@
+package er.neo4jadaptor.query.expression.sentence;
+
+import java.util.Collection;
+
+import com.webobjects.eoaccess.EOAttribute;
+import com.webobjects.eoaccess.EORelationship;
+
+import er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator;
+
+
+
+public class Comparison extends Sentence {
+	private final Collection<EORelationship> relationships;
+	private final EOAttribute attribute;
+	private final ComparisonOperator operator;
+	private final Object value;
+
+	public Comparison(Collection<EORelationship> rels, EOAttribute att, ComparisonOperator op, Object val) {
+		this.relationships = rels;
+		this.attribute = att;
+		this.operator = op;
+		this.value = val;
+	}
+}

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/expression/sentence/Negation.java

@@ -0,0 +1,9 @@
+package er.neo4jadaptor.query.expression.sentence;
+
+public class Negation extends Sentence {
+	private final Sentence wrapped;
+
+	public Negation(Sentence toNegate) {
+		this.wrapped = toNegate;
+	}
+}

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/expression/sentence/Sentence.java

@@ -0,0 +1,5 @@
+package er.neo4jadaptor.query.expression.sentence;
+
+public abstract class Sentence {
+
+}

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/expression/sentence/operators/BinaryOperator.java

@@ -0,0 +1,5 @@
+package er.neo4jadaptor.query.expression.sentence.operators;
+
+public enum BinaryOperator {
+	AND, OR;
+}

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/expression/sentence/operators/ComparisonOperator.java

@@ -0,0 +1,36 @@
+package er.neo4jadaptor.query.expression.sentence.operators;
+
+
+public enum ComparisonOperator {
+	LESS_THAN("<"),
+	LESS_OR_EQUAL("<="),
+	GREATER_THAN(">"),
+	GREATER_OR_EQUAL(">="), 
+	EQUAL("="),
+	NOT_EQUAL("!="),
+
+	/**
+	 * Case sensitive match using wildcards
+	 */
+	LIKE("like"),
+	/**
+	 * Case insensitive match using wildcards
+	 */
+	ILIKE("ilike"),
+	/**
+	 * Regular expression match
+	 */
+	MATCHES("matches");
+
+	public final String asString;
+
+	private ComparisonOperator(String asString) {
+		this.asString = asString;
+	}
+
+	@Override
+	public String toString() {
+		return asString;
+	}
+
+}

Frameworks/EOAdaptors/JavaNeo4JAdaptor/Sources/er/neo4jadaptor/query/lucene/LuceneQueryConverter.java

@@ -21,6 +21,7 @@
 import er.neo4jadaptor.ersatz.lucene.LuceneErsatz;
 import er.neo4jadaptor.ersatz.lucene.LuceneTranslator;
 import er.neo4jadaptor.query.QueryConverter;
+import er.neo4jadaptor.query.expression.sentence.operators.ComparisonOperator;
 import er.neo4jadaptor.storage.lucene.LuceneStore;
 
 /**
@@ -102,7 +103,7 @@ protected Query convertKeyValueQualifier(EOEntity entity, EOKeyValueQualifier qu
 		}
 	}
 
-	private Query rangeQuery(String key, EOAttribute att, QueryConverter.ComparisonOperator operator, Object value) {
+	private Query rangeQuery(String key, EOAttribute att, ComparisonOperator operator, Object value) {
 		String min = null;
 		String max = null;
 		boolean minInclusive = false;
@@ -121,18 +122,18 @@ private Query rangeQuery(String key, EOAttribute att, QueryConverter.ComparisonO
 			break;
 		}
 
-		if (QueryConverter.ComparisonOperator.LESS_OR_EQUAL.equals(operator)) {
+		if (ComparisonOperator.LESS_OR_EQUAL.equals(operator)) {
 			maxInclusive = true;
 		}
-		if (QueryConverter.ComparisonOperator.GREATER_OR_EQUAL.equals(operator)) {
+		if (ComparisonOperator.GREATER_OR_EQUAL.equals(operator)) {
 			minInclusive = true;
 		}
 
 		return new TermRangeQuery(key, min, max, minInclusive, maxInclusive);
 	}
 
 	@Override
-	protected Query comparison(EOEntity entity, String key, QueryConverter.ComparisonOperator operator, Object value) {
+	protected Query comparison(EOEntity entity, String key, ComparisonOperator operator, Object value) {
 		EOAttribute att = entity.attributeNamed(key);
 		String luceneValue = LuceneTranslator.instance.fromNeutralValue(value, att);