/// <summary> /// Gets the match result for the item with the given name. /// </summary> /// <param name="itemName">The name of the item to get the results for.</param> /// <returns>The match result for the item with the given name -or- an empty MatchResult.</returns> public MatchResult this[string itemName] { get { MatchResult result; if (!resultLookup.TryGetValue(itemName, out result)) { result = new MatchResult() { ItemName = itemName, IsMatch = false }; } return result; } }
/// <summary> /// Attempts to match the expression item with the values returned by the parser. /// </summary> /// <param name="attempt">The parser currently iterating over the token source.</param> /// <param name="itemName">The name of the item in the outer expression.</param> /// <returns>The results of the match.</returns> public MatchResult Match(IParseAttempt attempt, string itemName) { MatchResult result = new MatchResult() { ItemName = itemName, IsMatch = true }; foreach (ExpressionItem detail in expression.Items) { IParseAttempt nextAttempt = attempt.Attempt(); MatchResult innerResult = detail.Item.Match(nextAttempt, detail.ItemName); if (innerResult.IsMatch) { attempt.Accept(nextAttempt); result.Matches.Add(innerResult); } else { nextAttempt.Reject(); if (detail.IsRequired) { result.IsMatch = false; return result; } } } return result; }
private void buildMatch(MatchResult result, MatchCase options) { MatchResult expressionResult = result.Matches[SqlGrammar.Match.Expression]; IProjectionItem expression = (IProjectionItem)buildArithmeticItem(expressionResult); MatchResult valueResult = result.Matches[SqlGrammar.Match.Value]; IProjectionItem value = (IProjectionItem)buildArithmeticItem(valueResult); options.AddBranch(expression, value); }
private void buildOrderByList(MatchResult result, List<OrderBy> orderByList) { MatchResult multiple = result.Matches[SqlGrammar.OrderByList.Multiple.Name]; if (multiple.IsMatch) { MatchResult first = multiple.Matches[SqlGrammar.OrderByList.Multiple.First]; buildOrderByItem(first, orderByList); MatchResult remaining = multiple.Matches[SqlGrammar.OrderByList.Multiple.Remaining]; buildOrderByList(remaining, orderByList); return; } MatchResult single = result.Matches[SqlGrammar.OrderByList.Single]; if (single.IsMatch) { buildOrderByItem(single, orderByList); return; } throw new InvalidOperationException(); }
private ICommand buildDeleteStatement(MatchResult result) { MatchResult tableResult = result.Matches[SqlGrammar.DeleteStatement.Table]; Table table = buildTable(tableResult); string alias = null; MatchResult aliasExpressionResult = result.Matches[SqlGrammar.DeleteStatement.AliasExpression.Name]; if (aliasExpressionResult.IsMatch) { MatchResult aliasResult = aliasExpressionResult.Matches[SqlGrammar.DeleteStatement.AliasExpression.Alias]; alias = getToken(aliasResult); } DeleteBuilder builder = new DeleteBuilder(table, alias); SourceCollection collection = new SourceCollection(); collection.AddSource(builder.Table.GetSourceName(), builder.Table); scope.Push(collection); MatchResult whereResult = result.Matches[SqlGrammar.DeleteStatement.Where.Name]; if (whereResult.IsMatch) { MatchResult filterListResult = whereResult.Matches[SqlGrammar.DeleteStatement.Where.FilterList]; IFilter innerFilter = buildOrFilter(filterListResult); builder.WhereFilterGroup.AddFilter(innerFilter); builder.WhereFilterGroup.Optimize(); } scope.Pop(); return builder; }
private object buildNamedItem(MatchResult result) { List<string> parts = new List<string>(); buildMultipartIdentifier(result, parts); if (parts.Count > 1) { // if is a period-separated, multiple-part identifier, it is a column Namespace qualifier = getNamespace(parts.Take(parts.Count - 2)); string tableName = parts[parts.Count - 2]; AliasedSource source = scope.GetSource(tableName); string columnName = parts[parts.Count - 1]; return source.Column(columnName); } string name = parts[0]; if (options.PlaceholderPrefix != null && name.StartsWith(options.PlaceholderPrefix)) { // if the identifier begins with the placeholder prefix, treat is as a placeholder Placeholder placeholder = new Placeholder(name); return placeholder; } AliasedSource singleSource; if (scope.HasSingleSource(out singleSource)) { // there is only one source in the query, so assume a column Column column = singleSource.Column(name); column.Qualify = false; return column; } // otherwise, we have no idea what the name represents // in order for the SQL to roundtrip without alteration, just use a placeholder Placeholder unknown = new Placeholder(name); return unknown; }
private NumericLiteral buildNumericLiteral(MatchResult result) { string numberString = getToken(result); double value = Double.Parse(numberString); return new NumericLiteral(value); }
private void buildMatchListPrime(MatchResult result, MatchCase options) { MatchResult matchResult = result.Matches[SqlGrammar.MatchListPrime.Match.Name]; if (matchResult.IsMatch) { MatchResult firstResult = matchResult.Matches[SqlGrammar.MatchListPrime.Match.First]; buildMatch(firstResult, options); MatchResult remainingResult = matchResult.Matches[SqlGrammar.MatchListPrime.Match.Remaining]; buildMatchListPrime(remainingResult, options); return; } MatchResult elseResult = result.Matches[SqlGrammar.MatchListPrime.Else.Name]; if (elseResult.IsMatch) { MatchResult valueResult = elseResult.Matches[SqlGrammar.MatchListPrime.Else.Value]; options.Default = (IProjectionItem)buildArithmeticItem(valueResult); return; } MatchResult emptyResult = result.Matches[SqlGrammar.MatchListPrime.Empty]; if (emptyResult.IsMatch) { return; } throw new InvalidOperationException(); }
private object buildMultiplicitiveOperator(MatchResult result, IProjectionItem leftHand, IProjectionItem rightHand, bool wrap) { MatchResult multiply = result.Matches[SqlGrammar.MultiplicitiveOperator.Multiply]; if (multiply.IsMatch) { Multiplication multiplication = new Multiplication(leftHand, rightHand); multiplication.WrapInParentheses = wrap; return multiplication; } MatchResult divide = result.Matches[SqlGrammar.MultiplicitiveOperator.Divide]; if (divide.IsMatch) { Division division = new Division(leftHand, rightHand); division.WrapInParentheses = wrap; return division; } MatchResult modulo = result.Matches[SqlGrammar.MultiplicitiveOperator.Modulus]; if (modulo.IsMatch) { Modulus modulus = new Modulus(leftHand, rightHand); modulus.WrapInParentheses = wrap; return modulus; } throw new InvalidOperationException(); }
private void buildFromList(MatchResult result, SelectBuilder builder) { MatchResult multiple = result.Matches[SqlGrammar.FromList.Multiple.Name]; if (multiple.IsMatch) { MatchResult first = multiple.Matches[SqlGrammar.FromList.Multiple.First]; Join join = buildJoin(first, false); addJoinItem(builder, join); MatchResult remaining = multiple.Matches[SqlGrammar.FromList.Multiple.Remaining]; buildFromList(remaining, builder); return; } MatchResult single = result.Matches[SqlGrammar.FromList.Single]; if (single.IsMatch) { Join join = buildJoin(single, false); addJoinItem(builder, join); return; } throw new InvalidOperationException(); }
private Function buildFunctionCall(MatchResult result) { MatchResult functionNameResult = result.Matches[SqlGrammar.FunctionCall.FunctionName]; List<string> parts = new List<string>(); buildMultipartIdentifier(functionNameResult, parts); Namespace qualifier = getNamespace(parts.Take(parts.Count - 1)); string functionName = parts[parts.Count - 1]; Function function = new Function(qualifier, functionName); MatchResult argumentsResult = result.Matches[SqlGrammar.FunctionCall.Arguments]; if (argumentsResult.IsMatch) { ValueList arguments = new ValueList(); buildValueList(argumentsResult, arguments); foreach (IProjectionItem value in arguments.Values) { function.AddArgument(value); } } MatchResult windowResult = result.Matches[SqlGrammar.FunctionCall.Window.Name]; if (windowResult.IsMatch) { FunctionWindow window = new FunctionWindow(); MatchResult partitioning = windowResult.Matches[SqlGrammar.FunctionCall.Window.Partitioning.Name]; if (partitioning.IsMatch) { MatchResult valueListResult = partitioning.Matches[SqlGrammar.FunctionCall.Window.Partitioning.ValueList]; ValueList valueList = new ValueList(); buildValueList(valueListResult, valueList); foreach (IProjectionItem value in valueList.Values) { window.AddPartition(value); } } MatchResult ordering = windowResult.Matches[SqlGrammar.FunctionCall.Window.Ordering.Name]; if (ordering.IsMatch) { MatchResult orderByListResult = ordering.Matches[SqlGrammar.FunctionCall.Window.Ordering.OrderByList]; buildOrderByList(orderByListResult, window.OrderByList); } MatchResult framing = windowResult.Matches[SqlGrammar.FunctionCall.Window.Framing.Name]; if (framing.IsMatch) { MatchResult precedingOnlyFrameResult = framing.Matches[SqlGrammar.FunctionCall.Window.Framing.PrecedingFrame]; if (precedingOnlyFrameResult.IsMatch) { IPrecedingFrame precedingFrame = buildPrecedingFrame(precedingOnlyFrameResult); window.Frame = new PrecedingOnlyWindowFrame(precedingFrame); } MatchResult betweenFrameResult = framing.Matches[SqlGrammar.FunctionCall.Window.Framing.BetweenFrame.Name]; if (betweenFrameResult.IsMatch) { MatchResult precedingFrameResult = betweenFrameResult.Matches[SqlGrammar.FunctionCall.Window.Framing.BetweenFrame.PrecedingFrame]; IPrecedingFrame precedingFrame = buildPrecedingFrame(precedingFrameResult); MatchResult followingFrameResult = betweenFrameResult.Matches[SqlGrammar.FunctionCall.Window.Framing.BetweenFrame.FollowingFrame]; IFollowingFrame followingFrame = buildFollowingFrame(followingFrameResult); window.Frame = new BetweenWindowFrame(precedingFrame, followingFrame); } MatchResult frameTypeResult = framing.Matches[SqlGrammar.FunctionCall.Window.Framing.FrameType]; window.Frame.FrameType = buildFrameType(frameTypeResult); } function.FunctionWindow = window; } return function; }
private IFollowingFrame buildFollowingFrame(MatchResult result) { MatchResult unbound = result.Matches[SqlGrammar.FollowingFrame.UnboundedFollowing.Name]; if (unbound.IsMatch) { return new FollowingUnboundFrame(); } MatchResult bound = result.Matches[SqlGrammar.FollowingFrame.BoundedFollowing.Name]; if (bound.IsMatch) { MatchResult rowCountResult = bound.Matches[SqlGrammar.FollowingFrame.BoundedFollowing.Number]; NumericLiteral rowCount = buildNumericLiteral(rowCountResult); return new FollowingBoundFrame((int)rowCount.Value); } MatchResult currentRow = result.Matches[SqlGrammar.FollowingFrame.CurrentRow]; if (currentRow.IsMatch) { return new CurrentRowFrame(); } throw new InvalidOperationException(); }
private FrameType buildFrameType(MatchResult result) { MatchResult rows = result.Matches[SqlGrammar.FrameType.Rows]; if (rows.IsMatch) { return FrameType.Row; } MatchResult range = result.Matches[SqlGrammar.FrameType.Range]; if (range.IsMatch) { return FrameType.Range; } throw new InvalidOperationException(); }
private FilteredJoin buildFilteredJoin(MatchResult result, Join join, IRightJoinItem joinItem, string alias) { MatchResult innerResult = result.Matches[SqlGrammar.FilteredJoinType.InnerJoin]; if (innerResult.IsMatch) { return join.InnerJoin(joinItem, alias); } MatchResult leftResult = result.Matches[SqlGrammar.FilteredJoinType.LeftOuterJoin]; if (leftResult.IsMatch) { return join.LeftOuterJoin(joinItem, alias); } MatchResult rightResult = result.Matches[SqlGrammar.FilteredJoinType.RightOuterJoin]; if (rightResult.IsMatch) { return join.RightOuterJoin(joinItem, alias); } MatchResult fullResult = result.Matches[SqlGrammar.FilteredJoinType.FullOuterJoin]; if (fullResult.IsMatch) { return join.FullOuterJoin(joinItem, alias); } throw new InvalidOperationException(); }
private IFilter buildFilter(MatchResult result) { MatchResult notResult = result.Matches[SqlGrammar.Filter.Not.Name]; if (notResult.IsMatch) { MatchResult filterResult = notResult.Matches[SqlGrammar.Filter.Not.Filter]; IFilter filter = buildFilter(filterResult); return new NotFilter(filter); } MatchResult wrappedResult = result.Matches[SqlGrammar.Filter.Wrapped.Name]; if (wrappedResult.IsMatch) { MatchResult filterResult = wrappedResult.Matches[SqlGrammar.Filter.Wrapped.Filter]; FilterGroup nested = new FilterGroup(); IFilter innerFilter = buildOrFilter(filterResult); nested.AddFilter(innerFilter); nested.WrapInParentheses = true; return nested; } MatchResult quantifyResult = result.Matches[SqlGrammar.Filter.Quantify.Name]; if (quantifyResult.IsMatch) { MatchResult expressionResult = quantifyResult.Matches[SqlGrammar.Filter.Quantify.Expression]; IFilterItem filterItem = (IFilterItem)buildArithmeticItem(expressionResult); MatchResult quantifierResult = quantifyResult.Matches[SqlGrammar.Filter.Quantify.Quantifier]; Quantifier quantifier = buildQuantifier(quantifierResult); IValueProvider valueProvider = null; MatchResult selectResult = quantifyResult.Matches[SqlGrammar.Filter.Quantify.SelectStatement]; if (selectResult.IsMatch) { valueProvider = buildSelectStatement(selectResult); } MatchResult valueListResult = quantifyResult.Matches[SqlGrammar.Filter.Quantify.ValueList]; if (valueListResult.IsMatch) { ValueList values = new ValueList(); buildValueList(valueListResult, values); valueProvider = values; } MatchResult operatorResult = quantifyResult.Matches[SqlGrammar.Filter.Quantify.ComparisonOperator]; return buildQuantifierFilter(operatorResult, filterItem, quantifier, valueProvider); } MatchResult functionResult = result.Matches[SqlGrammar.Filter.Function.Name]; if (functionResult.IsMatch) { MatchResult expressionResult = functionResult.Matches[SqlGrammar.Filter.Function.Expression]; return buildFunctionCall(expressionResult); } MatchResult orderResult = result.Matches[SqlGrammar.Filter.Order.Name]; if (orderResult.IsMatch) { MatchResult leftResult = orderResult.Matches[SqlGrammar.Filter.Order.Left]; IFilterItem left = (IFilterItem)buildArithmeticItem(leftResult); MatchResult rightResult = orderResult.Matches[SqlGrammar.Filter.Order.Right]; IFilterItem right = (IFilterItem)buildArithmeticItem(rightResult); MatchResult operatorResult = orderResult.Matches[SqlGrammar.Filter.Order.ComparisonOperator]; return buildOrderFilter(operatorResult, left, right); } MatchResult betweenResult = result.Matches[SqlGrammar.Filter.Between.Name]; if (betweenResult.IsMatch) { MatchResult expressionResult = betweenResult.Matches[SqlGrammar.Filter.Between.Expression]; IFilterItem expression = (IFilterItem)buildArithmeticItem(expressionResult); MatchResult lowerBoundResult = betweenResult.Matches[SqlGrammar.Filter.Between.LowerBound]; IFilterItem lowerBound = (IFilterItem)buildArithmeticItem(lowerBoundResult); MatchResult upperBoundResult = betweenResult.Matches[SqlGrammar.Filter.Between.UpperBound]; IFilterItem upperBound = (IFilterItem)buildArithmeticItem(upperBoundResult); BetweenFilter filter = new BetweenFilter(expression, lowerBound, upperBound); MatchResult betweenNotResult = betweenResult.Matches[SqlGrammar.Filter.Between.NotKeyword]; filter.Not = betweenNotResult.IsMatch; return filter; } MatchResult likeResult = result.Matches[SqlGrammar.Filter.Like.Name]; if (likeResult.IsMatch) { MatchResult leftResult = likeResult.Matches[SqlGrammar.Filter.Like.Left]; IFilterItem left = (IFilterItem)buildArithmeticItem(leftResult); MatchResult rightResult = likeResult.Matches[SqlGrammar.Filter.Like.Right]; IFilterItem right = (IFilterItem)buildArithmeticItem(rightResult); LikeFilter filter = new LikeFilter(left, right); MatchResult likeNotResult = likeResult.Matches[SqlGrammar.Filter.Like.NotKeyword]; filter.Not = likeNotResult.IsMatch; return filter; } MatchResult isResult = result.Matches[SqlGrammar.Filter.Is.Name]; if (isResult.IsMatch) { MatchResult expressionResult = isResult.Matches[SqlGrammar.Filter.Is.Expression]; IFilterItem expression = (IFilterItem)buildArithmeticItem(expressionResult); NullFilter filter = new NullFilter(expression); MatchResult isNotResult = isResult.Matches[SqlGrammar.Filter.Is.NotKeyword]; filter.Not = isNotResult.IsMatch; return filter; } MatchResult inResult = result.Matches[SqlGrammar.Filter.In.Name]; if (inResult.IsMatch) { MatchResult expressionResult = inResult.Matches[SqlGrammar.Filter.In.Expression]; IFilterItem expression = (IFilterItem)buildArithmeticItem(expressionResult); IValueProvider valueProvider = null; MatchResult valuesResult = inResult.Matches[SqlGrammar.Filter.In.Values.Name]; if (valuesResult.IsMatch) { MatchResult valueListResult = valuesResult.Matches[SqlGrammar.Filter.In.Values.ValueList]; ValueList values = new ValueList(); buildValueList(valueListResult, values); valueProvider = values; } MatchResult selectResult = inResult.Matches[SqlGrammar.Filter.In.Select.Name]; if (selectResult.IsMatch) { MatchResult selectStatementResult = selectResult.Matches[SqlGrammar.Filter.In.Select.SelectStatement]; valueProvider = buildSelectStatement(selectStatementResult); } MatchResult functionCall = inResult.Matches[SqlGrammar.Filter.In.FunctionCall]; if (functionCall.IsMatch) { valueProvider = buildFunctionCall(functionCall); } InFilter filter = new InFilter(expression, valueProvider); MatchResult inNotResult = inResult.Matches[SqlGrammar.Filter.In.NotKeyword]; filter.Not = inNotResult.IsMatch; return filter; } MatchResult existsResult = result.Matches[SqlGrammar.Filter.Exists.Name]; if (existsResult.IsMatch) { MatchResult selectExpressionResult = existsResult.Matches[SqlGrammar.Filter.Exists.SelectStatement]; ISelectBuilder builder = buildSelectStatement(selectExpressionResult); ExistsFilter filter = new ExistsFilter(builder); return filter; } throw new InvalidOperationException(); }
private DistinctQualifier buildDistinctQualifier(MatchResult result) { DistinctQualifierConverter converter = new DistinctQualifierConverter(); MatchResult distinct = result.Matches[SqlGrammar.DistinctQualifier.Distinct]; if (distinct.IsMatch) { return DistinctQualifier.Distinct; } MatchResult all = result.Matches[SqlGrammar.DistinctQualifier.All]; if (all.IsMatch) { return DistinctQualifier.All; } throw new InvalidOperationException(); }
private MatchCase buildMatchCase(MatchResult result) { MatchResult expressionResult = result.Matches[SqlGrammar.MatchCase.Expression]; IProjectionItem expression = (IProjectionItem)buildArithmeticItem(expressionResult); MatchCase options = new MatchCase(expression); MatchResult matchListResult = result.Matches[SqlGrammar.MatchCase.MatchList]; buildMatchList(matchListResult, options); return options; }
private void buildGroupByList(MatchResult result, SelectBuilder builder) { MatchResult multiple = result.Matches[SqlGrammar.GroupByList.Multiple.Name]; if (multiple.IsMatch) { MatchResult firstResult = multiple.Matches[SqlGrammar.GroupByList.Multiple.First]; IGroupByItem first = (IGroupByItem)buildArithmeticItem(firstResult); builder.AddGroupBy(first); MatchResult remainingResult = multiple.Matches[SqlGrammar.GroupByList.Multiple.Remaining]; buildGroupByList(remainingResult, builder); return; } MatchResult single = result.Matches[SqlGrammar.GroupByList.Single]; if (single.IsMatch) { IGroupByItem item = (IGroupByItem)buildArithmeticItem(single); builder.AddGroupBy(item); return; } throw new InvalidOperationException(); }
private void buildMatchList(MatchResult result, MatchCase options) { MatchResult match = result.Matches[SqlGrammar.MatchList.Match]; buildMatch(match, options); MatchResult matchListPrime = result.Matches[SqlGrammar.MatchList.MatchListPrime]; buildMatchListPrime(matchListPrime, options); }
private ICommand buildInsertStatement(MatchResult result) { MatchResult tableResult = result.Matches[SqlGrammar.InsertStatement.Table]; Table table = buildTable(tableResult); IValueProvider valueProvider = null; MatchResult valuesResult = result.Matches[SqlGrammar.InsertStatement.Values.Name]; if (valuesResult.IsMatch) { ValueList values = new ValueList(); MatchResult valueListResult = valuesResult.Matches[SqlGrammar.InsertStatement.Values.ValueList]; if (valueListResult.IsMatch) { buildValueList(valueListResult, values); } valueProvider = values; } MatchResult selectResult = result.Matches[SqlGrammar.InsertStatement.Select.Name]; if (selectResult.IsMatch) { MatchResult selectStatementResult = selectResult.Matches[SqlGrammar.InsertStatement.Select.SelectStatement]; ISelectBuilder selectBuilder = buildSelectStatement(selectStatementResult); valueProvider = selectBuilder; } string alias = null; MatchResult aliasExpressionResult = result.Matches[SqlGrammar.InsertStatement.AliasExpression.Name]; if (aliasExpressionResult.IsMatch) { MatchResult aliasResult = aliasExpressionResult.Matches[SqlGrammar.InsertStatement.AliasExpression.Alias]; alias = getToken(aliasResult); } InsertBuilder builder = new InsertBuilder(table, valueProvider, alias); SourceCollection collection = new SourceCollection(); collection.AddSource(builder.Table.GetSourceName(), builder.Table); scope.Push(collection); MatchResult columnsResult = result.Matches[SqlGrammar.InsertStatement.Columns.Name]; if (columnsResult.IsMatch) { MatchResult columnListResult = columnsResult.Matches[SqlGrammar.InsertStatement.Columns.ColumnList]; buildColumnsList(columnListResult, builder); } scope.Pop(); return builder; }
private void buildMultipartIdentifier(MatchResult result, List<string> parts) { MatchResult multiple = result.Matches[SqlGrammar.MultipartIdentifier.Multiple.Name]; if (multiple.IsMatch) { MatchResult first = multiple.Matches[SqlGrammar.MultipartIdentifier.Multiple.First]; parts.Add(getToken(first)); MatchResult remaining = multiple.Matches[SqlGrammar.MultipartIdentifier.Multiple.Remaining]; buildMultipartIdentifier(remaining, parts); return; } MatchResult single = result.Matches[SqlGrammar.MultipartIdentifier.Single]; if (single.IsMatch) { parts.Add(getToken(single)); return; } throw new InvalidOperationException(); }
private object buildItem(MatchResult result) { MatchResult numberResult = result.Matches[SqlGrammar.Item.Number]; if (numberResult.IsMatch) { return buildNumericLiteral(numberResult); } MatchResult stringResult = result.Matches[SqlGrammar.Item.String]; if (stringResult.IsMatch) { return buildStringLiteral(stringResult); } MatchResult nullResult = result.Matches[SqlGrammar.Item.Null]; if (nullResult.IsMatch) { return new NullLiteral(); } MatchResult functionCallResult = result.Matches[SqlGrammar.Item.FunctionCall]; if (functionCallResult.IsMatch) { return buildFunctionCall(functionCallResult); } MatchResult columnResult = result.Matches[SqlGrammar.Item.Column]; if (columnResult.IsMatch) { return buildNamedItem(columnResult); } MatchResult matchCaseResult = result.Matches[SqlGrammar.Item.MatchCase]; if (matchCaseResult.IsMatch) { return buildMatchCase(matchCaseResult); } MatchResult conditionCaseResult = result.Matches[SqlGrammar.Item.ConditionCase]; if (conditionCaseResult.IsMatch) { return buildConditionalCase(conditionCaseResult); } MatchResult selectResult = result.Matches[SqlGrammar.Item.Select.Name]; if (selectResult.IsMatch) { MatchResult selectExpressionResult = selectResult.Matches[SqlGrammar.Item.Select.SelectStatement]; return buildSelectStatement(selectExpressionResult); } throw new NotImplementedException(); }
private object buildAdditiveExpression(MatchResult result, bool wrap) { MatchResult multiple = result.Matches[SqlGrammar.AdditiveExpression.Multiple.Name]; if (multiple.IsMatch) { MatchResult firstResult = multiple.Matches[SqlGrammar.AdditiveExpression.Multiple.First]; IProjectionItem first = (IProjectionItem)buildMultiplicitiveExpression(firstResult, false); MatchResult remainingResult = multiple.Matches[SqlGrammar.AdditiveExpression.Multiple.Remaining]; IProjectionItem remaining = (IProjectionItem)buildAdditiveExpression(remainingResult, false); MatchResult operatorResult = multiple.Matches[SqlGrammar.AdditiveExpression.Multiple.Operator]; return buildAdditiveOperator(operatorResult, first, remaining, wrap); } MatchResult single = result.Matches[SqlGrammar.AdditiveExpression.Single]; if (single.IsMatch) { return buildMultiplicitiveExpression(single, wrap); } throw new InvalidOperationException(); }
private Join buildJoin(MatchResult result, bool wrap) { MatchResult wrapped = result.Matches[SqlGrammar.Join.Wrapped.Name]; if (wrapped.IsMatch) { MatchResult joinResult = wrapped.Matches[SqlGrammar.Join.Wrapped.Join]; Join first = buildJoin(joinResult, true); first.WrapInParentheses = true; scope.Push(first.Sources); MatchResult joinPrime = wrapped.Matches[SqlGrammar.Join.Wrapped.JoinPrime]; Join join = buildJoinPrime(joinPrime, first); scope.Pop(); return join; } MatchResult joined = result.Matches[SqlGrammar.Join.Joined.Name]; if (joined.IsMatch) { string alias; MatchResult joinItemResult = joined.Matches[SqlGrammar.Join.Joined.JoinItem]; IRightJoinItem first = buildJoinItem(joinItemResult, out alias); Join start = Join.From(first, alias); scope.Push(start.Sources); MatchResult joinPrime = joined.Matches[SqlGrammar.Join.Joined.JoinPrime]; Join join = buildJoinPrime(joinPrime, start); scope.Pop(); return join; } throw new InvalidOperationException(); }
private NullPlacement buildNullPlacement(MatchResult result) { MatchResult nullsFirst = result.Matches[SqlGrammar.NullPlacement.NullsFirst]; if (nullsFirst.IsMatch) { return NullPlacement.First; } MatchResult nullsLast = result.Matches[SqlGrammar.NullPlacement.NullsLast]; if (nullsLast.IsMatch) { return NullPlacement.Last; } throw new InvalidOperationException(); }
private ConditionalCase buildConditionalCase(MatchResult result) { ConditionalCase options = new ConditionalCase(); MatchResult conditionListResult = result.Matches[SqlGrammar.ConditionalCase.ConditionList]; buildConditionList(conditionListResult, options); return options; }
private void buildOrderByItem(MatchResult result, List<OrderBy> orderByList) { MatchResult expressionResult = result.Matches[SqlGrammar.OrderByItem.Expression]; IProjectionItem expression = (IProjectionItem)buildArithmeticItem(expressionResult); Order order = Order.Default; MatchResult directionResult = result.Matches[SqlGrammar.OrderByItem.OrderDirection]; if (directionResult.IsMatch) { order = buildOrderDirection(directionResult); } NullPlacement placement = NullPlacement.Default; MatchResult placementResult = result.Matches[SqlGrammar.OrderByItem.NullPlacement]; if (placementResult.IsMatch) { placement = buildNullPlacement(placementResult); } OrderBy orderBy = new OrderBy(expression, order, placement); orderByList.Add(orderBy); }
private Join buildJoinPrime(MatchResult result, Join join) { MatchResult filtered = result.Matches[SqlGrammar.JoinPrime.Filtered.Name]; if (filtered.IsMatch) { MatchResult joinItemResult = filtered.Matches[SqlGrammar.JoinPrime.Filtered.JoinItem]; string alias; IRightJoinItem joinItem = buildJoinItem(joinItemResult, out alias); MatchResult joinTypeResult = filtered.Matches[SqlGrammar.JoinPrime.Filtered.JoinType]; FilteredJoin filteredJoin = buildFilteredJoin(joinTypeResult, join, joinItem, alias); scope.Push(filteredJoin.Sources); MatchResult onResult = filtered.Matches[SqlGrammar.JoinPrime.Filtered.On.Name]; MatchResult filterListResult = onResult.Matches[SqlGrammar.JoinPrime.Filtered.On.FilterList]; IFilter innerFilter = buildOrFilter(filterListResult); filteredJoin.OnFilterGroup.AddFilter(innerFilter); filteredJoin.OnFilterGroup.Optimize(); MatchResult joinPrimeResult = filtered.Matches[SqlGrammar.JoinPrime.Filtered.JoinPrime]; Join prime = buildJoinPrime(joinPrimeResult, filteredJoin); scope.Pop(); return prime; } MatchResult cross = result.Matches[SqlGrammar.JoinPrime.Cross.Name]; if (cross.IsMatch) { MatchResult joinItemResult = cross.Matches[SqlGrammar.JoinPrime.Cross.JoinItem]; string alias; IRightJoinItem joinItem = buildJoinItem(joinItemResult, out alias); Join crossJoin = join.CrossJoin(joinItem, alias); scope.Push(crossJoin.Sources); MatchResult joinPrimeResult = cross.Matches[SqlGrammar.JoinPrime.Cross.JoinPrime]; Join prime = buildJoinPrime(joinPrimeResult, crossJoin); scope.Pop(); return prime; } MatchResult empty = result.Matches[SqlGrammar.JoinPrime.Empty]; if (empty.IsMatch) { return join; } throw new InvalidOperationException(); }
private IRightJoinItem buildJoinItem(MatchResult result, out string alias) { alias = null; MatchResult aliasExpression = result.Matches[SqlGrammar.JoinItem.AliasExpression.Name]; if (aliasExpression.IsMatch) { MatchResult aliasResult = aliasExpression.Matches[SqlGrammar.JoinItem.AliasExpression.Alias]; alias = getToken(aliasResult); } MatchResult tableResult = result.Matches[SqlGrammar.JoinItem.Table]; if (tableResult.IsMatch) { Table table = buildTable(tableResult); return table; } MatchResult select = result.Matches[SqlGrammar.JoinItem.Select.Name]; if (select.IsMatch) { MatchResult selectStatement = select.Matches[SqlGrammar.JoinItem.Select.SelectStatement]; return buildSelectStatement(selectStatement); } MatchResult functionCall = result.Matches[SqlGrammar.JoinItem.FunctionCall]; if (functionCall.IsMatch) { return buildFunctionCall(functionCall); } throw new InvalidOperationException(); }
private void buildConditionList(MatchResult result, ConditionalCase options) { MatchResult condition = result.Matches[SqlGrammar.ConditionList.Condition]; buildCondition(condition, options); MatchResult conditionListPrime = result.Matches[SqlGrammar.ConditionList.ConditionListPrime]; buildConditionListPrime(conditionListPrime, options); }