Java tutorial
/************************************************************************************** * Copyright (C) 2008 EsperTech, Inc. All rights reserved. * * http://esper.codehaus.org * * http://www.espertech.com * * ---------------------------------------------------------------------------------- * * The software in this package is published under the terms of the GPL license * * a copy of which has been included with this distribution in the license.txt file. * **************************************************************************************/ package com.espertech.esper.epl.join.table; import com.espertech.esper.client.EventBean; import com.espertech.esper.client.EventPropertyGetter; import com.espertech.esper.collection.SuperIterator; import com.espertech.esper.epl.join.exec.base.RangeIndexLookupValue; import com.espertech.esper.epl.join.exec.base.RangeIndexLookupValueEquals; import com.espertech.esper.epl.join.exec.base.RangeIndexLookupValueRange; import com.espertech.esper.epl.join.plan.QueryGraphRangeEnum; import com.espertech.esper.filter.Range; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.util.*; /** * Index that organizes events by the event property values into a single TreeMap sortable non-nested index * with Object keys that store the property values. */ public class PropertySortedEventTable implements EventTable { protected final int streamNum; protected final EventPropertyGetter propertyGetter; /** * Index table. */ protected final TreeMap<Object, Set<EventBean>> propertyIndex; protected final HashSet<EventBean> nullKeyedValues; // override in a subclass protected Object coerce(Object value) { return value; } /** * Ctor. * @param streamNum - the stream number that is indexed */ public PropertySortedEventTable(int streamNum, EventPropertyGetter propertyGetter) { this.streamNum = streamNum; this.propertyGetter = propertyGetter; propertyIndex = new TreeMap<Object, Set<EventBean>>(); nullKeyedValues = new LinkedHashSet<EventBean>(); } /** * Determine multikey for index access. * @param theEvent to get properties from for key * @return multi key */ protected Object getIndexedValue(EventBean theEvent) { return propertyGetter.get(theEvent); } public void addRemove(EventBean[] newData, EventBean[] oldData) { add(newData); remove(oldData); } /** * Add an array of events. Same event instance is not added twice. Event properties should be immutable. * Allow null passed instead of an empty array. * @param events to add * @throws IllegalArgumentException if the event was already existed in the index */ public void add(EventBean[] events) { if (events == null) { return; } for (EventBean theEvent : events) { add(theEvent); } } /** * Remove events. * @param events to be removed, can be null instead of an empty array. * @throws IllegalArgumentException when the event could not be removed as its not in the index */ public void remove(EventBean[] events) { if (events == null) { return; } for (EventBean theEvent : events) { remove(theEvent); } } /** * Returns the set of events that have the same property value as the given event. * @param keyStart to compare against * @param keyEnd to compare against * @param allowRangeReversal indicate whether "a between 60 and 50" should return no results (equivalent to a>= X and a <=Y) or should return results (equivalent to 'between' and 'in' * @return set of events with property value, or null if none found (never returns zero-sized set) */ public Set<EventBean> lookupRange(Object keyStart, boolean includeStart, Object keyEnd, boolean includeEnd, boolean allowRangeReversal) { if (keyStart == null || keyEnd == null) { return Collections.emptySet(); } keyStart = coerce(keyStart); keyEnd = coerce(keyEnd); SortedMap<Object, Set<EventBean>> submap; try { submap = propertyIndex.subMap(keyStart, includeStart, keyEnd, includeEnd); } catch (IllegalArgumentException ex) { if (allowRangeReversal) { submap = propertyIndex.subMap(keyEnd, includeStart, keyStart, includeEnd); } else { return Collections.emptySet(); } } return normalize(submap); } public Collection<EventBean> lookupRangeColl(Object keyStart, boolean includeStart, Object keyEnd, boolean includeEnd, boolean allowRangeReversal) { if (keyStart == null || keyEnd == null) { return Collections.emptyList(); } keyStart = coerce(keyStart); keyEnd = coerce(keyEnd); SortedMap<Object, Set<EventBean>> submap; try { submap = propertyIndex.subMap(keyStart, includeStart, keyEnd, includeEnd); } catch (IllegalArgumentException ex) { if (allowRangeReversal) { submap = propertyIndex.subMap(keyEnd, includeStart, keyStart, includeEnd); } else { return Collections.emptyList(); } } return normalizeCollection(submap); } public Set<EventBean> lookupRangeInverted(Object keyStart, boolean includeStart, Object keyEnd, boolean includeEnd) { if (keyStart == null || keyEnd == null) { return Collections.emptySet(); } keyStart = coerce(keyStart); keyEnd = coerce(keyEnd); SortedMap<Object, Set<EventBean>> submapOne = propertyIndex.headMap(keyStart, !includeStart); SortedMap<Object, Set<EventBean>> submapTwo = propertyIndex.tailMap(keyEnd, !includeEnd); return normalize(submapOne, submapTwo); } public Collection<EventBean> lookupRangeInvertedColl(Object keyStart, boolean includeStart, Object keyEnd, boolean includeEnd) { if (keyStart == null || keyEnd == null) { return Collections.emptySet(); } keyStart = coerce(keyStart); keyEnd = coerce(keyEnd); SortedMap<Object, Set<EventBean>> submapOne = propertyIndex.headMap(keyStart, !includeStart); SortedMap<Object, Set<EventBean>> submapTwo = propertyIndex.tailMap(keyEnd, !includeEnd); return normalizeCollection(submapOne, submapTwo); } public Set<EventBean> lookupLess(Object keyStart) { if (keyStart == null) { return Collections.emptySet(); } keyStart = coerce(keyStart); return normalize(propertyIndex.headMap(keyStart)); } public Collection<EventBean> lookupLessThenColl(Object keyStart) { if (keyStart == null) { return Collections.emptyList(); } keyStart = coerce(keyStart); return normalizeCollection(propertyIndex.headMap(keyStart)); } public Set<EventBean> lookupLessEqual(Object keyStart) { if (keyStart == null) { return Collections.emptySet(); } keyStart = coerce(keyStart); return normalize(propertyIndex.headMap(keyStart, true)); } public Collection<EventBean> lookupLessEqualColl(Object keyStart) { if (keyStart == null) { return Collections.emptyList(); } keyStart = coerce(keyStart); return normalizeCollection(propertyIndex.headMap(keyStart, true)); } public Set<EventBean> lookupGreaterEqual(Object keyStart) { if (keyStart == null) { return Collections.emptySet(); } keyStart = coerce(keyStart); return normalize(propertyIndex.tailMap(keyStart)); } public Collection<EventBean> lookupGreaterEqualColl(Object keyStart) { if (keyStart == null) { return Collections.emptyList(); } keyStart = coerce(keyStart); return normalizeCollection(propertyIndex.tailMap(keyStart)); } public Set<EventBean> lookupGreater(Object keyStart) { if (keyStart == null) { return Collections.emptySet(); } keyStart = coerce(keyStart); return normalize(propertyIndex.tailMap(keyStart, false)); } public Collection<EventBean> lookupGreaterColl(Object keyStart) { if (keyStart == null) { return Collections.emptyList(); } keyStart = coerce(keyStart); return normalizeCollection(propertyIndex.tailMap(keyStart, false)); } private Set<EventBean> normalize(SortedMap<Object, Set<EventBean>> submap) { if (submap.size() == 0) { return null; } if (submap.size() == 1) { return submap.get(submap.firstKey()); } Set<EventBean> result = new LinkedHashSet<EventBean>(); for (Map.Entry<Object, Set<EventBean>> entry : submap.entrySet()) { result.addAll(entry.getValue()); } return result; } private Collection<EventBean> normalizeCollection(SortedMap<Object, Set<EventBean>> submap) { if (submap.size() == 0) { return null; } if (submap.size() == 1) { return submap.get(submap.firstKey()); } Deque<EventBean> result = new ArrayDeque<EventBean>(); for (Map.Entry<Object, Set<EventBean>> entry : submap.entrySet()) { result.addAll(entry.getValue()); } return result; } private Collection<EventBean> normalizeCollection(SortedMap<Object, Set<EventBean>> submapOne, SortedMap<Object, Set<EventBean>> submapTwo) { if (submapOne.size() == 0) { return normalizeCollection(submapTwo); } if (submapTwo.size() == 0) { return normalizeCollection(submapOne); } ArrayDeque<EventBean> result = new ArrayDeque<EventBean>(); for (Map.Entry<Object, Set<EventBean>> entry : submapOne.entrySet()) { result.addAll(entry.getValue()); } for (Map.Entry<Object, Set<EventBean>> entry : submapTwo.entrySet()) { result.addAll(entry.getValue()); } return result; } private Set<EventBean> normalize(SortedMap<Object, Set<EventBean>> submapOne, SortedMap<Object, Set<EventBean>> submapTwo) { if (submapOne.size() == 0) { return normalize(submapTwo); } if (submapTwo.size() == 0) { return normalize(submapOne); } Set<EventBean> result = new LinkedHashSet<EventBean>(); for (Map.Entry<Object, Set<EventBean>> entry : submapOne.entrySet()) { result.addAll(entry.getValue()); } for (Map.Entry<Object, Set<EventBean>> entry : submapTwo.entrySet()) { result.addAll(entry.getValue()); } return result; } private void add(EventBean theEvent) { Object key = getIndexedValue(theEvent); key = coerce(key); if (key == null) { nullKeyedValues.add(theEvent); return; } Set<EventBean> events = propertyIndex.get(key); if (events == null) { events = new LinkedHashSet<EventBean>(); propertyIndex.put(key, events); } events.add(theEvent); } private void remove(EventBean theEvent) { Object key = getIndexedValue(theEvent); if (key == null) { nullKeyedValues.remove(theEvent); return; } key = coerce(key); Set<EventBean> events = propertyIndex.get(key); if (events == null) { return; } if (!events.remove(theEvent)) { // Not an error, its possible that an old-data event is artificial (such as for statistics) and // thus did not correspond to a new-data event raised earlier. return; } if (events.isEmpty()) { propertyIndex.remove(key); } } public boolean isEmpty() { return propertyIndex.isEmpty(); } public Iterator<EventBean> iterator() { if (nullKeyedValues.isEmpty()) { return new PropertySortedEventTableIterator(propertyIndex); } return new SuperIterator<EventBean>(new PropertySortedEventTableIterator(propertyIndex), nullKeyedValues.iterator()); } public void clear() { propertyIndex.clear(); } public String toQueryPlan() { return this.getClass().getSimpleName() + " streamNum=" + streamNum + " propertyGetter=" + propertyGetter; } private static Log log = LogFactory.getLog(PropertySortedEventTable.class); public Set<EventBean> lookupConstants(RangeIndexLookupValue lookupValueBase) { if (lookupValueBase instanceof RangeIndexLookupValueEquals) { RangeIndexLookupValueEquals equals = (RangeIndexLookupValueEquals) lookupValueBase; return propertyIndex.get(equals.getValue()); } RangeIndexLookupValueRange lookupValue = (RangeIndexLookupValueRange) lookupValueBase; if (lookupValue.getOperator() == QueryGraphRangeEnum.RANGE_CLOSED) { Range range = (Range) lookupValue.getValue(); return lookupRange(range.getLowEndpoint(), true, range.getHighEndpoint(), true, lookupValue.isAllowRangeReverse()); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.RANGE_HALF_OPEN) { Range range = (Range) lookupValue.getValue(); return lookupRange(range.getLowEndpoint(), true, range.getHighEndpoint(), false, lookupValue.isAllowRangeReverse()); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.RANGE_HALF_CLOSED) { Range range = (Range) lookupValue.getValue(); return lookupRange(range.getLowEndpoint(), false, range.getHighEndpoint(), true, lookupValue.isAllowRangeReverse()); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.RANGE_OPEN) { Range range = (Range) lookupValue.getValue(); return lookupRange(range.getLowEndpoint(), false, range.getHighEndpoint(), false, lookupValue.isAllowRangeReverse()); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.NOT_RANGE_CLOSED) { Range range = (Range) lookupValue.getValue(); return lookupRangeInverted(range.getLowEndpoint(), true, range.getHighEndpoint(), true); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.NOT_RANGE_HALF_OPEN) { Range range = (Range) lookupValue.getValue(); return lookupRangeInverted(range.getLowEndpoint(), true, range.getHighEndpoint(), false); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.NOT_RANGE_HALF_CLOSED) { Range range = (Range) lookupValue.getValue(); return lookupRangeInverted(range.getLowEndpoint(), false, range.getHighEndpoint(), true); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.NOT_RANGE_OPEN) { Range range = (Range) lookupValue.getValue(); return lookupRangeInverted(range.getLowEndpoint(), false, range.getHighEndpoint(), false); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.GREATER) { return lookupGreater(lookupValue.getValue()); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.GREATER_OR_EQUAL) { return lookupGreaterEqual(lookupValue.getValue()); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.LESS) { return lookupLess(lookupValue.getValue()); } else if (lookupValue.getOperator() == QueryGraphRangeEnum.LESS_OR_EQUAL) { return lookupLessEqual(lookupValue.getValue()); } else { throw new IllegalArgumentException("Unrecognized operator '" + lookupValue.getOperator() + "'"); } } }