public static SubordPropPlan GetJoinProps(
ExprNode filterExpr,
int outsideStreamCount,
EventType[] allStreamTypesZeroIndexed,
ExcludePlanHint excludePlanHint)
{
// No filter expression means full table scan
if (filterExpr == null) {
return new SubordPropPlan();
}
// analyze query graph
var queryGraph = new QueryGraphForge(outsideStreamCount + 1, excludePlanHint, true);
FilterExprAnalyzer.Analyze(filterExpr, queryGraph, false);
// Build a list of streams and indexes
var joinProps = new LinkedHashMap<string, SubordPropHashKeyForge>();
var rangeProps = new LinkedHashMap<string, SubordPropRangeKeyForge>();
IDictionary<QueryGraphValueEntryCustomKeyForge, QueryGraphValueEntryCustomOperationForge> customIndexOps =
EmptyDictionary<QueryGraphValueEntryCustomKeyForge, QueryGraphValueEntryCustomOperationForge>.Instance;
for (var stream = 0; stream < outsideStreamCount; stream++) {
var lookupStream = stream + 1;
var queryGraphValue = queryGraph.GetGraphValue(lookupStream, 0);
var hashKeysAndIndexes = queryGraphValue.HashKeyProps;
// determine application functions
foreach (var item in queryGraphValue.Items) {
if (item.Entry is QueryGraphValueEntryCustomForge) {
if (customIndexOps.IsEmpty()) {
customIndexOps =
new Dictionary<QueryGraphValueEntryCustomKeyForge,
QueryGraphValueEntryCustomOperationForge>();
}
var custom = (QueryGraphValueEntryCustomForge) item.Entry;
custom.MergeInto(customIndexOps);
}
}
// handle key-lookups
var keyPropertiesJoin = hashKeysAndIndexes.Keys;
var indexPropertiesJoin = hashKeysAndIndexes.Indexed;
if (!keyPropertiesJoin.IsEmpty()) {
if (keyPropertiesJoin.Count != indexPropertiesJoin.Length) {
throw new IllegalStateException(
"Invalid query key and index property collection for stream " + stream);
}
for (var i = 0; i < keyPropertiesJoin.Count; i++) {
QueryGraphValueEntryHashKeyedForge keyDesc = keyPropertiesJoin[i];
var compareNode = keyDesc.KeyExpr;
var keyPropType = compareNode.Forge.EvaluationType.GetBoxedType();
var indexedPropType = allStreamTypesZeroIndexed[0]
.GetPropertyType(indexPropertiesJoin[i])
.GetBoxedType();
var coercionType = indexedPropType;
if (keyPropType != indexedPropType) {
coercionType = keyPropType.GetCompareToCoercionType(indexedPropType);
}
SubordPropHashKeyForge desc;
if (keyPropertiesJoin[i] is QueryGraphValueEntryHashKeyedForgeExpr) {
var keyExpr = (QueryGraphValueEntryHashKeyedForgeExpr) keyPropertiesJoin[i];
var keyStreamNum = keyExpr.IsRequiresKey ? (int?) stream : null;
desc = new SubordPropHashKeyForge(keyDesc, keyStreamNum, coercionType);
}
else {
var prop = (QueryGraphValueEntryHashKeyedForgeProp) keyDesc;
desc = new SubordPropHashKeyForge(prop, stream, coercionType);
}
joinProps.Put(indexPropertiesJoin[i], desc);
}
}
// handle range lookups
var rangeKeysAndIndexes = queryGraphValue.RangeProps;
var rangeIndexes = rangeKeysAndIndexes.Indexed;
var rangeDescs = rangeKeysAndIndexes.Keys;
if (rangeDescs.IsEmpty()) {
continue;
}
// get all ranges lookups
var count = -1;
foreach (var rangeDesc in rangeDescs) {
count++;
var rangeIndexProp = rangeIndexes[count];
var subqRangeDesc = rangeProps.Get(rangeIndexProp);
// other streams may specify the start or end endpoint of a range, therefore this operation can be additive
if (subqRangeDesc != null) {
if (subqRangeDesc.RangeInfo.Type.IsRange()) {
continue;
}
// see if we can make this additive by using a range
var relOpOther = (QueryGraphValueEntryRangeRelOpForge) subqRangeDesc.RangeInfo;
var relOpThis = (QueryGraphValueEntryRangeRelOpForge) rangeDesc;
var opsDesc = QueryGraphRangeUtil.GetCanConsolidate(relOpThis.Type, relOpOther.Type);
if (opsDesc != null) {
ExprNode start;
ExprNode end;
if (!opsDesc.IsReverse) {
start = relOpOther.Expression;
end = relOpThis.Expression;
}
else {
start = relOpThis.Expression;
end = relOpOther.Expression;
}
var allowRangeReversal = relOpOther.IsBetweenPart && relOpThis.IsBetweenPart;
var rangeIn = new QueryGraphValueEntryRangeInForge(
opsDesc.Type,
start,
end,
allowRangeReversal);
var indexedPropType = allStreamTypesZeroIndexed[0]
.GetPropertyType(rangeIndexProp)
.GetBoxedType();
var coercionType = indexedPropType;
var proposedType = CoercionUtil.GetCoercionTypeRangeIn(
indexedPropType,
rangeIn.ExprStart,
rangeIn.ExprEnd);
if (proposedType != null && proposedType != indexedPropType) {
coercionType = proposedType;
}
subqRangeDesc = new SubordPropRangeKeyForge(rangeIn, coercionType);
rangeProps.Put(rangeIndexProp, subqRangeDesc);
}
// ignore
continue;
}
// an existing entry has not been found
if (rangeDesc.Type.IsRange()) {
var rangeIn = (QueryGraphValueEntryRangeInForge) rangeDesc;
var indexedPropType =
allStreamTypesZeroIndexed[0].GetPropertyType(rangeIndexProp).GetBoxedType();
var coercionType = indexedPropType;
var proposedType = CoercionUtil.GetCoercionTypeRangeIn(
indexedPropType,
rangeIn.ExprStart,
rangeIn.ExprEnd);
if (proposedType != null && proposedType != indexedPropType) {
coercionType = proposedType;
}
subqRangeDesc = new SubordPropRangeKeyForge(rangeDesc, coercionType);
}
else {
var relOp = (QueryGraphValueEntryRangeRelOpForge) rangeDesc;
var keyPropType = relOp.Expression.Forge.EvaluationType;
var indexedPropType =
allStreamTypesZeroIndexed[0].GetPropertyType(rangeIndexProp).GetBoxedType();
var coercionType = indexedPropType;
if (keyPropType != indexedPropType) {
coercionType = keyPropType.GetCompareToCoercionType(indexedPropType);
}
subqRangeDesc = new SubordPropRangeKeyForge(rangeDesc, coercionType);
}
rangeProps.Put(rangeIndexProp, subqRangeDesc);
}
}
SubordPropInKeywordSingleIndex inKeywordSingleIdxProp = null;
SubordPropInKeywordMultiIndex inKeywordMultiIdxProp = null;
if (joinProps.IsEmpty() && rangeProps.IsEmpty()) {
for (var stream = 0; stream < outsideStreamCount; stream++) {
var lookupStream = stream + 1;
var queryGraphValue = queryGraph.GetGraphValue(lookupStream, 0);
var inkwSingles = queryGraphValue.InKeywordSingles;
if (inkwSingles.Indexed.Length != 0) {
ExprNode[] keys = inkwSingles.Key[0].KeyExprs;
var key = inkwSingles.Indexed[0];
if (inKeywordSingleIdxProp != null) {
continue;
}
var coercionType = keys[0].Forge.EvaluationType; // for in-comparison the same type is required
inKeywordSingleIdxProp = new SubordPropInKeywordSingleIndex(key, coercionType, keys);
}
var inkwMultis = queryGraphValue.InKeywordMulti;
if (!inkwMultis.IsEmpty()) {
QueryGraphValuePairInKWMultiIdx multi = inkwMultis[0];
inKeywordMultiIdxProp = new SubordPropInKeywordMultiIndex(
ExprNodeUtilityQuery.GetIdentResolvedPropertyNames(multi.Indexed),
multi.Indexed[0].Forge.EvaluationType,
multi.Key.KeyExpr);
}
if (inKeywordSingleIdxProp != null && inKeywordMultiIdxProp != null) {
inKeywordMultiIdxProp = null;
}
}
}
return new SubordPropPlan(
joinProps,
rangeProps,
inKeywordSingleIdxProp,
inKeywordMultiIdxProp,
customIndexOps);
}
/// <summary>
/// Constructs indexing and lookup strategy for a given relationship that a historical stream may have with another
/// stream (historical or not) that looks up into results of a poll of a historical stream.
/// <para />
/// The term "polled" refers to the assumed-historical stream.
/// </summary>
/// <param name="queryGraph">relationship representation of where-clause filter and outer join on-expressions</param>
/// <param name="polledViewType">the event type of the historical that is indexed</param>
/// <param name="streamViewType">the event type of the stream looking up in indexes</param>
/// <param name="polledViewStreamNum">the stream number of the historical that is indexed</param>
/// <param name="streamViewStreamNum">the stream number of the historical that is looking up</param>
/// <param name="raw"></param>
/// <param name="serdeResolver"></param>
/// <returns>indexing and lookup strategy pair</returns>
public static JoinSetComposerPrototypeHistoricalDesc DetermineIndexing(
QueryGraphForge queryGraph,
EventType polledViewType,
EventType streamViewType,
int polledViewStreamNum,
int streamViewStreamNum,
StatementRawInfo raw,
SerdeCompileTimeResolver serdeResolver)
{
var queryGraphValue = queryGraph.GetGraphValue(streamViewStreamNum, polledViewStreamNum);
var hashKeysAndIndes = queryGraphValue.HashKeyProps;
var rangeKeysAndIndex = queryGraphValue.RangeProps;
// index and key property names
var hashKeys = hashKeysAndIndes.Keys;
var hashIndexes = hashKeysAndIndes.Indexed;
var rangeKeys = rangeKeysAndIndex.Keys;
var rangeIndexes = rangeKeysAndIndex.Indexed;
// If the analysis revealed no join columns, must use the brute-force full table scan
if (hashKeys.IsEmpty() && rangeKeys.IsEmpty()) {
var inKeywordSingles = queryGraphValue.InKeywordSingles;
if (inKeywordSingles != null && inKeywordSingles.Indexed.Length != 0) {
var indexed = inKeywordSingles.Indexed[0];
var lookup = inKeywordSingles.Key[0];
var strategy =
new HistoricalIndexLookupStrategyInKeywordSingleForge(streamViewStreamNum, lookup.KeyExprs);
var indexing = new PollResultIndexingStrategyHashForge(
polledViewStreamNum,
polledViewType,
new string[]{ indexed },
null,
null);
return new JoinSetComposerPrototypeHistoricalDesc(strategy, indexing, EmptyList<StmtClassForgeableFactory>.Instance);
}
var multis = queryGraphValue.InKeywordMulti;
if (!multis.IsEmpty()) {
var multi = multis[0];
var strategy =
new HistoricalIndexLookupStrategyInKeywordMultiForge(streamViewStreamNum, multi.Key.KeyExpr);
var indexing =
new PollResultIndexingStrategyInKeywordMultiForge(
polledViewStreamNum,
polledViewType,
ExprNodeUtilityQuery.GetIdentResolvedPropertyNames(multi.Indexed));
return new JoinSetComposerPrototypeHistoricalDesc(strategy, indexing, EmptyList<StmtClassForgeableFactory>.Instance);
}
return new JoinSetComposerPrototypeHistoricalDesc(
HistoricalIndexLookupStrategyNoIndexForge.INSTANCE,
PollResultIndexingStrategyNoIndexForge.INSTANCE,
EmptyList<StmtClassForgeableFactory>.Instance);
}
CoercionDesc keyCoercionTypes = CoercionUtil.GetCoercionTypesHash(
new[] {streamViewType, polledViewType},
0,
1,
hashKeys,
hashIndexes);
if (rangeKeys.IsEmpty()) {
var hashEvals = QueryGraphValueEntryHashKeyedForge.GetForges(hashKeys.ToArray());
var multiKeyPlan = MultiKeyPlanner.PlanMultiKey(hashEvals, false, raw, serdeResolver);
var lookup = new HistoricalIndexLookupStrategyHashForge(
streamViewStreamNum, hashEvals, keyCoercionTypes.CoercionTypes, multiKeyPlan.ClassRef);
var indexing = new PollResultIndexingStrategyHashForge(
polledViewStreamNum,
polledViewType,
hashIndexes,
keyCoercionTypes.CoercionTypes,
multiKeyPlan.ClassRef);
return new JoinSetComposerPrototypeHistoricalDesc(lookup, indexing, multiKeyPlan.MultiKeyForgeables);
}
CoercionDesc rangeCoercionTypes = CoercionUtil.GetCoercionTypesRange(
new[] {streamViewType, polledViewType},
1,
rangeIndexes,
rangeKeys);
if (rangeKeys.Count == 1 && hashKeys.Count == 0) {
var rangeCoercionType = rangeCoercionTypes.CoercionTypes[0];
var indexing = new PollResultIndexingStrategySortedForge(
polledViewStreamNum,
polledViewType,
rangeIndexes[0],
rangeCoercionType);
var lookup = new HistoricalIndexLookupStrategySortedForge(
streamViewStreamNum,
rangeKeys[0],
rangeCoercionType);
return new JoinSetComposerPrototypeHistoricalDesc(lookup, indexing, EmptyList<StmtClassForgeableFactory>.Instance);
}
else {
var hashEvals = QueryGraphValueEntryHashKeyedForge.GetForges(hashKeys.ToArray());
var multiKeyPlan = MultiKeyPlanner.PlanMultiKey(hashEvals, false, raw, serdeResolver);
var strategy = new HistoricalIndexLookupStrategyCompositeForge(
streamViewStreamNum,
hashEvals,
multiKeyPlan.ClassRef,
rangeKeys.ToArray());
var indexing = new PollResultIndexingStrategyCompositeForge(
polledViewStreamNum,
polledViewType,
hashIndexes,
keyCoercionTypes.CoercionTypes,
multiKeyPlan.ClassRef,
rangeIndexes,
rangeCoercionTypes.CoercionTypes);
return new JoinSetComposerPrototypeHistoricalDesc(strategy, indexing, multiKeyPlan.MultiKeyForgeables);
}
}