private Operation getOppositeOperation(Operation operation) { return operation.isUpdate() ? Operation.CREATE : Operation.UPDATE; }
/** * Returns the create operation that corresponds to this operation. For an update operation the * corresponding create op is returned. For all other operations <code>this</code> is returned. */ public Operation getCorrespondingCreateOp() { if (isUpdate()) { switch (this.opDetails) { case OP_DETAILS_SEARCH: return Operation.SEARCH_CREATE; case OP_DETAILS_LOCAL_LOAD: return Operation.LOCAL_LOAD_CREATE; case OP_DETAILS_NET_LOAD: return Operation.NET_LOAD_CREATE; case OP_DETAILS_PUTALL: return Operation.PUTALL_CREATE; default: return Operation.CREATE; } } else { return this; } }
@Override public void onEvent(final CqEvent aCqEvent) { Operation op = aCqEvent.getBaseOperation(); if (op.isCreate()) { ++this.numCreates; } else if (op.isUpdate()) { ++this.numUpdates; } else if (op.isDestroy()) { ++this.numDestroys; } else { ++this.numOtherOps; } eventList.add(aCqEvent); }
public void toData(DataOutput out) throws IOException { out.writeByte(this.op.ordinal); DataSerializer.writeObject(this.cbArg, out); if (this.op.isEntry()) { DataSerializer.writeObject(this.key, out); if (this.op.isUpdate() || this.op.isCreate()) { out.writeByte(this.deserializationPolicy); DataSerializer.writeByteArray(this.value, out); } } } }
@Override public ConflationKey getConflationKey() { if (!super.regionAllowsConflation || this.directAck || getProcessorId() != 0) { // if the publisher's region attributes do not support conflation // or if it is an ack region // then don't even bother with a conflation key return null; } else { // only conflate if it is not a create // and we don't want an ack return new ConflationKey(this.key, super.regionPath, getOperation().isUpdate()); } }
<K> EntryColumnData getEntryColumnData(TableMetaDataView tableMetaData, RegionMapping regionMapping, K key, PdxInstance value, Operation operation) { List<ColumnData> keyColumnData = createKeyColumnDataList(tableMetaData, regionMapping, key); List<ColumnData> valueColumnData = null; if (operation.isCreate() || operation.isUpdate()) { valueColumnData = createValueColumnDataList(tableMetaData, regionMapping, value); } return new EntryColumnData(keyColumnData, valueColumnData); }
/** * Removing the existing indexed value requires the current value in the cache, that is the one * prior to applying the operation. * * @param entry the RegionEntry that contains the value prior to applying the op */ @Override public void txRemoveOldIndexEntry(Operation op, RegionEntry entry) { if ((op.isUpdate() && !entry.isInvalid()) || op.isInvalidate() || op.isDestroy()) { IndexManager idxManager = _getOwner().getIndexManager(); if (idxManager != null) { try { idxManager.updateIndexes(entry, IndexManager.REMOVE_ENTRY, op.isUpdate() ? IndexProtocol.BEFORE_UPDATE_OP : IndexProtocol.OTHER_OP); } catch (QueryException e) { throw new IndexMaintenanceException(e); } } } }
public static QueuedOperation createFromData(DataInput in) throws IOException, ClassNotFoundException { Operation op = Operation.fromOrdinal(in.readByte()); Object key = null; byte[] value = null; Object valueObj = null; byte deserializationPolicy = DistributedCacheOperation.DESERIALIZATION_POLICY_NONE; Object cbArg = DataSerializer.readObject(in); if (op.isEntry()) { key = DataSerializer.readObject(in); if (op.isUpdate() || op.isCreate()) { deserializationPolicy = in.readByte(); value = DataSerializer.readByteArray(in); } } return new QueuedOperation(op, key, value, valueObj, deserializationPolicy, cbArg); }
private void setValuesInStatement(PreparedStatement statement, EntryColumnData entryColumnData, Operation operation) throws SQLException { int index = 0; if (operation.isCreate() || operation.isUpdate()) { index = setValuesFromColumnData(statement, entryColumnData.getEntryValueColumnData(), index); } setValuesFromColumnData(statement, entryColumnData.getEntryKeyColumnData(), index); }
private static EnumListenerEvent getEnumListenerEvent(Operation operation) { EnumListenerEvent ele = null; if (operation.isCreate()) { ele = EnumListenerEvent.AFTER_CREATE; } else if (operation.isUpdate()) { ele = EnumListenerEvent.AFTER_UPDATE; } else if (operation.isDestroy()) { ele = EnumListenerEvent.AFTER_DESTROY; } return ele; } }
private boolean isUpdate() { if (isCacheWrite() && getEvent().getOperation().isUpdate()) { // if there is a cacheWriter, type of event has already been set return true; } if (isReplaceOnClient()) { return true; } if (!getRegionEntry().isRemoved()) { return true; } return false; }
/** @return whether we should do a local create for a remote one */ private static boolean shouldDoRemoteCreate(LocalRegion rgn, EntryEventImpl ev) { DataPolicy dp = rgn.getAttributes().getDataPolicy(); if (!rgn.isAllEvents() || (dp.withReplication() && rgn.isInitialized() && ev.getOperation().isUpdate() && !rgn.getConcurrencyChecksEnabled() // misordered CREATE and // UPDATE messages can // cause inconsistencies && !ALWAYS_REPLICATE_UPDATES)) { // we are not accepting all events // or we are a replicate and initialized and it was an update // (we exclude that latter to avoid resurrecting a key deleted in a replicate return false; } else { return true; } }
/** * Update stats for a CQ for VSD * * @param cqEvent object containing info on the newly qualified CQ event */ public void updateStats(CqEvent cqEvent) { if (cqEvent.getQueryOperation() == null) return; this.incNumEvents(); if (cqEvent.getQueryOperation().isCreate()) { this.incNumInserts(); } if (cqEvent.getQueryOperation().isUpdate()) { this.incNumUpdates(); } if (cqEvent.getQueryOperation().isDestroy()) { this.incNumDeletes(); } }
/** * dispatch listener events for this event * * @param notifyGateways pass the event on to WAN queues */ public void invokeCallbacks(InternalRegion rgn, boolean skipListeners, boolean notifyGateways) { if (!callbacksInvoked()) { callbacksInvoked(true); if (this.op.isUpdate()) { rgn.invokePutCallbacks(EnumListenerEvent.AFTER_UPDATE, this, !skipListeners, notifyGateways); // gateways are notified in part2 processing } else if (this.op.isCreate()) { rgn.invokePutCallbacks(EnumListenerEvent.AFTER_CREATE, this, !skipListeners, notifyGateways); } else if (this.op.isDestroy()) { rgn.invokeDestroyCallbacks(EnumListenerEvent.AFTER_DESTROY, this, !skipListeners, notifyGateways); } else if (this.op.isInvalidate()) { rgn.invokeInvalidateCallbacks(EnumListenerEvent.AFTER_INVALIDATE, this, !skipListeners); } } }
private String getSqlString(TableMetaDataView tableMetaData, EntryColumnData entryColumnData, Operation operation) { SqlStatementFactory statementFactory = new SqlStatementFactory(tableMetaData.getIdentifierQuoteString()); String tableName = tableMetaData.getQuotedTablePath(); if (operation.isCreate()) { return statementFactory.createInsertSqlString(tableName, entryColumnData); } else if (operation.isUpdate()) { return statementFactory.createUpdateSqlString(tableName, entryColumnData); } else if (operation.isDestroy()) { return statementFactory.createDestroySqlString(tableName, entryColumnData); } else if (operation.isGet()) { return statementFactory.createSelectQueryString(tableName, entryColumnData); } else { throw new InternalGemFireException("unsupported operation " + operation); } }
/** * Check NET_LOAD_CREATE Operation. */ @Test public void testNET_LOAD_CREATE() { Operation op = Operation.NET_LOAD_CREATE; assertTrue(op.isCreate()); assertFalse(op.isUpdate()); assertFalse(op.isInvalidate()); assertFalse(op.isDestroy()); assertFalse(op.isPutAll()); assertFalse(op.isRegionInvalidate()); assertFalse(op.isRegionDestroy()); assertFalse(op.isRegion()); assertFalse(op.isLocal()); assertTrue(op.isDistributed()); assertTrue(op.isEntry()); assertFalse(op.isExpiration()); assertFalse(op.isLocalLoad()); assertTrue(op.isNetLoad()); assertTrue(op.isLoad()); assertFalse(op.isNetSearch()); assertFalse(op.isClose()); assertFalse(op.isClear()); }
/** * Check REGION_LOCAL_INVALIDATE Operation. */ @Test public void testREGION_LOCAL_INVALIDATE() { Operation op = Operation.REGION_LOCAL_INVALIDATE; assertFalse(op.isCreate()); assertFalse(op.isUpdate()); assertFalse(op.isInvalidate()); assertFalse(op.isDestroy()); assertFalse(op.isPutAll()); assertTrue(op.isRegionInvalidate()); assertFalse(op.isRegionDestroy()); assertTrue(op.isRegion()); assertTrue(op.isLocal()); assertFalse(op.isDistributed()); assertFalse(op.isEntry()); assertFalse(op.isExpiration()); assertFalse(op.isLocalLoad()); assertFalse(op.isNetLoad()); assertFalse(op.isLoad()); assertFalse(op.isNetSearch()); assertFalse(op.isClose()); assertFalse(op.isClear()); }
/** * Check CACHE_CREATE Operation */ @Test public void testCACHE_CREATE() { Operation op = Operation.CACHE_CREATE; assertFalse(op.isCreate()); assertFalse(op.isUpdate()); assertFalse(op.isInvalidate()); assertFalse(op.isDestroy()); assertFalse(op.isPutAll()); assertFalse(op.isRegionInvalidate()); assertFalse(op.isRegionDestroy()); assertTrue(op.isRegion()); assertTrue(op.isLocal()); assertFalse(op.isDistributed()); assertFalse(op.isEntry()); assertFalse(op.isExpiration()); assertFalse(op.isLocalLoad()); assertFalse(op.isNetLoad()); assertFalse(op.isLoad()); assertFalse(op.isNetSearch()); assertFalse(op.isClose()); assertFalse(op.isClear()); }
/** * Check DESTROY Operation. */ @Test public void testDESTROY() { Operation op = Operation.DESTROY; assertFalse(op.isCreate()); assertFalse(op.isUpdate()); assertFalse(op.isInvalidate()); assertTrue(op.isDestroy()); assertFalse(op.isPutAll()); assertFalse(op.isRegionInvalidate()); assertFalse(op.isRegionDestroy()); assertFalse(op.isRegion()); assertFalse(op.isLocal()); assertTrue(op.isDistributed()); assertTrue(op.isEntry()); assertFalse(op.isExpiration()); assertFalse(op.isLocalLoad()); assertFalse(op.isNetLoad()); assertFalse(op.isLoad()); assertFalse(op.isNetSearch()); assertFalse(op.isClose()); assertFalse(op.isClear()); }
/** * Check REGION_EXPIRE_INVALIDATE Operation. */ @Test public void testREGION_EXPIRE_INVALIDATE() { Operation op = Operation.REGION_EXPIRE_INVALIDATE; assertFalse(op.isCreate()); assertFalse(op.isUpdate()); assertFalse(op.isInvalidate()); assertFalse(op.isDestroy()); assertFalse(op.isPutAll()); assertTrue(op.isRegionInvalidate()); assertFalse(op.isRegionDestroy()); assertTrue(op.isRegion()); assertFalse(op.isLocal()); assertTrue(op.isDistributed()); assertFalse(op.isEntry()); assertTrue(op.isExpiration()); assertFalse(op.isLocalLoad()); assertFalse(op.isNetLoad()); assertFalse(op.isLoad()); assertFalse(op.isNetSearch()); assertFalse(op.isClose()); assertFalse(op.isClear()); }