コード例 #1
0
 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;
 }
コード例 #2
0
  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);
        }
      }
    }
  }
コード例 #3
0
 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;
 }
コード例 #4
0
  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());
 }
コード例 #6
0
  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);
  }