private static void fetchArray(
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 {
if (fieldValue instanceof ODocument[]) {
final ODocument[] linked = (ODocument[]) fieldValue;
iContext.onBeforeArray(iRootRecord, fieldName, iUserObject, linked);
for (ODocument d : linked) {
// 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, fieldName, iUserObject);
final Object userObject =
iListener.fetchLinked(iRootRecord, iUserObject, fieldName, d, iContext);
processRecord(
d,
userObject,
iFetchPlan,
iCurrentLevel,
iLevelFromRoot,
iFieldDepthLevel,
parsedRecords,
iFieldPathFromRoot,
iListener,
iContext,
"");
iContext.onAfterDocument(iRootRecord, d, fieldName, iUserObject);
} else {
iListener.parseLinkedCollectionValue(iRootRecord, d, iUserObject, fieldName, iContext);
}
}
iContext.onAfterArray(iRootRecord, fieldName, iUserObject);
} else {
iListener.processStandardField(iRootRecord, fieldValue, fieldName, iContext, iUserObject, "");
}
}
private static void fetchDocument(
final ORecordSchemaAware<?> iRootRecord,
final Object iUserObject,
final Map<String, Integer> iFetchPlan,
final OIdentifiable 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 Integer fieldDepthLevel = parsedRecords.get(fieldValue.getIdentity());
if (!fieldValue.getIdentity().isValid()
|| (fieldDepthLevel != null && fieldDepthLevel.intValue() == iLevelFromRoot)) {
removeParsedFromMap(parsedRecords, fieldValue);
final ODocument linked = (ODocument) fieldValue;
iContext.onBeforeDocument(iRootRecord, linked, fieldName, iUserObject);
Object userObject =
iListener.fetchLinked(iRootRecord, iUserObject, fieldName, linked, iContext);
processRecord(
linked,
userObject,
iFetchPlan,
iCurrentLevel,
iLevelFromRoot,
iFieldDepthLevel,
parsedRecords,
iFieldPathFromRoot,
iListener,
iContext,
"");
iContext.onAfterDocument(iRootRecord, linked, fieldName, iUserObject);
} else {
iListener.parseLinked(iRootRecord, fieldValue, iUserObject, fieldName, iContext);
}
}
@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);
}
public static void processRecordRidMap(
final ORecordSchemaAware<?> record,
Map<String, Integer> iFetchPlan,
final int iCurrentLevel,
final int iLevelFromRoot,
final int iFieldDepthLevel,
final Map<ORID, Integer> parsedRecords,
final String iFieldPathFromRoot,
final OFetchContext iContext)
throws IOException {
if (iFetchPlan == null) return;
Object fieldValue;
for (String fieldName : record.fieldNames()) {
int depthLevel;
final String fieldPath =
!iFieldPathFromRoot.isEmpty() ? iFieldPathFromRoot + "." + fieldName : fieldName;
depthLevel = getDepthLevel(iFetchPlan, fieldPath);
if (depthLevel == -2) continue;
if (iFieldDepthLevel > -1) depthLevel = iFieldDepthLevel;
fieldValue = record.field(fieldName);
if (fieldValue == null
|| !(fieldValue instanceof OIdentifiable)
&& (!(fieldValue instanceof ORecordLazyMultiValue)
|| !((ORecordLazyMultiValue) fieldValue).rawIterator().hasNext()
|| !(((ORecordLazyMultiValue) fieldValue).rawIterator().next()
instanceof OIdentifiable))
&& (!(fieldValue instanceof Collection<?>)
|| ((Collection<?>) fieldValue).size() == 0
|| !(((Collection<?>) fieldValue).iterator().next() instanceof OIdentifiable))
&& (!(fieldValue instanceof OMultiCollectionIterator<?>))
&& (!(fieldValue instanceof Map<?, ?>)
|| ((Map<?, ?>) fieldValue).size() == 0
|| !(((Map<?, ?>) fieldValue).values().iterator().next()
instanceof OIdentifiable))) {
continue;
} else {
try {
final boolean isEmbedded =
fieldValue instanceof ODocument
&& (((ODocument) fieldValue).isEmbedded()
|| !((ODocument) fieldValue).getIdentity().isValid());
if (!(isEmbedded && iContext.fetchEmbeddedDocuments())
&& !iFetchPlan.containsKey(fieldPath)
&& depthLevel > -1
&& iCurrentLevel >= depthLevel)
// MAX DEPTH REACHED: STOP TO FETCH THIS FIELD
continue;
final int nextLevel = isEmbedded ? iLevelFromRoot : iLevelFromRoot + 1;
fetchRidMap(
record,
iFetchPlan,
fieldValue,
fieldName,
iCurrentLevel,
nextLevel,
iFieldDepthLevel,
parsedRecords,
fieldPath,
iContext);
} catch (Exception e) {
e.printStackTrace();
OLogManager.instance()
.error(null, "Fetching error on record %s", e, record.getIdentity());
}
}
}
}
