public void put(final String iKey, final Object iValue) { index.put(iKey, (OIdentifiable) iValue); }
protected static void putInIndex(OIndex<?> index, Object key, OIdentifiable value) { index.put(key, value); }
protected void putBasic(final String key, final T element) { underlying.put(key, element.getRecord()); }
public OIndex<T> put(final Object iKey, final OIdentifiable iValue) { checkForKeyType(iKey); return delegate.put(iKey, iValue); }
private static void processIndexUpdateFieldAssignment(OIndex<?> index, ODocument iRecord, final Object origValue, final Object newValue) { if ((origValue instanceof Collection) && (newValue instanceof Collection)) { final Set<Object> valuesToRemove = new HashSet<Object>((Collection<?>) origValue); final Set<Object> valuesToAdd = new HashSet<Object>((Collection<?>) newValue); valuesToRemove.removeAll((Collection<?>) newValue); valuesToAdd.removeAll((Collection<?>) origValue); for (final Object valueToRemove : valuesToRemove) { if (valueToRemove != null) { index.remove(valueToRemove, iRecord); } } for (final Object valueToAdd : valuesToAdd) { if (valueToAdd != null) { index.put(valueToAdd, iRecord); } } } else { deleteIndexKey(index, iRecord, origValue); if (newValue instanceof Collection) { for (final Object newValueItem : (Collection<?>) newValue) { index.put(newValueItem, iRecord.placeholder()); } } else if (newValue != null) { index.put(newValue, iRecord.placeholder()); } } }
public void addIndexEntry(final OIndex<?> delegate, final String indexName, final OPERATION status, final Object key, final OIdentifiable value) { switch (status) { case CLEAR: delegate.clear(); break; case PUT: delegate.put(key, value); break; case REMOVE: delegate.remove(key, value); break; } }
private int doExecute(OIndex index, OCommandContext ctx, OExpression keyExp, OExpression valueExp) { int count = 0; Object key = keyExp.execute((OResult) null, ctx); Object value = valueExp.execute((OResult) null, ctx); if (value instanceof OIdentifiable) { index.put(key, (OIdentifiable) value); count++; } else if (value instanceof OResult && ((OResult) value).isElement()) { index.put(key, ((OResult) value).getElement().get()); count++; } else if (value instanceof OResultSet) { ((OResultSet) value).elementStream().forEach(x -> index.put(key, x)); } else if (OMultiValue.isMultiValue(value)) { Iterator iterator = OMultiValue.getMultiValueIterator(value); while (iterator.hasNext()) { Object item = iterator.next(); if (value instanceof OIdentifiable) { index.put(key, (OIdentifiable) value); count++; } else if (value instanceof OResult && ((OResult) value).isElement()) { index.put(key, ((OResult) value).getElement().get()); count++; } else { throw new OCommandExecutionException("Cannot insert into index " + value); } } } return count; }
public void put(final String key, final Object value, final T element) { final String keyTemp = key + SEPARATOR + value; final ODocument doc = element.getRecord(); if (!doc.getIdentity().isValid()) doc.save(); graph.setCurrentGraphInThreadLocal(); graph.autoStartTransaction(); underlying.put(keyTemp, doc); recordKeyValueIndex.put(new OCompositeKey(doc.getIdentity(), keyTemp), doc.getIdentity()); }
public void put(final String key, final Object value, final T element) { final String keyTemp = key + SEPARATOR + value; final ODocument doc = element.getRecord(); if (!doc.getIdentity().isValid()) doc.save(); graph.autoStartTransaction(); underlying.put(keyTemp, doc); }
private static void processSingleIndexUpdate(final OIndex<?> index, final Set<String> dirtyFields, final ODocument iRecord) { final OIndexDefinition indexDefinition = index.getDefinition(); final List<String> indexFields = indexDefinition.getFields(); if (indexFields.isEmpty()) return; final String indexField = indexFields.get(0); if (!dirtyFields.contains(indexField)) return; final OMultiValueChangeTimeLine<?, ?> multiValueChangeTimeLine = iRecord.getCollectionTimeLine(indexField); if (multiValueChangeTimeLine != null) { final OIndexDefinitionMultiValue indexDefinitionMultiValue = (OIndexDefinitionMultiValue) indexDefinition; final Map<Object, Integer> keysToAdd = new HashMap<Object, Integer>(); final Map<Object, Integer> keysToRemove = new HashMap<Object, Integer>(); for (OMultiValueChangeEvent<?, ?> changeEvent : multiValueChangeTimeLine.getMultiValueChangeEvents()) { indexDefinitionMultiValue.processChangeEvent(changeEvent, keysToAdd, keysToRemove); } for (final Object keyToRemove : keysToRemove.keySet()) index.remove(keyToRemove, iRecord); for (final Object keyToAdd : keysToAdd.keySet()) index.put(keyToAdd, iRecord.placeholder()); } else { final Object origValue = indexDefinition.createValue(iRecord.getOriginalValue(indexField)); final Object newValue = indexDefinition.getDocumentValueToIndex(iRecord); processIndexUpdateFieldAssignment(index, iRecord, origValue, newValue); } }
private void addIndexesEntries(ODocument document) { document = checkForLoading(document); // STORE THE RECORD IF NEW, OTHERWISE ITS RID final OIdentifiable rid = document.getIdentity().isPersistent() ? document.placeholder() : document; final OClass cls = document.getSchemaClass(); if (cls != null) { final Collection<OIndex<?>> indexes = cls.getIndexes(); for (final OIndex<?> index : indexes) { final Object key = index.getDefinition().getDocumentValueToIndex(document); // SAVE A COPY TO AVOID PROBLEM ON RECYCLING OF THE RECORD if (key instanceof Collection) { for (final Object keyItem : (Collection<?>) key) if (keyItem != null) index.put(keyItem, rid); } else if (key != null) index.put(key, rid); } } }
Object indexKey = getIndexKeyValue(commandParameters, candidate); OIdentifiable indexValue = getIndexValue(commandParameters, candidate); index.put(indexKey, indexValue); result.put(KEYWORD_KEY, indexKey); result.put(KEYWORD_RID, indexValue);
exportImportHashTable.put(rid, record.getIdentity());
newRid = oldRid; index.put(doc.field("key"), newRid != null ? newRid.getIdentity() : oldRid.getIdentity()); } else { ORuntimeKeyIndexDefinition<?> runtimeKeyIndexDefinition = (ORuntimeKeyIndexDefinition<?>) index.getDefinition(); newRid = doc.<OIdentifiable>field("rid"); index.put(binarySerializer.deserialize(doc.<byte[]>field("key"), 0), newRid != null ? newRid : oldRid);
private OIndex<?> buildKeyValueIndex(final ODocument metadata) { final OIndexFactory factory = OIndexes.getFactory(OClass.INDEX_TYPE.DICTIONARY.toString(), null); final OIndex<?> recordKeyValueIndex = new OIndexTxAwareOneValue(graph.getRawGraph(), (OIndex<OIdentifiable>) graph .getRawGraph() .getMetadata() .getIndexManager() .createIndex("__@recordmap@___" + underlying.getName(), OClass.INDEX_TYPE.DICTIONARY.toString(), new OSimpleKeyIndexDefinition(factory.getLastVersion(), OType.LINK, OType.STRING), null, null, null)); final List<ODocument> entries = graph.getRawGraph().query( new OSQLSynchQuery<Object>("select from index:" + underlying.getName())); for (ODocument entry : entries) { final OIdentifiable rid = entry.field("rid"); if (rid != null) recordKeyValueIndex.put(new OCompositeKey(rid, entry.field("key")), rid); } metadata.field(CONFIG_RECORD_MAP_NAME, recordKeyValueIndex.getName()); return recordKeyValueIndex; }