/// <summary>
/// Ctor.
/// </summary>
/// <param name="lookupStream">stream that generates event to look up for</param>
/// <param name="indexedStream">stream to full table scan</param>
/// <param name="indexNum">index number for the table containing the full unindexed contents</param>
/// <param name="typesPerStream">types</param>
/// <param name="indexedStreamIsVDW">vdw indicator</param>
public FullTableScanLookupPlanForge(
int lookupStream,
int indexedStream,
bool indexedStreamIsVDW,
EventType[] typesPerStream,
TableLookupIndexReqKey indexNum)
: base(lookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, new[] {indexNum})
{
}
private static TableLookupIndexReqKey[] GetIndexKeys(params string[] names)
{
var keys = new TableLookupIndexReqKey[names.Length];
for (var i = 0; i < names.Length; i++) {
keys[i] = new TableLookupIndexReqKey(names[i], null);
}
return keys;
}
public static void AssertJoinOneStreamAndReset(bool unique)
{
Assert.IsTrue(Joins.Count == 1);
QueryPlan join = Joins[0];
QueryPlanIndex first = join.IndexSpecs[1];
TableLookupIndexReqKey firstName = first.Items.Keys.First();
QueryPlanIndexItem index = first.Items.Get(firstName);
Assert.AreEqual(unique, index.IsUnique);
Reset();
}
public InKeywordTableLookupPlanSingleIdxForge(
int lookupStream,
int indexedStream,
bool indexedStreamIsVDW,
EventType[] typesPerStream,
TableLookupIndexReqKey indexNum,
ExprNode[] expressions)
: base(lookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, new[] {indexNum})
{
Expressions = expressions;
}
public static void AssertJoinAllStreamsAndReset(bool unique)
{
Assert.IsTrue(Joins.Count == 1);
QueryPlan join = Joins[0];
foreach (QueryPlanIndex index in join.IndexSpecs)
{
TableLookupIndexReqKey firstName = index.Items.Keys.First();
QueryPlanIndexItem indexDesc = index.Items.Get(firstName);
Assert.AreEqual(unique, indexDesc.IsUnique);
}
Reset();
}
public SortedTableLookupPlanForge(
int lookupStream,
int indexedStream,
bool indexedStreamIsVDW,
EventType[] typesPerStream,
TableLookupIndexReqKey indexNum,
QueryGraphValueEntryRangeForge rangeKeyPair,
Type optionalCoercionType)
:
base(lookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, new[] {indexNum})
{
RangeKeyPair = rangeKeyPair;
this.optionalCoercionType = optionalCoercionType;
}
private static TableLookupPlanDesc GetFullTableScanTable(
int lookupStream,
int indexedStream,
bool indexedStreamIsVDW,
EventType[] typesPerStream,
TableMetaData indexedStreamTableMeta)
{
var indexName = new TableLookupIndexReqKey(
indexedStreamTableMeta.TableName,
indexedStreamTableMeta.TableModuleName,
indexedStreamTableMeta.TableName);
var forge = new FullTableScanUniquePerKeyLookupPlanForge(
lookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexName);
return new TableLookupPlanDesc(forge, EmptyList<StmtClassForgeableFactory>.Instance);
}
public CompositeTableLookupPlanForge(
int lookupStream,
int indexedStream,
bool indexedStreamIsVDW,
EventType[] typesPerStream,
TableLookupIndexReqKey indexNum,
IList<QueryGraphValueEntryHashKeyedForge> hashKeys,
Type[] hashCoercionTypes,
IList<QueryGraphValueEntryRangeForge> rangeKeyPairs,
Type[] optRangeCoercionTypes,
QueryPlanIndexForge indexSpecs,
MultiKeyClassRef optionalEPLTableLookupMultiKey)
: base(lookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, new[] {indexNum})
{
_hashKeys = hashKeys;
_hashCoercionTypes = hashCoercionTypes;
_rangeKeyPairs = rangeKeyPairs;
_optRangeCoercionTypes = optRangeCoercionTypes;
_indexSpecs = indexSpecs;
_optionalEPLTableLookupMultiKey = optionalEPLTableLookupMultiKey;
}
public IndexedTableLookupPlanHashedOnlyForge(
int lookupStream,
int indexedStream,
bool indexedStreamIsVDW,
EventType[] typesPerStream,
TableLookupIndexReqKey indexNum,
QueryGraphValueEntryHashKeyedForge[] hashKeys,
QueryPlanIndexForge indexSpecs,
Type[] optionalCoercionTypes,
MultiKeyClassRef optionalEPLTableLookupMultiKey)
: base(
lookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
new[] { indexNum })
{
_hashKeys = hashKeys;
_indexSpecs = indexSpecs;
_optionalCoercionTypes = optionalCoercionTypes;
_optionalEPLTableLookupMultiKey = optionalEPLTableLookupMultiKey;
}
/// <summary>
/// Create the table lookup plan for a from-stream to look up in an indexed stream
/// using the columns supplied in the query graph and looking at the actual indexes available
/// and their index number.
/// </summary>
/// <param name="queryGraph">contains properties joining the 2 streams</param>
/// <param name="currentLookupStream">stream to use key values from</param>
/// <param name="indexedStream">stream to look up in</param>
/// <param name="indexSpecs">index specification defining indexes to be created for stream</param>
/// <param name="typesPerStream">event types for each stream</param>
/// <param name="indexedStreamTableMeta">table info</param>
/// <param name="indexedStreamIsVDW">vdw indicators</param>
/// <param name="raw">raw statement information</param>
/// <param name="serdeResolver">serde resolver</param>
/// <returns>plan for performing a lookup in a given table using one of the indexes supplied</returns>
public static TableLookupPlanDesc CreateLookupPlan(
QueryGraphForge queryGraph,
int currentLookupStream,
int indexedStream,
bool indexedStreamIsVDW,
QueryPlanIndexForge indexSpecs,
EventType[] typesPerStream,
TableMetaData indexedStreamTableMeta,
StatementRawInfo raw,
SerdeCompileTimeResolver serdeResolver)
{
var queryGraphValue = queryGraph.GetGraphValue(currentLookupStream, indexedStream);
var hashKeyProps = queryGraphValue.HashKeyProps;
var hashPropsKeys = hashKeyProps.Keys;
var hashIndexProps = hashKeyProps.Indexed;
var rangeProps = queryGraphValue.RangeProps;
var rangePropsKeys = rangeProps.Keys;
var rangeIndexProps = rangeProps.Indexed;
var pairIndexHashRewrite =
indexSpecs.GetIndexNum(hashIndexProps, rangeIndexProps);
var indexNum = pairIndexHashRewrite == null ? null : pairIndexHashRewrite.First;
// handle index redirection towards unique index
if (pairIndexHashRewrite != null && pairIndexHashRewrite.Second != null) {
var indexes = pairIndexHashRewrite.Second;
var newHashIndexProps = new string[indexes.Length];
IList<QueryGraphValueEntryHashKeyedForge> newHashKeys = new List<QueryGraphValueEntryHashKeyedForge>();
for (var i = 0; i < indexes.Length; i++) {
newHashIndexProps[i] = hashIndexProps[indexes[i]];
newHashKeys.Add(hashPropsKeys[indexes[i]]);
}
hashIndexProps = newHashIndexProps;
hashPropsKeys = newHashKeys;
rangeIndexProps = new string[0];
rangePropsKeys = Collections.GetEmptyList<QueryGraphValueEntryRangeForge>();
}
// no direct hash or range lookups
if (hashIndexProps.Length == 0 && rangeIndexProps.Length == 0) {
// handle single-direction 'in' keyword
var singles = queryGraphValue.InKeywordSingles;
if (!singles.Key.IsEmpty()) {
QueryGraphValueEntryInKeywordSingleIdxForge single = null;
indexNum = null;
if (indexedStreamTableMeta != null) {
var indexes = singles.Indexed;
var count = 0;
foreach (var index in indexes) {
var indexPairFound =
EventTableIndexUtil.FindIndexBestAvailable(
indexedStreamTableMeta.IndexMetadata.Indexes,
Collections.SingletonSet(index),
Collections.GetEmptySet<string>(),
null);
if (indexPairFound != null) {
indexNum = new TableLookupIndexReqKey(
indexPairFound.Second.OptionalIndexName,
indexPairFound.Second.OptionalIndexModuleName,
indexedStreamTableMeta.TableName);
single = singles.Key[count];
}
count++;
}
}
else {
single = singles.Key[0];
var pairIndex = indexSpecs.GetIndexNum(
new[] {singles.Indexed[0]},
new string[0]);
indexNum = pairIndex.First;
}
if (indexNum != null) {
var forge = new InKeywordTableLookupPlanSingleIdxForge(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexNum,
single.KeyExprs);
return new TableLookupPlanDesc(forge, EmptyList<StmtClassForgeableFactory>.Instance);
}
}
// handle multi-direction 'in' keyword
var multis = queryGraphValue.InKeywordMulti;
if (!multis.IsEmpty()) {
if (indexedStreamTableMeta != null) {
return GetFullTableScanTable(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexedStreamTableMeta);
}
var multi = multis[0];
var indexNameArray = new TableLookupIndexReqKey[multi.Indexed.Length];
var foundAll = true;
for (var i = 0; i < multi.Indexed.Length; i++) {
var identNode = (ExprIdentNode) multi.Indexed[i];
var pairIndex = indexSpecs.GetIndexNum(
new[] {identNode.ResolvedPropertyName},
new string[0]);
if (pairIndex == null) {
foundAll = false;
}
else {
indexNameArray[i] = pairIndex.First;
}
}
if (foundAll) {
var forge = new InKeywordTableLookupPlanMultiIdxForge(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexNameArray,
multi.Key.KeyExpr);
return new TableLookupPlanDesc(forge, EmptyList<StmtClassForgeableFactory>.Instance);
}
}
// We don't use a keyed index but use the full stream set as the stream does not have any indexes
// If no such full set index exists yet, add to specs
if (indexedStreamTableMeta != null) {
return GetFullTableScanTable(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexedStreamTableMeta);
}
if (indexNum == null) {
indexNum = new TableLookupIndexReqKey(
indexSpecs.AddIndex(new string[0], new Type[0], typesPerStream[indexedStream]),
null);
}
var forgeX = new FullTableScanLookupPlanForge(currentLookupStream, indexedStream, indexedStreamIsVDW, typesPerStream, indexNum);
return new TableLookupPlanDesc(forgeX, EmptyList<StmtClassForgeableFactory>.Instance);
}
if (indexNum == null) {
throw new IllegalStateException(
"Failed to query plan as index for " +
hashIndexProps.RenderAny() +
" and " +
rangeIndexProps.RenderAny() +
" in the index specification");
}
if (indexedStreamTableMeta != null) {
var indexPairFound =
EventTableIndexUtil.FindIndexBestAvailable(
indexedStreamTableMeta.IndexMetadata.Indexes,
ToSet(hashIndexProps),
ToSet(rangeIndexProps),
null);
if (indexPairFound != null) {
var indexKeyInfo = SubordinateQueryPlannerUtil.CompileIndexKeyInfo(
indexPairFound.First,
hashIndexProps,
GetHashKeyFuncsAsSubProp(hashPropsKeys),
rangeIndexProps,
GetRangeFuncsAsSubProp(rangePropsKeys));
if (indexKeyInfo.OrderedKeyCoercionTypes.IsCoerce ||
indexKeyInfo.OrderedRangeCoercionTypes.IsCoerce) {
return GetFullTableScanTable(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexedStreamTableMeta);
}
hashPropsKeys = ToHashKeyFuncs(indexKeyInfo.OrderedHashDesc);
hashIndexProps = IndexedPropDesc.GetIndexProperties(indexPairFound.First.HashIndexedProps);
rangePropsKeys = ToRangeKeyFuncs(indexKeyInfo.OrderedRangeDesc);
rangeIndexProps = IndexedPropDesc.GetIndexProperties(indexPairFound.First.RangeIndexedProps);
indexNum = new TableLookupIndexReqKey(
indexPairFound.Second.OptionalIndexName,
indexPairFound.Second.OptionalIndexModuleName,
indexedStreamTableMeta.TableName);
// the plan will be created below
if (hashIndexProps.Length == 0 && rangeIndexProps.Length == 0) {
return GetFullTableScanTable(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexedStreamTableMeta);
}
}
else {
return GetFullTableScanTable(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexedStreamTableMeta);
}
}
// straight keyed-index lookup
if (hashIndexProps.Length > 0 && rangeIndexProps.Length == 0) {
// Determine coercion required
var coercionTypes = CoercionUtil.GetCoercionTypesHash(
typesPerStream,
currentLookupStream,
indexedStream,
hashPropsKeys,
hashIndexProps);
if (coercionTypes.IsCoerce) {
// check if there already are coercion types for this index
var existCoercionTypes = indexSpecs.GetCoercionTypes(hashIndexProps);
if (existCoercionTypes != null) {
for (var i = 0; i < existCoercionTypes.Length; i++) {
coercionTypes.CoercionTypes[i] = existCoercionTypes[i]
.GetCompareToCoercionType(coercionTypes.CoercionTypes[i]);
}
}
if (!indexSpecs.Items.IsEmpty()) {
indexSpecs.SetCoercionTypes(hashIndexProps, coercionTypes.CoercionTypes);
}
}
var coercionTypesArray = coercionTypes.CoercionTypes;
MultiKeyClassRef tableLookupMultiKey = null;
IList<StmtClassForgeableFactory> additionalForgeables = EmptyList<StmtClassForgeableFactory>.Instance;
if (indexNum.TableName != null) {
var tableMultiKeyPlan = MultiKeyPlanner.PlanMultiKey(coercionTypesArray, true, raw, serdeResolver);
tableLookupMultiKey = tableMultiKeyPlan.ClassRef;
additionalForgeables = tableMultiKeyPlan.MultiKeyForgeables;
}
var forge = new IndexedTableLookupPlanHashedOnlyForge(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexNum,
hashPropsKeys.ToArray(),
indexSpecs,
coercionTypesArray,
tableLookupMultiKey);
return new TableLookupPlanDesc(forge, additionalForgeables);
}
// sorted index lookup
var coercionTypesRange = CoercionUtil.GetCoercionTypesRange(
typesPerStream,
indexedStream,
rangeIndexProps,
rangePropsKeys);
var coercionTypesHash = CoercionUtil.GetCoercionTypesHash(
typesPerStream,
currentLookupStream,
indexedStream,
hashPropsKeys,
hashIndexProps);
if (hashIndexProps.Length == 0 && rangeIndexProps.Length == 1) {
var range = rangePropsKeys[0];
Type coercionType = null;
if (coercionTypesRange.IsCoerce) {
coercionType = coercionTypesRange.CoercionTypes[0];
}
SortedTableLookupPlanForge forge = new SortedTableLookupPlanForge(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexNum,
range,
coercionType);
return new TableLookupPlanDesc(forge, EmptyList<StmtClassForgeableFactory>.Instance);
}
else {
MultiKeyClassRef tableLookupMultiKey = null;
IList<StmtClassForgeableFactory> additionalForgeables = EmptyList<StmtClassForgeableFactory>.Instance;
if (indexNum.TableName != null) {
MultiKeyPlan tableMultiKeyPlan = MultiKeyPlanner.PlanMultiKey(coercionTypesHash.CoercionTypes, true, raw, serdeResolver);
tableLookupMultiKey = tableMultiKeyPlan.ClassRef;
additionalForgeables = tableMultiKeyPlan.MultiKeyForgeables;
}
// composite range and index lookup
CompositeTableLookupPlanForge forge = new CompositeTableLookupPlanForge(
currentLookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexNum,
hashPropsKeys,
coercionTypesHash.CoercionTypes,
rangePropsKeys,
coercionTypesRange.CoercionTypes,
indexSpecs,
tableLookupMultiKey);
return new TableLookupPlanDesc(forge, additionalForgeables);
}
}
