public EventTable index(List<EventBean> pollResult, boolean isActiveCache) { if (!isActiveCache) { return new UnindexedEventTableList(pollResult); } PropertyIndexedEventTableSingleCoerceAllFactory factory = new PropertyIndexedEventTableSingleCoerceAllFactory( streamNum, eventType, propertyName, coercionType); EventTable table = factory.makeEventTable(); table.add(pollResult.toArray(new EventBean[pollResult.size()])); return table; }
public void removeOldData(EventBean[] oldData, NamedWindowIndexRepository indexRepository) { for (int i = 0; i < oldData.length; i++) { RevisionEventBeanDeclared event = (RevisionEventBeanDeclared) oldData[i]; // If the remove event is the latest event, remove from all caches if (event.isLatest()) { MultiKeyUntyped key = event.getKey(); statePerKey.remove(key); for (EventTable table : indexRepository.getTables()) { table.remove(oldData); } } } }
public EventTable index(List<EventBean> pollResult, boolean isActiveCache) { if (!isActiveCache) { return new UnindexedEventTableList(pollResult); } PropertySortedEventTableFactory tableFactory; if (coercionType == null) { tableFactory = new PropertySortedEventTableFactory(streamNum, eventType, propertyName); } else { tableFactory = new PropertySortedEventTableCoercedFactory( streamNum, eventType, propertyName, coercionType); } EventTable table = tableFactory.makeEventTable(); table.add(pollResult.toArray(new EventBean[pollResult.size()])); return table; }
private Pair<IndexMultiKey, EventTableAndNamePair> addIndex( boolean unique, List<IndexedPropDesc> hashProps, List<IndexedPropDesc> btreeProps, Iterable<EventBean> prefilledEvents, EventType indexedType, String indexName, boolean mustCoerce) { // not resolved as full match and not resolved as unique index match, allocate IndexMultiKey indexPropKey = new IndexMultiKey(unique, hashProps, btreeProps); IndexedPropDesc[] indexedPropDescs = hashProps.toArray(new IndexedPropDesc[hashProps.size()]); String[] indexProps = IndexedPropDesc.getIndexProperties(indexedPropDescs); Class[] indexCoercionTypes = IndexedPropDesc.getCoercionTypes(indexedPropDescs); if (!mustCoerce) { indexCoercionTypes = null; } IndexedPropDesc[] rangePropDescs = btreeProps.toArray(new IndexedPropDesc[btreeProps.size()]); String[] rangeProps = IndexedPropDesc.getIndexProperties(rangePropDescs); Class[] rangeCoercionTypes = IndexedPropDesc.getCoercionTypes(rangePropDescs); QueryPlanIndexItem indexItem = new QueryPlanIndexItem( indexProps, indexCoercionTypes, rangeProps, rangeCoercionTypes, false); EventTable table = EventTableUtil.buildIndex(0, indexItem, indexedType, true, unique, indexName); // fill table since its new EventBean[] events = new EventBean[1]; for (EventBean prefilledEvent : prefilledEvents) { events[0] = prefilledEvent; table.add(events); } // add table tables.add(table); // add index, reference counted tableIndexesRefCount.put(indexPropKey, new EventTableIndexRepositoryEntry(indexName, table)); return new Pair<IndexMultiKey, EventTableAndNamePair>( indexPropKey, new EventTableAndNamePair(table, indexName)); }
public void newData( int streamId, FlushedEventBuffer newEventBuffer, FlushedEventBuffer oldEventBuffer) { eventIndex.addRemove(newEventBuffer.getAndFlush(), oldEventBuffer.getAndFlush()); }
public void onUpdate( EventBean[] newData, EventBean[] oldData, NamedWindowRootView namedWindowRootView, NamedWindowIndexRepository indexRepository) { // If new data is filled, it is not a delete if ((newData == null) || (newData.length == 0)) { // we are removing an event RevisionEventBeanDeclared revisionEvent = (RevisionEventBeanDeclared) oldData[0]; MultiKeyUntyped key = revisionEvent.getKey(); statePerKey.remove(key); // Insert into indexes for fast deletion, if there are any for (EventTable table : indexRepository.getTables()) { table.remove(oldData); } // make as not the latest event since its due for removal revisionEvent.setLatest(false); namedWindowRootView.updateChildren(null, oldData); return; } RevisionEventBeanDeclared revisionEvent = (RevisionEventBeanDeclared) newData[0]; EventBean underlyingEvent = revisionEvent.getUnderlyingFullOrDelta(); EventType underyingEventType = underlyingEvent.getEventType(); // obtain key values MultiKeyUntyped key = null; RevisionTypeDesc typesDesc = null; boolean isBaseEventType = false; if (underyingEventType == baseEventType) { key = PropertyUtility.getKeys(underlyingEvent, fullKeyGetters); isBaseEventType = true; } else { typesDesc = typeDescriptors.get(underyingEventType); // if this type cannot be found, check all supertypes, if any if (typesDesc == null) { Iterator<EventType> superTypes = underyingEventType.getDeepSuperTypes(); if (superTypes != null) { EventType superType; for (; superTypes.hasNext(); ) { superType = superTypes.next(); if (superType == baseEventType) { key = PropertyUtility.getKeys(underlyingEvent, fullKeyGetters); isBaseEventType = true; break; } typesDesc = typeDescriptors.get(superType); if (typesDesc != null) { typeDescriptors.put(underyingEventType, typesDesc); key = PropertyUtility.getKeys(underlyingEvent, typesDesc.getKeyPropertyGetters()); break; } } } } else { key = PropertyUtility.getKeys(underlyingEvent, typesDesc.getKeyPropertyGetters()); } if (key == null) { log.warn( "Ignoring event of event type '" + underyingEventType + "' for revision processing type '" + revisionEventTypeName); return; } } // get the state for this key value RevisionStateDeclared revisionState = statePerKey.get(key); // Delta event and no full if ((!isBaseEventType) && (revisionState == null)) { return; // Ignore the event, its a delta and we don't currently have a full event for it } // New full event if (revisionState == null) { revisionState = new RevisionStateDeclared(underlyingEvent, null, null); statePerKey.put(key, revisionState); // prepare revison event revisionEvent.setLastBaseEvent(underlyingEvent); revisionEvent.setKey(key); revisionEvent.setHolders(null); revisionEvent.setLatest(true); // Insert into indexes for fast deletion, if there are any for (EventTable table : indexRepository.getTables()) { table.add(newData); } // post to data window revisionState.setLastEvent(revisionEvent); namedWindowRootView.updateChildren(new EventBean[] {revisionEvent}, null); return; } // new version long versionNumber = revisionState.incRevisionNumber(); // Previously-seen full event if (isBaseEventType) { revisionState.setHolders(null); revisionState.setBaseEventUnderlying(underlyingEvent); } // Delta event to existing full event else { int groupNum = typesDesc.getGroup().getGroupNum(); RevisionBeanHolder[] holders = revisionState.getHolders(); if (holders == null) // optimization - the full event sets it to null, deltas all get a new one { holders = new RevisionBeanHolder[groups.length]; } else { holders = arrayCopy(holders); // preserve the last revisions } // add the new revision for a property group on top holders[groupNum] = new RevisionBeanHolder( versionNumber, underlyingEvent, typesDesc.getChangesetPropertyGetters()); revisionState.setHolders(holders); } // prepare revision event revisionEvent.setLastBaseEvent(revisionState.getBaseEventUnderlying()); revisionEvent.setHolders(revisionState.getHolders()); revisionEvent.setKey(key); revisionEvent.setLatest(true); // get prior event RevisionEventBeanDeclared lastEvent = revisionState.getLastEvent(); lastEvent.setLatest(false); // data to post EventBean[] newDataPost = new EventBean[] {revisionEvent}; EventBean[] oldDataPost = new EventBean[] {lastEvent}; // update indexes for (EventTable table : indexRepository.getTables()) { table.remove(oldDataPost); table.add(newDataPost); } // keep reference to last event revisionState.setLastEvent(revisionEvent); namedWindowRootView.updateChildren(newDataPost, oldDataPost); }