@Override public Object mergeResults(final Map<String, Object> results) throws Exception { if (results.isEmpty()) return null; Object aggregatedResult = null; for (Map.Entry<String, Object> entry : results.entrySet()) { final String nodeName = entry.getKey(); final Object nodeResult = entry.getValue(); if (nodeResult instanceof Collection) { if (aggregatedResult == null) aggregatedResult = new ArrayList(); ((List) aggregatedResult).addAll((Collection<?>) nodeResult); } else if (nodeResult instanceof Exception) // RECEIVED EXCEPTION throw (Exception) nodeResult; else if (nodeResult instanceof OIdentifiable) { if (aggregatedResult == null) aggregatedResult = new ArrayList(); ((List) aggregatedResult).add(nodeResult); } else if (nodeResult instanceof Number) { if (aggregatedResult == null) aggregatedResult = nodeResult; else OMultiValue.add(aggregatedResult, nodeResult); } } return aggregatedResult; }
public void formatMultiValue( final Iterator<?> iIterator, final StringWriter buffer, final String format) throws IOException { if (iIterator != null) { int counter = 0; String objectJson; while (iIterator.hasNext()) { final Object entry = iIterator.next(); if (entry != null) { if (counter++ > 0) buffer.append(", "); if (entry instanceof OIdentifiable) { ORecord<?> rec = ((OIdentifiable) entry).getRecord(); try { objectJson = rec.getRecord().toJSON(format); buffer.append(objectJson); } catch (Exception e) { OLogManager.instance() .error(this, "Error transforming record " + rec.getIdentity() + " to JSON", e); } } else if (OMultiValue.isMultiValue(entry)) formatMultiValue(OMultiValue.getMultiValueIterator(entry), buffer, format); else buffer.append(OJSONWriter.writeValue(entry, format)); } } } }
@Override public Object execute( Object iThis, OIdentifiable iCurrentRecord, Object iCurrentResult, Object[] iParams, OCommandContext iContext) { if (iParams[0] instanceof Number) { addValue((Number) iParams[0]); } else if (OMultiValue.isMultiValue(iParams[0])) { for (Object n : OMultiValue.getMultiValueIterable(iParams[0])) { addValue((Number) n); } } return null; }
@Override public String toString() { if (!deserialized) return "[size=" + size + "]"; if (size < 10) return OMultiValue.toString(this); else return "[size=" + size + "]"; }
public static String toString(final ORecordLazyMultiValue iMultivalue) { final boolean previousAutoConvertSetting = iMultivalue.isAutoConvertToRecord(); iMultivalue.setAutoConvertToRecord(false); final String result = OMultiValue.toString(iMultivalue); iMultivalue.setAutoConvertToRecord(previousAutoConvertSetting); return result; }
@SuppressWarnings("unchecked") public void writeResult(Object iResult, final String iFormat) throws InterruptedException, IOException { if (iResult == null) send( OHttpUtils.STATUS_OK_NOCONTENT_CODE, "", OHttpUtils.CONTENT_TEXT_PLAIN, null, null, true); else { if (iResult instanceof Map<?, ?>) { iResult = ((Map<?, ?>) iResult).entrySet().iterator(); } else if (OMultiValue.isMultiValue(iResult) && (OMultiValue.getSize(iResult) > 0 && !(OMultiValue.getFirstValue(iResult) instanceof OIdentifiable))) { final List<OIdentifiable> resultSet = new ArrayList<OIdentifiable>(); resultSet.add(new ODocument().field("value", iResult)); iResult = resultSet.iterator(); } else if (iResult instanceof OIdentifiable) { // CONVERT SIGLE VALUE IN A COLLECTION final List<OIdentifiable> resultSet = new ArrayList<OIdentifiable>(); resultSet.add((OIdentifiable) iResult); iResult = resultSet.iterator(); } else if (iResult instanceof Iterable<?>) iResult = ((Iterable<OIdentifiable>) iResult).iterator(); else if (OMultiValue.isMultiValue(iResult)) iResult = OMultiValue.getMultiValueIterator(iResult); else { final List<OIdentifiable> resultSet = new ArrayList<OIdentifiable>(); resultSet.add(new ODocument().field("value", iResult)); iResult = resultSet.iterator(); } if (iResult == null) send( OHttpUtils.STATUS_OK_NOCONTENT_CODE, "", OHttpUtils.CONTENT_TEXT_PLAIN, null, null, true); else if (iResult instanceof Iterator<?>) writeRecords((Iterator<OIdentifiable>) iResult, null, iFormat); } }
/** * Returns a Property value. * * @param key Property name * @return Property value if any, otherwise NULL. */ @Override public <T> T getProperty(final String key) { if (key == null) return null; final OrientBaseGraph graph = getGraph(); if (key.equals("_class")) return (T) ODocumentInternal.getImmutableSchemaClass(getRecord()).getName(); else if (key.equals("_version")) return (T) new Integer(getRecord().getVersion()); else if (key.equals("_rid")) return (T) rawElement.getIdentity().toString(); final Object fieldValue = getRecord().field(key); if (graph != null && fieldValue instanceof OIdentifiable && !(((OIdentifiable) fieldValue).getRecord() instanceof ORecordBytes)) // CONVERT IT TO VERTEX/EDGE return (T) graph.getElement(fieldValue); else if (OMultiValue.isMultiValue(fieldValue) && OMultiValue.getFirstValue(fieldValue) instanceof OIdentifiable) { final OIdentifiable firstValue = (OIdentifiable) OMultiValue.getFirstValue(fieldValue); if (firstValue instanceof ODocument) { final ODocument document = (ODocument) firstValue; if (document.isEmbedded() || ODocumentInternal.getImmutableSchemaClass(document) == null) return (T) fieldValue; } if (graph != null) // CONVERT IT TO ITERABLE<VERTEX/EDGE> return (T) new OrientElementIterable<OrientElement>( graph, OMultiValue.getMultiValueIterable(fieldValue)); } return (T) fieldValue; }
protected static boolean comparesValues( final Object iValue, final ORecord<?> iRecord, final boolean iConsiderIn) { // ORID && RECORD final ORID other = ((ORecord<?>) iRecord).getIdentity(); if (!other.isPersistent() && iRecord instanceof ODocument) { // ODOCUMENT AS RESULT OF SUB-QUERY: GET THE FIRST FIELD IF ANY final String[] firstFieldName = ((ODocument) iRecord).fieldNames(); if (firstFieldName.length > 0) { Object fieldValue = ((ODocument) iRecord).field(firstFieldName[0]); if (fieldValue != null) { if (iConsiderIn && OMultiValue.isMultiValue(fieldValue)) { for (Object o : OMultiValue.getMultiValueIterable(fieldValue)) { if (o != null && o.equals(iValue)) return true; } } return fieldValue.equals(iValue); } } return false; } return other.equals(iValue); }
public Object execute( Object iThis, final OIdentifiable iCurrentRecord, Object iCurrentResult, final Object[] iParams, OCommandContext iContext) { if (iParams.length > 1) // IN LINE MODE context = new HashSet<Object>(); for (Object value : iParams) { if (value != null) { if (iParams.length == 1 && context == null) // AGGREGATION MODE (STATEFULL) context = new HashSet<Object>(); if (value instanceof ODocument) context.add(value); else OMultiValue.add(context, value); } } return prepareResult(context); }
@SuppressWarnings("unchecked") private static void fetchCollection( final ORecordSchemaAware<?> iRootRecord, final Object iUserObject, final Map<String, Integer> iFetchPlan, final Object fieldValue, final String fieldName, final int iCurrentLevel, final int iLevelFromRoot, final int iFieldDepthLevel, final Map<ORID, Integer> parsedRecords, final String iFieldPathFromRoot, final OFetchListener iListener, final OFetchContext iContext) throws IOException { final Collection<?> linked; if (fieldValue instanceof ODocument) linked = new OMVRBTreeRIDSet().fromDocument((ODocument) fieldValue); else if (fieldValue instanceof Collection<?>) { linked = (Collection<OIdentifiable>) fieldValue; iContext.onBeforeCollection(iRootRecord, fieldName, iUserObject, linked); } else if (fieldValue instanceof Map<?, ?>) { linked = (Collection<?>) ((Map<?, ?>) fieldValue).values(); iContext.onBeforeMap(iRootRecord, fieldName, iUserObject); } else throw new IllegalStateException("Unrecognized type: " + fieldValue.getClass()); final Iterator<?> iter; if (linked instanceof ORecordLazyMultiValue) iter = ((ORecordLazyMultiValue) linked).rawIterator(); else iter = linked.iterator(); while (iter.hasNext()) { final Object o = iter.next(); if (o == null) continue; if (o instanceof OIdentifiable) { OIdentifiable d = (OIdentifiable) o; // GO RECURSIVELY final Integer fieldDepthLevel = parsedRecords.get(d.getIdentity()); if (!d.getIdentity().isValid() || (fieldDepthLevel != null && fieldDepthLevel.intValue() == iLevelFromRoot)) { removeParsedFromMap(parsedRecords, d); d = d.getRecord(); if (!(d instanceof ODocument)) { iListener.processStandardField(null, d, fieldName, iContext, iUserObject, ""); } else { iContext.onBeforeDocument(iRootRecord, (ODocument) d, fieldName, iUserObject); final Object userObject = iListener.fetchLinkedCollectionValue( iRootRecord, iUserObject, fieldName, (ODocument) d, iContext); processRecord( (ODocument) d, userObject, iFetchPlan, iCurrentLevel, iLevelFromRoot, iFieldDepthLevel, parsedRecords, iFieldPathFromRoot, iListener, iContext, ""); iContext.onAfterDocument(iRootRecord, (ODocument) d, fieldName, iUserObject); } } else { iListener.parseLinkedCollectionValue(iRootRecord, d, iUserObject, fieldName, iContext); } } else if (o instanceof Map<?, ?>) { fetchMap( iRootRecord, iUserObject, iFetchPlan, o, null, iCurrentLevel + 1, iLevelFromRoot, iFieldDepthLevel, parsedRecords, iFieldPathFromRoot, iListener, iContext); } else if (OMultiValue.isMultiValue(o)) { fetchCollection( iRootRecord, iUserObject, iFetchPlan, o, null, iCurrentLevel + 1, iLevelFromRoot, iFieldDepthLevel, parsedRecords, iFieldPathFromRoot, iListener, iContext); } } if (fieldValue instanceof Collection<?>) iContext.onAfterCollection(iRootRecord, fieldName, iUserObject); else if (fieldValue instanceof Map<?, ?>) iContext.onAfterMap(iRootRecord, fieldName, iUserObject); }
@SuppressWarnings("unchecked") private static void fetchMap( final ORecordSchemaAware<?> iRootRecord, final Object iUserObject, final Map<String, Integer> iFetchPlan, Object fieldValue, String fieldName, final int iCurrentLevel, final int iLevelFromRoot, final int iFieldDepthLevel, final Map<ORID, Integer> parsedRecords, final String iFieldPathFromRoot, final OFetchListener iListener, final OFetchContext iContext) throws IOException { final Map<String, ODocument> linked = (Map<String, ODocument>) fieldValue; iContext.onBeforeMap(iRootRecord, fieldName, iUserObject); for (Object key : linked.keySet()) { final Object o = linked.get(key); if (o instanceof OIdentifiable) { final ODocument d = ((OIdentifiable) o).getRecord(); if (d != null) { // GO RECURSIVELY final Integer fieldDepthLevel = parsedRecords.get(d.getIdentity()); if (!d.getIdentity().isValid() || (fieldDepthLevel != null && fieldDepthLevel.intValue() == iLevelFromRoot)) { removeParsedFromMap(parsedRecords, d); iContext.onBeforeDocument(iRootRecord, d, key.toString(), iUserObject); final Object userObject = iListener.fetchLinkedMapEntry( iRootRecord, iUserObject, fieldName, key.toString(), d, iContext); processRecord( d, userObject, iFetchPlan, iCurrentLevel, iLevelFromRoot, iFieldDepthLevel, parsedRecords, iFieldPathFromRoot, iListener, iContext, ""); iContext.onAfterDocument(iRootRecord, d, key.toString(), iUserObject); } else { iListener.parseLinked(iRootRecord, d, iUserObject, key.toString(), iContext); } } } else if (o instanceof Map) { fetchMap( iRootRecord, iUserObject, iFetchPlan, o, key.toString(), iCurrentLevel + 1, iLevelFromRoot, iFieldDepthLevel, parsedRecords, iFieldPathFromRoot, iListener, iContext); } else if (OMultiValue.isMultiValue(o)) { fetchCollection( iRootRecord, iUserObject, iFetchPlan, o, key.toString(), iCurrentLevel + 1, iLevelFromRoot, iFieldDepthLevel, parsedRecords, iFieldPathFromRoot, iListener, iContext); } else iListener.processStandardField(iRootRecord, o, key.toString(), iContext, iUserObject, ""); } iContext.onAfterMap(iRootRecord, fieldName, iUserObject); }
private static void processRecord( final ORecordSchemaAware<?> record, final Object iUserObject, final Map<String, Integer> iFetchPlan, final int iCurrentLevel, final int iLevelFromRoot, final int iFieldDepthLevel, final Map<ORID, Integer> parsedRecords, final String iFieldPathFromRoot, final OFetchListener iListener, final OFetchContext iContext, final String iFormat) throws IOException { Object fieldValue; iContext.onBeforeFetch(record); if (debug) { System.out.println("processRecord start"); System.out.println("iFieldDepthLevel: " + iFieldDepthLevel); System.out.println("record: " + record.toString()); System.out.println("iFetchPlan: " + iFetchPlan); System.out.println("iCurrentLevel: " + iCurrentLevel); System.out.println("iLevelFromRoot: " + iLevelFromRoot); System.out.println("iCurrentLevel: " + iCurrentLevel); System.out.println("parsedRecords: " + parsedRecords); System.out.println("iFieldPathFromRoot: " + iFieldPathFromRoot); } for (String fieldName : record.fieldNames()) { String fieldPath = !iFieldPathFromRoot.isEmpty() ? iFieldPathFromRoot + "." + fieldName : fieldName; if (debug) { System.out.println(" fieldName: " + fieldName); System.out.println(" fieldPath: " + fieldPath); } int depthLevel; depthLevel = getDepthLevel(iFetchPlan, fieldPath); if (depthLevel == -2) continue; if (iFieldDepthLevel > -1) depthLevel = iFieldDepthLevel; if (debug) System.out.println(" depthLevel: " + depthLevel); fieldValue = record.field(fieldName); boolean fetch = !iFormat.contains("shallow") && (!(fieldValue instanceof ODocument) || depthLevel == -1 || iCurrentLevel <= depthLevel || iFetchPlan.containsKey(fieldPath)); final boolean isEmbedded = fieldValue instanceof ODocument && (((ODocument) fieldValue).isEmbedded() || !((ODocument) fieldValue).getIdentity().isValid()); if (!fetch && isEmbedded && iContext.fetchEmbeddedDocuments()) // EMBEDDED, GO DEEPER fetch = true; if (iFormat.contains("shallow") || fieldValue == null || (!fetch && fieldValue instanceof OIdentifiable) || !(fieldValue instanceof OIdentifiable) && (!(fieldValue instanceof ORecordLazyMultiValue) || !((ORecordLazyMultiValue) fieldValue).rawIterator().hasNext() || !(((ORecordLazyMultiValue) fieldValue).rawIterator().next() instanceof OIdentifiable)) && (!(OMultiValue.getFirstValue(fieldValue) instanceof OIdentifiable || OMultiValue.getFirstValue(OMultiValue.getFirstValue(fieldValue)) instanceof OIdentifiable || OMultiValue.getFirstValue( OMultiValue.getFirstValue(OMultiValue.getFirstValue(fieldValue))) instanceof OIdentifiable))) { iContext.onBeforeStandardField(fieldValue, fieldName, iUserObject); iListener.processStandardField( record, fieldValue, fieldName, iContext, iUserObject, iFormat); iContext.onAfterStandardField(fieldValue, fieldName, iUserObject); } else { try { if (fetch) { final int nextLevel = isEmbedded ? iLevelFromRoot : iLevelFromRoot + 1; fetch( record, iUserObject, iFetchPlan, fieldValue, fieldName, iCurrentLevel, nextLevel, iFieldDepthLevel, parsedRecords, depthLevel, fieldPath, iListener, iContext); } } catch (Exception e) { e.printStackTrace(); OLogManager.instance() .error(null, "Fetching error on record %s", e, record.getIdentity()); } } } iContext.onAfterFetch(record); }