protected void onIndexEngineChange(final int indexId) { while (true) try { storage.callIndexEngine(false, false, indexId, engine -> { engine.init(getName(), getType(), getDefinition(), isAutomatic(), getMetadata()); return null; }); break; } catch (OInvalidIndexEngineIdException ignore) { doReloadIndexEngine(); } }
public OIndexAbstract<T> removeCluster(String iClusterName) { acquireExclusiveLock(); try { if (clustersToIndex.remove(iClusterName)) { updateConfiguration(); rebuild(); } return this; } finally { releaseExclusiveLock(); } }
@Override public boolean remove(Object key) { return super.remove(key); }
public void commit(IndexTxSnapshot snapshots) { acquireSharedLock(); try { if (snapshots.clear) clear(); commitSnapshot(snapshots.indexSnapshot); } finally { releaseSharedLock(); } }
@Override public String getAlgorithm() { acquireSharedLock(); try { return algorithm; } finally { releaseSharedLock(); } }
public boolean loadFromConfiguration(final ODocument config) { acquireExclusiveLock(); try { configuration = indexConfigurationInstance(config); clustersToIndex.clear(); final OIndexMetadata indexMetadata = loadMetadata(config); indexDefinition = indexMetadata.getIndexDefinition(); clustersToIndex.addAll(indexMetadata.getClustersToIndex()); .loadExternalIndexEngine(name, algorithm, type, indexDefinition, determineValueSerializer(), isAutomatic(), true, version, 1, this instanceof OIndexMultiValues, getEngineProperties()); apiVersion = OAbstractPaginatedStorage.extractEngineAPIVersion(indexId); onIndexEngineChange(indexId); if (isAutomatic()) { OLogManager.instance().warn(this, "Cannot load index '%s' rebuilt it from scratch", getName()); try { rebuild(); } catch (Exception t) { OLogManager.instance() .error(this, "Cannot rebuild index '%s' because '" + t + "'. The index will be removed in configuration", e, getName()); releaseExclusiveLock();
final boolean intentInstalled = getDatabase().declareIntent(new OIntentMassiveInsert()); acquireExclusiveLock(); try { removeValuesContainer(); .addIndexEngine(name, algorithm, type, indexDefinition, determineValueSerializer(), isAutomatic(), true, version, 1, this instanceof OIndexMultiValues, getEngineProperties(), clustersToIndex, metadata); apiVersion = OAbstractPaginatedStorage.extractEngineAPIVersion(indexId); onIndexEngineChange(indexId); } catch (Exception e) { try { throw OException.wrapException(new OIndexException("Error on rebuilding the index for clusters: " + clustersToIndex), e); } finally { releaseExclusiveLock(); acquireSharedLock(); try { documentIndexed = fillIndex(iProgressListener, true); } catch (final Exception e) { OLogManager.instance().error(this, "Error during index rebuild", e); getDatabase().declareIntent(null); releaseSharedLock();
final Set<String> clustersToIndex, boolean rebuild, final OProgressListener progressListener, final OBinarySerializer valueSerializer) { acquireExclusiveLock(); try { configuration = indexConfigurationInstance(new ODocument().setTrackingChanges(false)); removeValuesContainer(); indexId = storage.addIndexEngine(name, algorithm, type, indexDefinition, valueSerializer, isAutomatic(), true, version, 1, this instanceof OIndexMultiValues, getEngineProperties(), clustersToIndex, metadata); apiVersion = OAbstractPaginatedStorage.extractEngineAPIVersion(indexId); onIndexEngineChange(indexId); fillIndex(progressListener, false); updateConfiguration(); } catch (Exception e) { OLogManager.instance().error(this, "Exception during index '%s' creation", e, name); break; } catch (OInvalidIndexEngineIdException ignore) { doReloadIndexEngine(); } catch (Exception ex) { OLogManager.instance().error(this, "Exception during index '%s' deletion", ex, name); releaseExclusiveLock();
@Override public Object getFirstKey() { acquireSharedLock(); try { while (true) try { return storage.getIndexFirstKey(indexId); } catch (OInvalidIndexEngineIdException ignore) { doReloadIndexEngine(); } } finally { releaseSharedLock(); } }
public OIndexInternal<T> delete() { acquireExclusiveLock(); try { while (true) try { storage.deleteIndexEngine(indexId); break; } catch (OInvalidIndexEngineIdException ignore) { doReloadIndexEngine(); } // REMOVE THE INDEX ALSO FROM CLASS MAP if (getDatabase().getMetadata() != null) //noinspection deprecation getDatabase().getMetadata().getIndexManager().removeClassPropertyIndex(this); removeValuesContainer(); return this; } finally { releaseExclusiveLock(); } }
public boolean remove(Object key) { key = getCollatingValue(key); acquireSharedLock(); try { while (true) try { return storage.removeKeyFromIndex(indexId, key); } catch (OInvalidIndexEngineIdException ignore) { doReloadIndexEngine(); } } finally { releaseSharedLock(); } }
public void addTxOperation(IndexTxSnapshot snapshots, final OTransactionIndexChanges changes) { acquireSharedLock(); try { if (changes.cleared) clearSnapshot(snapshots); final Map<Object, Object> snapshot = snapshots.indexSnapshot; for (final OTransactionIndexChangesPerKey entry : changes.changesPerKey.values()) { applyIndexTxEntry(snapshot, entry); } applyIndexTxEntry(snapshot, changes.nullKeyChanges); } finally { releaseSharedLock(); } }
public OIndexAbstract<T> addCluster(final String clusterName) { acquireExclusiveLock(); try { if (clustersToIndex.add(clusterName)) { updateConfiguration(); // INDEX SINGLE CLUSTER indexCluster(clusterName, null, 0, 0, 0); } return this; } finally { releaseExclusiveLock(); } }
@Override public OLuceneIndexNotUnique create(String name, OIndexDefinition indexDefinition, String clusterIndexName, Set<String> clustersToIndex, boolean rebuild, OProgressListener progressListener) { return (OLuceneIndexNotUnique) super .create(indexDefinition, clusterIndexName, clustersToIndex, rebuild, progressListener, determineValueSerializer()); }
private void removeValuesContainer() { if (valueContainerAlgorithm.equals(ODefaultIndexFactory.SBTREE_BONSAI_VALUE_CONTAINER)) { final OAtomicOperation atomicOperation = OAtomicOperationsManager.getCurrentOperation(); final OReadCache readCache = storage.getReadCache(); final OWriteCache writeCache = storage.getWriteCache(); if (atomicOperation == null) { try { final String fileName = getName() + OIndexRIDContainer.INDEX_FILE_EXTENSION; if (writeCache.exists(fileName)) { final long fileId = writeCache.loadFile(fileName); readCache.deleteFile(fileId, writeCache); } } catch (IOException e) { OLogManager.instance().error(this, "Cannot delete file for value containers", e); } } else { try { final String fileName = getName() + OIndexRIDContainer.INDEX_FILE_EXTENSION; if (atomicOperation.isFileExists(fileName)) { final long fileId = atomicOperation.loadFile(fileName); atomicOperation.deleteFile(fileId); } } catch (IOException e) { OLogManager.instance().error(this, "Cannot delete file for value containers", e); } } } }
@Override public long rebuild(OProgressListener iProgressListener) { return super.rebuild(iProgressListener); }
public OIndexAbstract(String name, final String type, final String algorithm, final String valueContainerAlgorithm, final ODocument metadata, final int version, final OStorage storage, int binaryFormatVersion) { this.binaryFormatVersion = binaryFormatVersion; acquireExclusiveLock(); try { databaseName = storage.getName(); this.version = version; this.name = name; this.type = type; this.algorithm = algorithm; this.metadata = metadata; this.valueContainerAlgorithm = valueContainerAlgorithm; this.storage = (OAbstractPaginatedStorage) storage.getUnderlying(); } finally { releaseExclusiveLock(); } }
protected void clearSnapshot(IndexTxSnapshot indexTxSnapshot) { // storage will delay real operations till the end of tx clear(); }
@Override public boolean hasRangeQuerySupport() { acquireSharedLock(); try { while (true) try { return storage.hasIndexRangeQuerySupport(indexId); } catch (OInvalidIndexEngineIdException ignore) { doReloadIndexEngine(); } } finally { releaseSharedLock(); } }
@Override public String toString() { acquireSharedLock(); try { return name; } finally { releaseSharedLock(); } }