congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
ILSMIndexAccessor.getOpContext
Code IndexAdd Tabnine to your IDE (free)

How to use
getOpContext
method
in
org.apache.hyracks.storage.am.lsm.common.api.ILSMIndexAccessor

Best Java code snippets using org.apache.hyracks.storage.am.lsm.common.api.ILSMIndexAccessor.getOpContext (Showing top 20 results out of 315)

origin: apache/asterixdb

@Override
public Map<String, Object> getParameters() {
  return accessor.getOpContext().getParameters();
}
origin: apache/asterixdb

public List<ILSMComponent> getMergingComponents() {
  return accessor.getOpContext().getComponentHolder();
}
origin: apache/asterixdb

public ILSMComponent getFlushingComponent() {
  return accessor.getOpContext().getComponentHolder().get(0);
}
origin: apache/asterixdb

@Override
public synchronized void scheduled(ILSMIOOperation operation) throws HyracksDataException {
  dsInfo.declareActiveIOOperation();
  if (operation.getIOOpertionType() == LSMIOOperationType.FLUSH) {
    pendingFlushes++;
    FlushOperation flush = (FlushOperation) operation;
    Map<String, Object> map = operation.getAccessor().getOpContext().getParameters();
    Long flushLsn = (Long) map.get(KEY_FLUSH_LOG_LSN);
    map.put(KEY_FIRST_LSN, firstLsnForCurrentMemoryComponent);
    map.put(KEY_FLUSHED_COMPONENT_ID, flush.getFlushingComponent().getId());
    componentIds.add((ILSMComponentId) map.get(KEY_NEXT_COMPONENT_ID));
    firstLsnForCurrentMemoryComponent = flushLsn; // Advance the first lsn for new component
  }
}
origin: apache/asterixdb

@Override
public final ILSMDiskComponent merge(ILSMIOOperation operation) throws HyracksDataException {
  ILSMIndexAccessor accessor = operation.getAccessor();
  ILSMIndexOperationContext opCtx = accessor.getOpContext();
  return opCtx.getOperation() == IndexOperation.DELETE_COMPONENTS ? EmptyComponent.INSTANCE : doMerge(operation);
}
origin: apache/asterixdb

@Override
public void merge(ILSMIOOperation operation) throws HyracksDataException {
  if (LOGGER.isDebugEnabled()) {
    LOGGER.debug("Started a merge operation for index: {}", lsmIndex);
  }
  synchronized (opTracker) {
    enterComponents(operation.getAccessor().getOpContext(), LSMOperationType.MERGE);
  }
  try {
    doIo(operation);
  } finally {
    exitComponents(operation.getAccessor().getOpContext(), LSMOperationType.MERGE, operation.getNewComponent(),
        operation.getStatus() == LSMIOOperationStatus.FAILURE);
    opTracker.completeOperation(lsmIndex, LSMOperationType.MERGE,
        operation.getAccessor().getOpContext().getSearchOperationCallback(),
        operation.getAccessor().getOpContext().getModificationCallback());
  }
  if (LOGGER.isDebugEnabled()) {
    LOGGER.debug("Finished the merge operation for index: {}. Result: {}", lsmIndex, operation.getStatus());
  }
}
origin: apache/asterixdb

@Override
public synchronized void completed(ILSMIOOperation operation) {
  if (operation.getIOOpertionType() == LSMIOOperationType.FLUSH) {
    pendingFlushes--;
    if (operation.getStatus() == LSMIOOperationStatus.SUCCESS) {
      Map<String, Object> map = operation.getAccessor().getOpContext().getParameters();
      persistenceLsn =
          pendingFlushes == 0 ? firstLsnForCurrentMemoryComponent : (Long) map.get(KEY_FLUSH_LOG_LSN);
    }
  }
  dsInfo.undeclareActiveIOOperation();
}
origin: apache/asterixdb

