private IEnumerable <SceneNode> IncrementalTraverseWithSearchPath(SceneNode basisNode, DocumentNodeMarker rootMarker) { if (this.path.NumberOfSteps == 1) { SearchStep step = this.path.Step(0); if (step.Axis == SearchAxis.DocumentDescendant && (step.Predicate == null || (step.Predicate.AnalysisScope & (SearchScope)6) == step.Predicate.AnalysisScope)) { SceneNode rootSceneNode = this.currentViewModel.GetSceneNode(rootMarker.Node); if (step.ContinuePredicate != null) { for (DocumentNode node = rootMarker.Node; node != null && node != basisNode.DocumentNode; node = (DocumentNode)node.Parent) { if (!step.ContinuePredicate.Test(this.currentViewModel.GetSceneNode(node))) { yield break; } } } if (step.Predicate == null || step.Predicate.Test(rootSceneNode)) { yield return(rootSceneNode); } foreach (SceneNode sceneNode in this.path.Query(rootSceneNode)) { yield return(sceneNode); } } } }
private List <SearchStep> GetSearchParts(List <StatementPart> parts) { var result = new List <SearchStep>(); foreach (var part in parts) { var step = new SearchStep(part); step.Level = _level; result.Add(step); } return(result); }
public QueryPlan GetPlan(string input) { var plan = new QueryPlan(); var items = input.Split(';'); var databaseStatement = string.Empty; var commandStatement = string.Empty; if (items.Count() > 0) { databaseStatement = items[0]; commandStatement = items[1]; } var databaseName = GetDatabaseName(databaseStatement); if (IsDDLStatment(input)) { FrostIDDLStatement statement = GetDDLStatement(commandStatement, databaseName); if (string.IsNullOrEmpty(statement.DatabaseName)) { statement.DatabaseName = databaseName; } else { databaseName = statement.DatabaseName; } plan = _planGenerator.GeneratePlan(statement, databaseName); } else { FrostIDMLStatement statement = GetDMLStatement(commandStatement, databaseName); statement.DatabaseName = databaseName; if (!statement.IsValid) { var step = new SearchStep(); step.IsValid = false; plan.Steps.Add(step); } else { plan = _planGenerator.GeneratePlan(statement, databaseName); } } return(plan); }
public override void Start() { SearchStep searchStep = new SearchStep(); searchStep.Start(); }
/// <summary> /// Overrides the normal searching waits to take half as long as normal. useful through dynamic polymorphism /// </summary> protected override void AddSearchStep() { SearchStep searchStep = new SearchStep(finalStep.Location, SearchStep.defaultTime / 2, this, map); plannedActions.Add(searchStep); }
public void ChainUpdate(SceneViewModel viewModel, DocumentNodeMarkerSortedListBase newBasisNodes, IEnumerable <SceneNode> bonusBasisNodes, DocumentNodeChangeList damage, uint damageChangeStamp) { this.ValidateBasisNodeStateWithViewModel(viewModel); if (this.currentViewModel == null) { return; } SearchScope searchScope = (SearchScope)6; SearchScope scope = this.path.Scope; bool flag1 = (scope & searchScope) != scope; bool flag2 = false; if (this.path.NumberOfSteps == 1) { SearchStep searchStep = this.path.Step(0); if (searchStep.Axis == SearchAxis.DocumentDescendant && (searchStep.Predicate.AnalysisScope & (SearchScope)6) == searchStep.Predicate.AnalysisScope) { flag2 = true; } } if (newBasisNodes != null || bonusBasisNodes != null) { DocumentNodeMarkerSortedListOf <SceneNodeSubscription <basisT, pathT> .BasisNodeHolder> newBasisNodeList = new DocumentNodeMarkerSortedListOf <SceneNodeSubscription <basisT, pathT> .BasisNodeHolder>(newBasisNodes.Count); if (newBasisNodes != null) { for (int index = 0; index < newBasisNodes.Count; ++index) { newBasisNodeList.Add(newBasisNodes.MarkerAt(index), (SceneNodeSubscription <basisT, pathT> .BasisNodeHolder)null); } } if (bonusBasisNodes != null) { foreach (SceneNode sceneNode in bonusBasisNodes) { newBasisNodeList.Add(sceneNode.DocumentNode.Marker, (SceneNodeSubscription <basisT, pathT> .BasisNodeHolder)null); } } this.SetBasisNodesWorker(viewModel, newBasisNodeList); } foreach (DocumentNodeMarkerSortedListBase.IntersectionResult intersectionResult in this.pathNodeList.Intersect((DocumentNodeMarkerSortedListBase)damage, DocumentNodeMarkerSortedListBase.Flags.Contains)) { this.OnPathNodeContentChanged(this.pathNodeList.ValueAt(intersectionResult.LeftHandSideIndex), damage.MarkerAt(intersectionResult.RightHandSideIndex), damage.ValueAt(intersectionResult.RightHandSideIndex)); } if (flag1) { this.Recalculate(viewModel); } else { for (int index = this.basisNodeList.Count - 1; index >= 0; --index) { if (this.basisNodeList.MarkerAt(index).IsDeleted) { this.RemoveBasisNode(index); } else if (flag2) { this.IncrementalRecalculateBasisNode(index, damage, damageChangeStamp); } else { this.RecalculateBasisNode(index); } } } }
private BoolStep GetBoolStepFromStep(SearchStep step, string boolTerm, List <SearchStep> steps, List <BoolStep> boolSteps) { Console.WriteLine($"GetBoolStepFromStep: {step.Part.TextWithWhiteSpace}"); var stepParentText = step.Part.StatementParentWithWhiteSpace; var stepGrandParentText = step.Part.StatementGrandParentWithWhiteSpace; BoolStep boolStep = null; // if the previous step has a BOOLEAN and is not part of a () grouping if (stepParentText.Contains(boolTerm) && !stepParentText.Contains("(")) { boolStep = new BoolStep(); boolStep.Level = _level; boolStep.Boolean = boolTerm.Trim(); boolStep.InputOne = step; int indexOfBool = stepParentText.IndexOf(boolTerm); // need to find the other half of the BOOL statement var otherTermText = stepParentText.Substring(indexOfBool); int i = otherTermText.IndexOf(boolTerm); otherTermText = otherTermText.Remove(i, boolTerm.Length); var otherTerm = steps.Where(s => s.Part.TextWithWhiteSpace.Equals(otherTermText)).FirstOrDefault(); if (otherTerm != null) { // make sure we don't already have a boolstep for ourselves if (otherTerm.Part.Text != step.Part.Text) { boolStep.InputTwo = otherTerm; } else { return(null); } } } // if the previous step has a boolean AND is part of a () grouping // AGE > 32 if (stepParentText.Contains(boolTerm) && stepParentText.Contains("(")) { var clauses = stepParentText.Split('(', ')').ToList(); var nextStep = new BoolStep(); var lastBoolStep = new BoolStep(); foreach (var clause in clauses) { foreach (var b in boolSteps) { if (b.BoolStepTextWithWhiteSpace.Contains(clause)) { lastBoolStep = b; nextStep.InputOne = b; nextStep.InputTwo = step; break; } } } var parse = stepParentText; parse = parse.Remove(parse.IndexOf(lastBoolStep.BoolStepTextWithWhiteSpace), lastBoolStep.BoolStepTextWithWhiteSpace.Length); parse = parse.Remove(parse.IndexOf(step.Part.TextWithWhiteSpace), step.Part.TextWithWhiteSpace.Length); if (parse.Contains(" AND ")) { nextStep.Boolean = "AND"; } if (parse.Contains(" OR ")) { nextStep.Boolean = "OR"; } nextStep.Level = _level++; nextStep.BoolStepTextWithWhiteSpace = stepParentText; boolStep = nextStep; } // if the previous step is part of a multi BOOLEAN (i.e. NAME = MEGAN) if (stepParentText.Equals(step.Part.TextWithWhiteSpace) && !stepGrandParentText.Equals(step.Part.TextWithWhiteSpace)) { var totalBools = 0; var words = stepGrandParentText.Split(" ").ToList(); foreach (var word in words) { if (word.Equals("AND") || word.Equals("OR")) { totalBools++; } } if (totalBools > 1) { // we know we are part of a multi BOOL operation at the same level and need to // find the previous bool operator(s) for the other terms foreach (var b in boolSteps) { if (b.InputOne is SearchStep && b.InputTwo is SearchStep) { var input1 = (b.InputOne as SearchStep); var input2 = (b.InputTwo as SearchStep); if (stepGrandParentText.Contains(input1.Part.TextWithWhiteSpace) && stepGrandParentText.Contains(input2.Part.TextWithWhiteSpace)) { // we need to link this boolstep to the next planstep var nextStep = new BoolStep(); nextStep.Boolean = boolTerm.Trim(); nextStep.Level = _level++; nextStep.InputOne = b; nextStep.InputTwo = step; var parse = stepGrandParentText; parse = parse.Remove(parse.IndexOf(input1.Part.TextWithWhiteSpace), input1.Part.TextWithWhiteSpace.Length); parse = parse.Remove(parse.IndexOf(b.Boolean), b.Boolean.Length); parse = parse.Remove(parse.IndexOf(input2.Part.TextWithWhiteSpace), input2.Part.TextWithWhiteSpace.Length); parse = parse.Remove(parse.IndexOf(step.Part.TextWithWhiteSpace), step.Part.TextWithWhiteSpace.Length); if (parse.Contains(" AND ")) { nextStep.Boolean = "AND"; } if (parse.Contains(" OR ")) { nextStep.Boolean = "OR"; } nextStep.BoolStepTextWithWhiteSpace = stepGrandParentText; boolStep = nextStep; break; } } } } else if (totalBools == 1) { boolStep = new BoolStep(); boolStep.InputOne = steps[0]; boolStep.InputTwo = steps[1]; if (stepGrandParentText.Contains(" AND ")) { boolStep.Boolean = "AND"; } if (stepGrandParentText.Contains(" OR ")) { boolStep.Boolean = "OR"; } } } // we are an outermost term // NAME = BRIAN if (stepParentText.Equals(stepGrandParentText) && boolStep is null && stepParentText != _clause.TextWithWhiteSpace ) { if (boolSteps.Count > 0) { int maxLevel = boolSteps.Max(i => i.Level); var maxStep = boolSteps.Where(i => i.Level == maxLevel).FirstOrDefault(); if (maxStep != null) { boolStep = new BoolStep(); boolStep.InputOne = maxStep; boolStep.InputTwo = step; boolStep.Level = maxLevel++; // need to find the boolean operator var text = _clause.TextWithWhiteSpace; foreach (var k in steps) { if (k.Part == step.Part) { break; } int i = text.IndexOf(k.Part.TextWithWhiteSpace); text = text.Remove(i, k.Part.TextWithWhiteSpace.Length); } var par = text.Split('(', ')').ToList(); par.RemoveAll(p => string.IsNullOrEmpty(p)); int previousItem = 0; foreach (var r in par) { if (r == step.Part.TextWithWhiteSpace) { previousItem = par.IndexOf(r) - 1; } } boolStep.Boolean = par[previousItem].Trim(); } } } if (boolStep != null) { DebugBoolStep(boolStep); } return(boolStep); }