public void AddRelOp(ExprNode propertyKey, QueryGraphRangeEnum op, ExprIdentNode propertyValueIdent, bool isBetweenOrIn)
{
// Note: Read as follows:
// Console.WriteLine("If I have an index on '" + propertyValue + "' I'm evaluating " + propertyKey + " and finding all values of " + propertyValue + " " + op + " then " + propertyKey);
// Check if there is an opportunity to convert this to a range or remove an earlier specification
var existing = FindIdentEntry(propertyValueIdent);
if (existing == null)
{
_items.Add(new QueryGraphValueDesc(new ExprNode[] { propertyValueIdent }, new QueryGraphValueEntryRangeRelOp(op, propertyKey, isBetweenOrIn)));
return;
}
if (!(existing.Entry is QueryGraphValueEntryRangeRelOp))
{
return; // another comparison exists already, don't add range
}
var relOp = (QueryGraphValueEntryRangeRelOp)existing.Entry;
var opsDesc = QueryGraphRangeUtil.GetCanConsolidate(op, relOp.RangeType);
if (opsDesc != null)
{
var start = !opsDesc.IsReverse ? relOp.Expression : propertyKey;
var end = !opsDesc.IsReverse ? propertyKey : relOp.Expression;
_items.Remove(existing);
AddRange(opsDesc.RangeType, start, end, propertyValueIdent);
}
}
public override EventType GetEventTypeCollection(EventAdapterService eventAdapterService, string statementId)
{
var selectClause = SelectClause;
var rawEventType = RawEventType;
if (selectClause == null) // wildcards allowed
{
return(rawEventType);
}
// special case: selecting a single property that is itself an event
if (selectClause.Length == 1 && selectClause[0] is ExprIdentNode)
{
ExprIdentNode identNode = (ExprIdentNode)selectClause[0];
FragmentEventType fragment = rawEventType.GetFragmentType(identNode.ResolvedPropertyName);
if (fragment != null && !fragment.IsIndexed)
{
return(fragment.FragmentType);
}
}
// select of a single value otherwise results in a collection of scalar values
if (selectClause.Length == 1)
{
return(null);
}
// fully-aggregated always returns zero or one row
if (SubselectAggregationType == SubqueryAggregationType.FULLY_AGGREGATED)
{
return(null);
}
return(GetAssignAnonymousType(eventAdapterService, statementId));
}
public void AddRangeExpr(int indexedStream, ExprIdentNode indexedProp, ExprNode startNode, int? optionalStartStreamNum, ExprNode endNode, int? optionalEndStreamNum)
{
if (optionalStartStreamNum == null && optionalEndStreamNum == null)
{
for (var i = 0; i < _numStreams; i++)
{
if (i == indexedStream)
{
continue;
}
InternalAddRange(i, indexedStream, QueryGraphRangeEnum.RANGE_CLOSED, startNode, endNode, indexedProp);
}
return;
}
optionalStartStreamNum = optionalStartStreamNum ?? -1;
optionalEndStreamNum = optionalEndStreamNum ?? -1;
// add for a specific stream only
if (optionalStartStreamNum.Equals(optionalEndStreamNum) || optionalEndStreamNum.Equals(-1))
{
InternalAddRange(optionalStartStreamNum.Value, indexedStream, QueryGraphRangeEnum.RANGE_CLOSED, startNode, endNode, indexedProp);
}
if (optionalStartStreamNum.Equals(-1))
{
InternalAddRange(optionalEndStreamNum.Value, indexedStream, QueryGraphRangeEnum.RANGE_CLOSED, startNode, endNode, indexedProp);
}
}
public void AddKeyedExpression(
int indexedStream, ExprIdentNode indexedProp,
int keyExprStream, ExprNode exprNodeNoIdent)
{
Check(indexedStream, keyExprStream);
InternalAddEqualsNoProp(keyExprStream, indexedStream, indexedProp, exprNodeNoIdent);
}
private static FilterSpecParam HandleProperty(
FilterOperator op,
ExprIdentNode identNodeLeft,
ExprIdentNode identNodeRight,
IDictionary<string, Pair<EventType, string>> arrayEventTypes,
string statementName)
{
var propertyName = identNodeLeft.ResolvedPropertyName;
var leftType = identNodeLeft.ExprEvaluator.ReturnType;
var rightType = identNodeRight.ExprEvaluator.ReturnType;
var numberCoercer = GetNumberCoercer(leftType, rightType, propertyName);
var isMustCoerce = numberCoercer != null;
var numericCoercionType = leftType.GetBoxedType();
var streamName = identNodeRight.ResolvedStreamName;
if (arrayEventTypes != null && !arrayEventTypes.IsEmpty() && arrayEventTypes.ContainsKey(streamName))
{
var indexAndProp = GetStreamIndex(identNodeRight.ResolvedPropertyName);
return new FilterSpecParamEventPropIndexed(
identNodeLeft.FilterLookupable, op, identNodeRight.ResolvedStreamName,
indexAndProp.First.Value,
indexAndProp.Second, isMustCoerce, numberCoercer, numericCoercionType, statementName);
}
return new FilterSpecParamEventProp(
identNodeLeft.FilterLookupable, op, identNodeRight.ResolvedStreamName,
identNodeRight.ResolvedPropertyName,
isMustCoerce, numberCoercer, numericCoercionType, statementName);
}
/// <summary>Analyzes the outer join descriptor list to build a query graph model. </summary>
/// <param name="outerJoinDescList">list of outer join descriptors</param>
/// <param name="queryGraph">model containing relationships between streams that is written into</param>
/// <returns>queryGraph object</returns>
public static QueryGraph Analyze(OuterJoinDesc[] outerJoinDescList, QueryGraph queryGraph)
{
foreach (OuterJoinDesc outerJoinDesc in outerJoinDescList)
{
// add optional on-expressions
if (outerJoinDesc.OptLeftNode != null) {
ExprIdentNode identNodeLeft = outerJoinDesc.OptLeftNode;
ExprIdentNode identNodeRight = outerJoinDesc.OptRightNode;
Add(queryGraph, identNodeLeft, identNodeRight);
if (outerJoinDesc.AdditionalLeftNodes != null)
{
for (int i = 0; i < outerJoinDesc.AdditionalLeftNodes.Length; i++)
{
Add(queryGraph, outerJoinDesc.AdditionalLeftNodes[i], outerJoinDesc.AdditionalRightNodes[i]);
}
}
}
else {
}
}
return queryGraph;
}
public void Apply(QueryGraph queryGraph)
{
ExprIdentNode targetExpr =
ExprNodeUtility.GetExprIdentNode(_typesPerStream, _targetStreamNum, _targetPropertyName);
RangeFilterAnalyzer.Apply(targetExpr, _start, _end, _includeLow, _includeHigh, false, queryGraph);
}
private static FilterSpecParamFilterForEvalDoubleForge GetIdentNodeDoubleEval(
ExprIdentNode node,
IDictionary<string, Pair<EventType, string>> arrayEventTypes,
string statementName)
{
if (node.StreamId == 0) {
return null;
}
if (arrayEventTypes != null &&
!arrayEventTypes.IsEmpty() &&
arrayEventTypes.ContainsKey(node.ResolvedStreamName)) {
var indexAndProp = GetStreamIndex(node.ResolvedPropertyName);
var eventType = GetArrayInnerEventType(arrayEventTypes, node.ResolvedStreamName);
return new FilterForEvalEventPropIndexedDoubleForge(
node.ResolvedStreamName,
indexAndProp.First,
indexAndProp.Second,
eventType);
}
return new FilterForEvalEventPropDoubleForge(
node.ResolvedStreamName,
node.ResolvedPropertyName,
node.ExprEvaluatorIdent);
}
public ExprIdentNodeEvaluatorImpl(int streamNum, EventPropertyGetter propertyGetter, Type propertyType, ExprIdentNode identNode)
{
_streamNum = streamNum;
_propertyGetter = propertyGetter;
_propertyType = propertyType; // .GetBoxedType();
_identNode = identNode;
}
/// <summary>
/// Add key and index property.
/// </summary>
/// <param name="keyProperty">key property</param>
/// <param name="indexPropertyIdent">index property</param>
/// <param name="keyPropNode">key node</param>
/// <returns>true if added and either property did not exist, false if either already existed</returns>
public bool AddStrictCompare(
string keyProperty,
ExprIdentNode keyPropNode,
ExprIdentNode indexPropertyIdent)
{
var value = FindIdentEntry(indexPropertyIdent);
if (value != null && value.Entry is QueryGraphValueEntryHashKeyedForgeExpr) {
// if this index property exists and is compared to a constant, ignore the index prop
var expr = (QueryGraphValueEntryHashKeyedForgeExpr) value.Entry;
if (expr.IsConstant) {
return false;
}
}
if (value != null && value.Entry is QueryGraphValueEntryHashKeyedForgeProp) {
return false; // second comparison, ignore
}
Items.Add(
new QueryGraphValueDescForge(
new ExprNode[] {indexPropertyIdent},
new QueryGraphValueEntryHashKeyedForgeProp(
keyPropNode,
keyProperty,
keyPropNode.ExprEvaluatorIdent.Getter)));
return true;
}
/// <summary>
/// Analye EQUALS (=) node.
/// </summary>
/// <param name="equalsNode">node to analyze</param>
/// <param name="queryGraph">store relationships between stream properties</param>
/// <param name="isOuterJoin">if set to <c>true</c> [is outer join].</param>
internal static void AnalyzeEqualsNode(ExprEqualsNode equalsNode, QueryGraph queryGraph, bool isOuterJoin)
{
if ((equalsNode.ChildNodes[0] is ExprIdentNode) &&
(equalsNode.ChildNodes[1] is ExprIdentNode))
{
var identNodeLeft = (ExprIdentNode)equalsNode.ChildNodes[0];
var identNodeRight = (ExprIdentNode)equalsNode.ChildNodes[1];
if (identNodeLeft.StreamId != identNodeRight.StreamId)
{
queryGraph.AddStrictEquals(identNodeLeft.StreamId, identNodeLeft.ResolvedPropertyName, identNodeLeft,
identNodeRight.StreamId, identNodeRight.ResolvedPropertyName, identNodeRight);
}
return;
}
if (isOuterJoin) // outerjoins don't use constants or one-way expression-derived information to evaluate join
{
return;
}
// handle constant-compare or transformation case
var indexedStream = -1;
ExprIdentNode indexedPropExpr = null;
ExprNode exprNodeNoIdent = null;
if (equalsNode.ChildNodes[0] is ExprIdentNode)
{
indexedPropExpr = (ExprIdentNode)equalsNode.ChildNodes[0];
indexedStream = indexedPropExpr.StreamId;
exprNodeNoIdent = equalsNode.ChildNodes[1];
}
else if (equalsNode.ChildNodes[1] is ExprIdentNode)
{
indexedPropExpr = (ExprIdentNode)equalsNode.ChildNodes[1];
indexedStream = indexedPropExpr.StreamId;
exprNodeNoIdent = equalsNode.ChildNodes[0];
}
if (indexedStream == -1)
{
return; // require property of right/left side of equals
}
var eligibility = EligibilityUtil.VerifyInputStream(exprNodeNoIdent, indexedStream);
if (!eligibility.Eligibility.IsEligible())
{
return;
}
if (eligibility.Eligibility == Eligibility.REQUIRE_NONE)
{
queryGraph.AddUnkeyedExpression(indexedStream, indexedPropExpr, exprNodeNoIdent);
}
else
{
queryGraph.AddKeyedExpression(indexedStream, indexedPropExpr, eligibility.StreamNum.Value, exprNodeNoIdent);
}
}
/// <summary>Ctor. </summary>
/// <param name="outerJoinType">type of the outer join</param>
/// <param name="optLeftNode">left hand identifier node</param>
/// <param name="optRightNode">right hand identifier node</param>
/// <param name="optAddLeftNode">additional optional left hand identifier nodes for the on-clause in a logical-and</param>
/// <param name="optAddRightNode">additional optional right hand identifier nodes for the on-clause in a logical-and</param>
public OuterJoinDesc(OuterJoinType outerJoinType, ExprIdentNode optLeftNode, ExprIdentNode optRightNode, ExprIdentNode[] optAddLeftNode, ExprIdentNode[] optAddRightNode)
{
OuterJoinType = outerJoinType;
OptLeftNode = optLeftNode;
OptRightNode = optRightNode;
AdditionalLeftNodes = optAddLeftNode;
AdditionalRightNodes = optAddRightNode;
}
public void AddRelationalOpStrict(int streamIdLeft, ExprIdentNode propertyLeftExpr,
int streamIdRight, ExprIdentNode propertyRightExpr,
RelationalOpEnum relationalOpEnum)
{
Check(streamIdLeft, streamIdRight);
InternalAddRelOp(streamIdLeft, streamIdRight, propertyLeftExpr, QueryGraphRangeEnumExtensions.MapFrom(relationalOpEnum.Reversed()), propertyRightExpr, false);
InternalAddRelOp(streamIdRight, streamIdLeft, propertyRightExpr, QueryGraphRangeEnumExtensions.MapFrom(relationalOpEnum), propertyLeftExpr, false);
}
public void AddKeyedExpr(
ExprIdentNode indexedPropIdent,
ExprNode exprNodeNoIdent)
{
Items.Add(
new QueryGraphValueDescForge(
new ExprNode[] {indexedPropIdent},
new QueryGraphValueEntryHashKeyedForgeExpr(exprNodeNoIdent, true)));
}
private void TryInvalidValidate(ExprIdentNode identNode)
{
try
{
identNode.Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.Fail();
}
catch (ExprValidationException ex)
{
// expected
}
}
private static void ValidateBuiltin(
CreateIndexItem columnDesc,
EventType eventType,
IList <IndexedPropDesc> hashProps,
IList <IndexedPropDesc> btreeProps,
ISet <string> indexedColumns)
{
if (columnDesc.Expressions.IsEmpty())
{
throw new ExprValidationException("Invalid empty list of index expressions");
}
if (columnDesc.Expressions.Count > 1)
{
throw new ExprValidationException("Invalid multiple index expressions for index type '" + columnDesc.IndexType + "'");
}
ExprNode expression = columnDesc.Expressions[0];
if (!(expression is ExprIdentNode))
{
throw new ExprValidationException("Invalid index expression '" + expression.ToExpressionStringMinPrecedenceSafe() + "'");
}
ExprIdentNode identNode = (ExprIdentNode)expression;
if (identNode.FullUnresolvedName.Contains("."))
{
throw new ExprValidationException("Invalid index expression '" + expression.ToExpressionStringMinPrecedenceSafe() + "'");
}
string columnName = identNode.FullUnresolvedName;
Type type = eventType.GetPropertyType(columnName).GetBoxedType();
if (type == null)
{
throw new ExprValidationException("Property named '" + columnName + "' not found");
}
if (!indexedColumns.Add(columnName))
{
throw new ExprValidationException("Property named '" + columnName + "' has been declared more then once");
}
var desc = new IndexedPropDesc(columnName, type);
string indexType = columnDesc.IndexType;
if (string.Equals(indexType, CreateIndexType.HASH.ToString(), StringComparison.InvariantCultureIgnoreCase))
{
hashProps.Add(desc);
}
else
{
btreeProps.Add(desc);
}
}
private static void Add(
QueryGraphForge queryGraph,
ExprIdentNode identNodeLeft,
ExprIdentNode identNodeRight)
{
queryGraph.AddStrictEquals(
identNodeLeft.StreamId,
identNodeLeft.ResolvedPropertyName,
identNodeLeft,
identNodeRight.StreamId,
identNodeRight.ResolvedPropertyName,
identNodeRight);
}
private void InternalAddEqualsUnkeyed(int streamKey, int streamValue, ExprIdentNode indexedProp, ExprNode exprNodeNoIdent)
{
if (_nToZeroAnalysis && streamValue != 0)
{
return;
}
if (_optionalHint != null && _optionalHint.Filter(streamKey, streamValue, ExcludePlanFilterOperatorType.EQUALS))
{
return;
}
var value = GetCreateValue(streamKey, streamValue);
value.AddUnkeyedExpr(indexedProp, exprNodeNoIdent);
}
private bool InternalAddEquals(int streamLookup, String propertyLookup, ExprIdentNode propertyLookupNode, int streamIndexed, ExprIdentNode propertyIndexedNode)
{
if (_nToZeroAnalysis && streamIndexed != 0)
{
return false;
}
if (_optionalHint != null && _optionalHint.Filter(streamLookup, propertyIndexedNode.StreamId, ExcludePlanFilterOperatorType.EQUALS, propertyLookupNode, propertyIndexedNode))
{
return false;
}
var value = GetCreateValue(streamLookup, streamIndexed);
return value.AddStrictCompare(propertyLookup, propertyLookupNode, propertyIndexedNode);
}
private void InternalAddEqualsNoProp(int keyExprStream, int indexedStream, ExprIdentNode indexedProp, ExprNode exprNodeNoIdent)
{
if (_nToZeroAnalysis && indexedStream != 0)
{
return;
}
if (_optionalHint != null && _optionalHint.Filter(keyExprStream, indexedStream, ExcludePlanFilterOperatorType.EQUALS))
{
return;
}
var value = GetCreateValue(keyExprStream, indexedStream);
value.AddKeyedExpr(indexedProp, exprNodeNoIdent);
}
private static void AnalyzeRelationalOpNode(ExprRelationalOpNode relNode, QueryGraph queryGraph)
{
if (((relNode.ChildNodes[0] is ExprIdentNode)) &&
((relNode.ChildNodes[1] is ExprIdentNode)))
{
var identNodeLeft = (ExprIdentNode)relNode.ChildNodes[0];
var identNodeRight = (ExprIdentNode)relNode.ChildNodes[1];
if (identNodeLeft.StreamId != identNodeRight.StreamId)
{
queryGraph.AddRelationalOpStrict(
identNodeLeft.StreamId, identNodeLeft,
identNodeRight.StreamId, identNodeRight,
relNode.RelationalOpEnum);
}
return;
}
var indexedStream = -1;
ExprIdentNode indexedPropExpr = null;
ExprNode exprNodeNoIdent = null;
RelationalOpEnum relop = relNode.RelationalOpEnum;
if (relNode.ChildNodes[0] is ExprIdentNode)
{
indexedPropExpr = (ExprIdentNode)relNode.ChildNodes[0];
indexedStream = indexedPropExpr.StreamId;
exprNodeNoIdent = relNode.ChildNodes[1];
}
else if (relNode.ChildNodes[1] is ExprIdentNode)
{
indexedPropExpr = (ExprIdentNode)relNode.ChildNodes[1];
indexedStream = indexedPropExpr.StreamId;
exprNodeNoIdent = relNode.ChildNodes[0];
relop = relop.Reversed();
}
if (indexedStream == -1)
{
return; // require property of right/left side of equals
}
var eligibility = EligibilityUtil.VerifyInputStream(exprNodeNoIdent, indexedStream);
if (!eligibility.Eligibility.IsEligible())
{
return;
}
queryGraph.AddRelationalOp(indexedStream, indexedPropExpr, eligibility.StreamNum, exprNodeNoIdent, relop);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (ChildNodes.Length != 1) {
throw new ExprValidationException("Exists function node must have exactly 1 child node");
}
if (!(ChildNodes[0] is ExprIdentNode)) {
throw new ExprValidationException(
"Exists function expects an property value expression as the child node");
}
identNode = (ExprIdentNode) ChildNodes[0];
return null;
}
internal void AddRangeStrict(
int streamNumStart, ExprIdentNode propertyStartExpr,
int streamNumEnd, ExprIdentNode propertyEndExpr,
int streamNumValue, ExprIdentNode propertyValueExpr,
QueryGraphRangeEnum rangeOp)
{
Check(streamNumStart, streamNumValue);
Check(streamNumEnd, streamNumValue);
// add as a range if the endpoints are from the same stream
if (streamNumStart == streamNumEnd && streamNumStart != streamNumValue)
{
InternalAddRange(
streamNumStart, streamNumValue, rangeOp, propertyStartExpr, propertyEndExpr,
propertyValueExpr);
InternalAddRelOp(
streamNumValue, streamNumStart, propertyValueExpr,
QueryGraphRangeEnum.GREATER_OR_EQUAL, propertyEndExpr, false);
InternalAddRelOp(
streamNumValue, streamNumStart, propertyValueExpr, QueryGraphRangeEnum.LESS_OR_EQUAL,
propertyStartExpr, false);
}
else
{
// endpoints from a different stream, add individually
if (streamNumValue != streamNumStart)
{
// read propertyValue >= propertyStart
InternalAddRelOp(
streamNumStart, streamNumValue, propertyStartExpr,
QueryGraphRangeEnum.GREATER_OR_EQUAL, propertyValueExpr, true);
// read propertyStart <= propertyValue
InternalAddRelOp(
streamNumValue, streamNumStart, propertyValueExpr,
QueryGraphRangeEnum.LESS_OR_EQUAL, propertyStartExpr, true);
}
if (streamNumValue != streamNumEnd)
{
// read propertyValue <= propertyEnd
InternalAddRelOp(
streamNumEnd, streamNumValue, propertyEndExpr, QueryGraphRangeEnum.LESS_OR_EQUAL,
propertyValueExpr, true);
// read propertyEnd >= propertyValue
InternalAddRelOp(
streamNumValue, streamNumEnd, propertyValueExpr,
QueryGraphRangeEnum.GREATER_OR_EQUAL, propertyEndExpr, true);
}
}
}
public static Pair<string, ExprNode> CheckGetAssignmentToProp(ExprNode node)
{
if (!(node is ExprEqualsNode)) {
return null;
}
ExprEqualsNode equals = (ExprEqualsNode) node;
if (!(equals.ChildNodes[0] is ExprIdentNode)) {
return null;
}
ExprIdentNode identNode = (ExprIdentNode) equals.ChildNodes[0];
return new Pair<string, ExprNode>(identNode.FullUnresolvedName, equals.ChildNodes[1]);
}
public void TestGetNavigableStreams()
{
ExprIdentNode fake = supportExprNodeFactory.MakeIdentNode("TheString", "s0");
queryGraph = new QueryGraphForge(5, null, false);
queryGraph.AddStrictEquals(3, "p3", fake, 4, "p4", fake);
queryGraph.AddStrictEquals(2, "P2", fake, 3, "p3", fake);
queryGraph.AddStrictEquals(1, "P1", fake, 2, "P2", fake);
Assert.AreEqual(0, queryGraph.GetNavigableStreams(0).Count);
EPAssertionUtil.AssertEqualsAnyOrder(new int[] { 2 }, queryGraph.GetNavigableStreams(1));
EPAssertionUtil.AssertEqualsAnyOrder(new int[] { 1, 3 }, queryGraph.GetNavigableStreams(2));
EPAssertionUtil.AssertEqualsAnyOrder(new int[] { 2, 4 }, queryGraph.GetNavigableStreams(3));
EPAssertionUtil.AssertEqualsAnyOrder(new int[] { 3 }, queryGraph.GetNavigableStreams(4));
}
public void AddUnkeyedExpression(int indexedStream, ExprIdentNode indexedProp, ExprNode exprNodeNoIdent)
{
if (indexedStream < 0 || indexedStream >= _numStreams)
{
throw new ArgumentException("Invalid indexed stream " + indexedStream);
}
for (var i = 0; i < _numStreams; i++)
{
if (i != indexedStream)
{
InternalAddEqualsUnkeyed(i, indexedStream, indexedProp, exprNodeNoIdent);
}
}
}
private QueryGraphValueDescForge FindIdentEntry(ExprIdentNode search)
{
foreach (var desc in Items) {
if (desc.IndexExprs.Length > 1 || !(desc.IndexExprs[0] is ExprIdentNode)) {
continue;
}
var other = (ExprIdentNode) desc.IndexExprs[0];
if (search.ResolvedPropertyName.Equals(other.ResolvedPropertyName)) {
return desc;
}
}
return null;
}
private void TryAdd(string propertyKeyOne, QueryGraphRangeEnum opOne, ExprIdentNode valueOne,
string propertyKeyTwo, QueryGraphRangeEnum opTwo, ExprIdentNode valueTwo,
object[][] expected)
{
var value = new QueryGraphValue();
value.AddRelOp(MakeIdent(propertyKeyOne), opOne, valueOne, true);
value.AddRelOp(MakeIdent(propertyKeyTwo), opTwo, valueTwo, true);
AssertRanges(expected, value);
value = new QueryGraphValue();
value.AddRelOp(MakeIdent(propertyKeyTwo), opTwo, valueTwo, true);
value.AddRelOp(MakeIdent(propertyKeyOne), opOne, valueOne, true);
AssertRanges(expected, value);
}
private static bool IsColumnNameNode(ExprNode node, String name)
{
if (node is ExprIdentNode)
{
if (node.ChildNodes.Count > 0)
{
throw new IllegalStateException("Ident node has unexpected child nodes");
}
ExprIdentNode identNode = (ExprIdentNode)node;
return(identNode.UnresolvedPropertyName.Equals(name) && identNode.StreamOrPropertyName == null);
}
else
{
return(false);
}
}
private QueryGraphValueDesc FindIdentEntry(ExprIdentNode search)
{
foreach (var desc in _items)
{
if (desc.IndexExprs.Count > 1 || !(desc.IndexExprs[0] is ExprIdentNode))
{
continue;
}
var other = (ExprIdentNode)desc.IndexExprs[0];
if (search.ResolvedPropertyName.Equals(other.ResolvedPropertyName))
{
return(desc);
}
}
return(null);
}