@SuppressWarnings("squid:S2142")
@Override
public void flush(ILSMIOOperation operation) throws HyracksDataException {
  LOGGER.debug("Started a flush operation for index: {}", lsmIndex);
  synchronized (opTracker) {
    while (!enterComponents(operation.getAccessor().getOpContext(), LSMOperationType.FLUSH)) {
      try {
        opTracker.wait();
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw HyracksDataException.create(e);
      }
    }
  }
  try {
    doIo(operation);
  } finally {
    exitComponents(operation.getAccessor().getOpContext(), LSMOperationType.FLUSH, operation.getNewComponent(),
        operation.getStatus() == LSMIOOperationStatus.FAILURE);
    opTracker.completeOperation(lsmIndex, LSMOperationType.FLUSH,
        operation.getAccessor().getOpContext().getSearchOperationCallback(),
        operation.getAccessor().getOpContext().getModificationCallback());
  }
  if (LOGGER.isDebugEnabled()) {
    LOGGER.debug("Finished the flush operation for index: {}. Result: {}", lsmIndex, operation.getStatus());
  }
}
origin: apache/asterixdb

public TestFlushOperation(ILSMIndexAccessor accessor, FileReference target, ILSMIOOperationCallback callback,
    String indexIdentifier, LSMComponentFileReferences files, LSMComponentId componentId)
    throws HyracksDataException {
  super(accessor, target, callback, indexIdentifier);
  this.files = files;
  flushingComponent = accessor.getOpContext().getIndex().getCurrentMemoryComponent();
  Mockito.when(flushingComponent.getId()).thenReturn(componentId);
}
origin: apache/asterixdb

