private V outerValue(final byte[] value) { return value == null ? null : serdes.valueFrom(value); }
private V fetchPrevious(final Bytes key, final long timestamp) { final byte[] value = underlying.fetch(key, timestamp); if (value != null) { return serdes.valueFrom(value); } return null; }
@Override public V fetch(final K key, final long timestamp) { final byte[] bytesValue = bytesStore.get(WindowKeySchema.toStoreKeyBinary(key, timestamp, seqnum, serdes)); if (bytesValue == null) { return null; } return serdes.valueFrom(bytesValue); }
@Override public KeyValue<Long, V> next() { final KeyValue<Long, byte[]> next = iter.next(); return KeyValue.pair(next.key, serdes.valueFrom(next.value)); }
/** * {@inheritDoc} */ @Override public NFAStates<K, V> find(final Runned key) { byte[] bytes = bytesStore.get(Bytes.wrap(serdes.rawKey(key))); return serdes.valueFrom(bytes); } }
@Override public KeyValue<Windowed<K>, V> next() { final KeyValue<Windowed<Bytes>, byte[]> next = iter.next(); return KeyValue.pair(windowedKey(next.key), serdes.valueFrom(next.value)); }
/** * {@inheritDoc} */ @SuppressWarnings("unchecked") @Override public <T> T find(Aggregated<K> aggregated) { byte[] bytes = bytesStore.get(Bytes.wrap(serdes.rawKey(aggregated))); return (T) serdes.valueFrom(bytes); }
@Override public void restore(final byte[] key, final byte[] value) { restoring = true; // check value for null, to avoid deserialization error. if (value == null) { delete(serdes.keyFrom(key)); } else { put(serdes.keyFrom(key), serdes.valueFrom(value)); } restoring = false; } });
@Override public KeyValue<Long, V> next() { final KeyValue<Bytes, byte[]> next = bytesIterator.next(); final long timestamp = WindowKeySchema.extractStoreTimestamp(next.key.get()); final V value = serdes.valueFrom(next.value); return KeyValue.pair(timestamp, value); }
private AGG fetchPrevious(final Bytes rawKey, final Window window) { try (final KeyValueIterator<Windowed<Bytes>, byte[]> iterator = bytesStore.findSessions(rawKey, window.start(), window.end())) { if (!iterator.hasNext()) { return null; } return serdes.valueFrom(iterator.next().value); } }
@Override public V fetch(final K key, final long timestamp) { final long startNs = time.nanoseconds(); try { final byte[] result = inner.fetch(keyBytes(key), timestamp); if (result == null) { return null; } return serdes.valueFrom(result); } finally { metrics.recordLatency(this.fetchTime, startNs, time.nanoseconds()); } }
@Override public KeyValue<Windowed<K>, V> next() { final KeyValue<Bytes, byte[]> next = bytesIterator.next(); return KeyValue.pair(SessionKeySchema.from(next.key.get(), serdes.keyDeserializer(), serdes.topic()), serdes.valueFrom(next.value)); }
@Override public KeyValue<Windowed<K>, V> next() { final KeyValue<Bytes, byte[]> next = bytesIterator.next(); final long timestamp = WindowKeySchema.extractStoreTimestamp(next.key.get()); final K key = WindowKeySchema.extractStoreKey(next.key.get(), serdes); final V value = serdes.valueFrom(next.value); return KeyValue.pair( new Windowed<>(key, WindowKeySchema.timeWindowForSize(timestamp, windowSize)), value ); }
private void maybeForward(final ThreadCache.DirtyEntry entry, final Bytes key, final Windowed<K> windowedKey, final InternalProcessorContext context) { if (flushListener != null) { final ProcessorRecordContext current = context.recordContext(); context.setRecordContext(entry.entry().context()); try { final V oldValue = sendOldValues ? fetchPrevious(key, windowedKey.window().start()) : null; flushListener.apply(windowedKey, serdes.valueFrom(entry.newValue()), oldValue); } finally { context.setRecordContext(current); } } }
private void putAndMaybeForward(final ThreadCache.DirtyEntry entry, final InternalProcessorContext context) { final ProcessorRecordContext current = context.recordContext(); try { context.setRecordContext(entry.entry().context()); if (flushListener != null) { V oldValue = null; if (sendOldValues) { final byte[] oldBytesValue = underlying.get(entry.key()); oldValue = oldBytesValue == null ? null : serdes.valueFrom(oldBytesValue); } // we rely on underlying store to handle null new value bytes as deletes underlying.put(entry.key(), entry.newValue()); flushListener.apply(serdes.keyFrom(entry.key().get()), serdes.valueFrom(entry.newValue()), oldValue); } else { underlying.put(entry.key(), entry.newValue()); } } finally { context.setRecordContext(current); } }
@Override @SuppressWarnings("unchecked") public void init(final ProcessorContext context, final StateStore root) { // construct the serde this.serdes = new StateSerdes<>( ProcessorStateManager.storeChangelogTopic(context.applicationId(), name), keySerde == null ? (Serde<K>) context.keySerde() : keySerde, valueSerde == null ? (Serde<V>) context.valueSerde() : valueSerde); if (root != null) { // register the store context.register(root, (key, value) -> { // this is a delete if (value == null) { delete(serdes.keyFrom(key)); } else { put(serdes.keyFrom(key), serdes.valueFrom(value)); } }); } this.open = true; }
/** * {@inheritDoc} */ @Override public void branch(final Stage<K, V> stage, final Event<K, V> event, final DeweyVersion version) { Matched key = Matched.from(stage, event); MatchedEvent.Pointer pointer = new MatchedEvent.Pointer(version, key); while(pointer != null && (key = pointer.getKey()) != null) { byte[] bytes = this.bytesStore.get(Bytes.wrap(serdes.rawKey(key))); final MatchedEvent<K, V> val = serdes.valueFrom(bytes); val.incrementRefAndGet(); this.bytesStore.put(Bytes.wrap(serdes.rawKey(key)), serdes.rawValue(val)); pointer = val.getPointerByVersion(pointer.getVersion()); } }
private Sequence<K, V> peek(final Matched matched, DeweyVersion version, boolean remove) { MatchedEvent.Pointer pointer = new MatchedEvent.Pointer(version, matched); Sequence.Builder<K, V> builder = new Sequence.Builder<>(); while (pointer != null && pointer.getKey() != null) { final Matched key = pointer.getKey(); byte[] bytes = this.bytesStore.get(Bytes.wrap(serdes.rawKey(key))); final MatchedEvent<K, V> stateValue = serdes.valueFrom(bytes); long refsLeft = stateValue.decrementRefAndGet(); if (remove && refsLeft == 0 && stateValue.getPredecessors().size() <= 1) { this.bytesStore.delete(Bytes.wrap(serdes.rawKey(key))); } builder.add(key.getStageName(), newEvent(key, stateValue)); pointer = stateValue.getPointerByVersion(pointer.getVersion()); if (remove && pointer != null && refsLeft == 0) { stateValue.removePredecessor(pointer); this.bytesStore.put(Bytes.wrap(serdes.rawKey(key)), serdes.rawValue(stateValue)); } } return builder.build(true); }
private void putAndMaybeForward(final ThreadCache.DirtyEntry entry, final InternalProcessorContext context) { final Bytes binaryKey = cacheFunction.key(entry.key()); final ProcessorRecordContext current = context.recordContext(); context.setRecordContext(entry.entry().context()); try { final Windowed<K> key = SessionKeySchema.from(binaryKey.get(), serdes.keyDeserializer(), topic); final Bytes rawKey = Bytes.wrap(serdes.rawKey(key.key())); if (flushListener != null) { final AGG newValue = serdes.valueFrom(entry.newValue()); final AGG oldValue = newValue == null || sendOldValues ? fetchPrevious(rawKey, key.window()) : null; if (!(newValue == null && oldValue == null)) { flushListener.apply(key, newValue, oldValue); } } bytesStore.put(new Windowed<>(rawKey, key.window()), entry.newValue()); } finally { context.setRecordContext(current); } }