for (ILSMIndex lsmIndex : dsInfo.getDatasetPartitionOpenIndexes(partition)) {
  ILSMIndexAccessor accessor = lsmIndex.createAccessor(NoOpIndexAccessParameters.INSTANCE);
  accessor.getOpContext().setParameters(flushMap);
  ILSMIOOperation flush = accessor.scheduleFlush();
  lastFlushTime = System.nanoTime();
origin: apache/asterixdb

@Override
public final ILSMDiskComponent flush(ILSMIOOperation operation) throws HyracksDataException {
  ILSMIndexAccessor accessor = operation.getAccessor();
  ILSMIndexOperationContext opCtx = accessor.getOpContext();
  ILSMMemoryComponent memoryComponent = (ILSMMemoryComponent) opCtx.getComponentHolder().get(0);
  if (memoryComponent != getOldestReadableMemoryComponent()) {
    throw new IllegalStateException("An attempt to flush a memory component that is not the oldest");
  }
  if (!memoryComponent.isModified() || opCtx.getOperation() == IndexOperation.DELETE_COMPONENTS) {
    return EmptyComponent.INSTANCE;
  }
  if (LOGGER.isInfoEnabled()) {
    FlushOperation flushOp = (FlushOperation) operation;
    LOGGER.log(Level.INFO,
        "Flushing component with id: " + flushOp.getFlushingComponent().getId() + " in the index " + this);
  }
  return doFlush(operation);
}
origin: apache/asterixdb

flushMap.put(LSMIOOperationCallback.KEY_FLUSH_LOG_LSN, flushLsn);
ILSMIndexAccessor accessor = index.createAccessor(NoOpIndexAccessParameters.INSTANCE);
accessor.getOpContext().setParameters(flushMap);
long minId = logRecord.getFlushingComponentMinId();
long maxId = logRecord.getFlushingComponentMaxId();
origin: apache/asterixdb

@Override
public void afterFinalize(ILSMIOOperation operation) throws HyracksDataException {
  if (operation.getStatus() == LSMIOOperationStatus.FAILURE) {
    return;
  }
  if (operation.getIOOpertionType() != LSMIOOperationType.LOAD
      && operation.getAccessor().getOpContext().getOperation() == IndexOperation.DELETE_COMPONENTS) {
    deleteComponentsFromCheckpoint(operation);
  } else if (operation.getIOOpertionType() == LSMIOOperationType.FLUSH
      || operation.getIOOpertionType() == LSMIOOperationType.LOAD) {
    addComponentToCheckpoint(operation);
  }
}
origin: apache/asterixdb

private void deleteComponentsFromCheckpoint(ILSMIOOperation operation) throws HyracksDataException {
  // component was deleted... if a flush, do nothing.. if a merge, must update the checkpoint file
  if (operation.getIOOpertionType() == LSMIOOperationType.MERGE) {
    // Get component id of the last disk component
    LSMComponentId mostRecentComponentId =
        getMostRecentComponentId(operation.getAccessor().getOpContext().getComponentsToBeMerged());
    // Update the checkpoint file
    FileReference target = operation.getTarget();
    final ResourceReference ref = ResourceReference.of(target.getAbsolutePath());
    indexCheckpointManagerProvider.get(ref).setLastComponentId(mostRecentComponentId.getMaxId());
  } else if (operation.getIOOpertionType() != LSMIOOperationType.FLUSH) {
    throw new IllegalStateException("Unexpected IO operation: " + operation.getIOOpertionType());
  }
}
origin: apache/asterixdb

    (ILSMIndex) datasetLifecycleManager.getIndex(logRecord.getDatasetId(), logRecord.getResourceId());
ILSMIndexAccessor indexAccessor = index.createAccessor(NoOpIndexAccessParameters.INSTANCE);
ILSMIndexOperationContext opCtx = indexAccessor.getOpContext();
opCtx.setFilterSkip(true);
try {
origin: apache/asterixdb

@Override
public ILSMIOOperation createFlushOperation(ILSMIndexOperationContext ctx) throws HyracksDataException {
  ILSMMemoryComponent flushingComponent = getCurrentMemoryComponent();
  if (flushingComponent.getWriterCount() > 0) {
    throw new IllegalStateException(
        "createFlushOperation is called on a component with writers: " + flushingComponent);
  }
  // take care of the flush cycling
  ILSMIOOperation flushOp =
      TracedIOOperation.wrap(createFlushOperation(createOpContext(NoOpIndexAccessParameters.INSTANCE),
          fileManager.getRelFlushFileReference(), ioOpCallback), tracer);
  // Changing the flush status should *always* precede changing the mutable component.
  flushingComponent.schedule(LSMIOOperationType.FLUSH);
  numScheduledFlushes++;
  changeFlushStatusForCurrentMutableCompoent(false);
  changeMutableComponent();
  ILSMIndexAccessor accessor = flushOp.getAccessor();
  ILSMIndexOperationContext flushCtx = accessor.getOpContext();
  flushCtx.setOperation(ctx.getOperation()); // Could be component delete
  flushCtx.getComponentHolder().add(flushingComponent);
  flushCtx.setIoOperation(flushOp);
  propagateMap(ctx, flushCtx);
  ioOpCallback.scheduled(flushOp);
  return flushOp;
}
origin: apache/asterixdb

  @Override
  public void run() {
    ILSMIndexAccessor lsmAccessor = lsmBtree.createAccessor(NoOpIndexAccessParameters.INSTANCE);
    try {
      dsLifecycleMgr.getComponentIdGenerator(StorageTestUtils.DATASET_ID, PARTITION, indexPath)
          .refresh();
      ILSMComponentId next = dsLifecycleMgr
          .getComponentIdGenerator(StorageTestUtils.DATASET_ID, PARTITION, indexPath).getId();
      long flushLsn = nc.getTransactionSubsystem().getLogManager().getAppendLSN();
      Map<String, Object> flushMap = new HashMap<>();
      flushMap.put(LSMIOOperationCallback.KEY_FLUSH_LOG_LSN, flushLsn);
      flushMap.put(LSMIOOperationCallback.KEY_NEXT_COMPONENT_ID, next);
      lsmAccessor.getOpContext().setParameters(flushMap);
      lsmAccessor.deleteComponents(predicate);
    } catch (HyracksDataException e) {
      failure = e;
    }
  }
};
origin: apache/asterixdb

@Override
public void afterOperation(ILSMIOOperation operation) throws HyracksDataException {
  if (operation.getStatus() == LSMIOOperationStatus.FAILURE) {
    return;
  }
  if (operation.getIOOpertionType() == LSMIOOperationType.LOAD) {
    Map<String, Object> map = operation.getParameters();
    putComponentIdIntoMetadata(operation.getNewComponent(), (LSMComponentId) map.get(KEY_FLUSHED_COMPONENT_ID));
  } else if (operation.getIOOpertionType() == LSMIOOperationType.FLUSH) {
    Map<String, Object> map = operation.getParameters();
    putLSNIntoMetadata(operation.getNewComponent(), (Long) map.get(KEY_FLUSH_LOG_LSN));
    putComponentIdIntoMetadata(operation.getNewComponent(),
        ((FlushOperation) operation).getFlushingComponent().getId());
  } else if (operation.getIOOpertionType() == LSMIOOperationType.MERGE) {
    List<ILSMDiskComponent> mergedComponents = operation.getAccessor().getOpContext().getComponentsToBeMerged();
    putLSNIntoMetadata(operation.getNewComponent(), mergedComponents);
    putComponentIdIntoMetadata(operation.getNewComponent(), mergedComponents);
    LongPointable markerLsn =
        LongPointable.FACTORY.createPointable(ComponentUtils.getLong(mergedComponents.get(0).getMetadata(),
            ComponentUtils.MARKER_LSN_KEY, ComponentUtils.NOT_FOUND, buffer));
    operation.getNewComponent().getMetadata().put(ComponentUtils.MARKER_LSN_KEY, markerLsn);
  }
}
origin: apache/asterixdb

private static void redo(ILogRecord logRecord, IDatasetLifecycleManager datasetLifecycleManager) {
  try {
    int datasetId = logRecord.getDatasetId();
    long resourceId = logRecord.getResourceId();
    ILSMIndex index = (ILSMIndex) datasetLifecycleManager.getIndex(datasetId, resourceId);
    ILSMIndexAccessor indexAccessor = index.createAccessor(NoOpIndexAccessParameters.INSTANCE);
    ILSMIndexOperationContext opCtx = indexAccessor.getOpContext();
    opCtx.setFilterSkip(true);
    opCtx.setRecovery(true);
    if (logRecord.getNewOp() == AbstractIndexModificationOperationCallback.INSERT_BYTE) {
      indexAccessor.forceInsert(logRecord.getNewValue());
    } else if (logRecord.getNewOp() == AbstractIndexModificationOperationCallback.DELETE_BYTE) {
      indexAccessor.forceDelete(logRecord.getNewValue());
    } else if (logRecord.getNewOp() == AbstractIndexModificationOperationCallback.UPSERT_BYTE) {
      // redo, upsert the new value
      indexAccessor.forceUpsert(logRecord.getNewValue());
    } else if (logRecord.getNewOp() == AbstractIndexModificationOperationCallback.FILTER_BYTE) {
      opCtx.setFilterSkip(false);
      indexAccessor.updateFilter(logRecord.getNewValue());
    } else {
      throw new IllegalStateException("Unsupported OperationType: " + logRecord.getNewOp());
    }
  } catch (Exception e) {
    throw new IllegalStateException("Failed to redo", e);
  }
}
origin: apache/asterixdb

flushMap.put(LSMIOOperationCallback.KEY_NEXT_COMPONENT_ID, expectedId);
ILSMIndexAccessor accessor = new TestLSMIndexAccessor(new TestLSMIndexOperationContext(mockIndex));
accessor.getOpContext().setParameters(flushMap);
FileReference target = new FileReference(Mockito.mock(IODeviceHandle.class), getComponentFileName());
LSMComponentFileReferences files = new LSMComponentFileReferences(target, target, target);
org.apache.hyracks.storage.am.lsm.common.apiILSMIndexAccessorgetOpContext

Popular methods of ILSMIndexAccessor

  • scheduleMerge
    Schedule a merge operation
  • forceDelete
    Force deleting an index entry even if the memory component is full replace the entry if found with a
  • forceInsert
    Insert a new tuple (failing if duplicate key entry is found)
  • scheduleFlush
    Schedule a flush operation
  • delete
  • insert
  • createSearchCursor
  • forceUpsert
    Force upserting the tuple into the memory component even if it is full
  • scanDiskComponents
    Open the given cursor for scanning all disk components of the primary index. The returned tuple has
  • upsert
  • deleteComponents
    Delete components that match the passed predicate NOTE: This call can only be made when the caller k
  • destroy
  • deleteComponents,
  • destroy,
  • flush,
  • forcePhysicalDelete,
  • merge,
  • scheduleFullMerge,
  • scheduleReplication,
  • search,
  • tryDelete

Popular in Java

  • Parsing JSON documents to java classes using gson
  • getSystemService (Context)
  • runOnUiThread (Activity)
  • setContentView (Activity)
  • ObjectMapper (com.fasterxml.jackson.databind)
    ObjectMapper provides functionality for reading and writing JSON, either to and from basic POJOs (Pl
  • BorderLayout (java.awt)
    A border layout lays out a container, arranging and resizing its components to fit in five regions:
  • UnknownHostException (java.net)
    Thrown when a hostname can not be resolved.
  • HttpServlet (javax.servlet.http)
    Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A sub
  • LogFactory (org.apache.commons.logging)
    Factory for creating Log instances, with discovery and configuration features similar to that employ
  • Runner (org.openjdk.jmh.runner)
  • Best plugins for Eclipse
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now