protected SqlQueryWriter(IFragmentBuilder parent, IQueryGraphBuilder graph, IDatabase database, IQueryGraphVisitor visitor, ICollection <IDatabaseQueryParameter> parameters)
: this(parent, graph)
{
this.Database = database;
this.Visitor = visitor;
this.Parameters = parameters;
}
protected virtual bool TryCapture <T>(IFragmentBuilder parent, Expression node, out T result, out CaptureFragmentContext context) where T : IFragmentBuilder
{
context = new CaptureFragmentContext(parent, this.Query.Clone());
var capture = new CaptureFragmentTarget(context);
this.Push(capture);
try
{
this.Visit(node);
}
finally
{
this.Pop(false);
}
foreach (var expression in context.Expressions)
{
if (expression is T)
{
result = (T)expression;
return(true);
}
}
result = default(T);
return(false);
}
public CommonTableExpressionBuilder(IFragmentBuilder parent, IQueryGraphBuilder graph)
: base(parent, graph)
{
this.Expressions = new List <IFragmentBuilder>();
this.Constants = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
this.ColumnNames = new List <string>();
}
public SqlRuleVisitor(IRuleVisitorBuilder ruleVisitorBuilder, IRuleExceptionFinder ruleExceptionFinder, IFragmentBuilder fragmentBuilder, IReporter reporter)
{
this.fragmentBuilder = fragmentBuilder;
this.reporter = reporter;
this.ruleExceptionFinder = ruleExceptionFinder;
this.ruleVisitorBuilder = ruleVisitorBuilder;
}
protected override void VisitSource(IFragmentBuilder parent, IQueryGraphBuilder graph, ISourceBuilder expression)
{
var filter = graph.Fragment <IFilterBuilder>();
if (!filter.Offset.HasValue)
{
return;
}
var table = expression.Tables.FirstOrDefault();
graph.Source.Expressions.Clear();
graph.Source.AddSubQuery(
this.Database.QueryFactory.Build().With(subquery =>
{
subquery.Output.AddOperator(QueryOperator.Star);
subquery.Output.AddWindowFunction(
SqlServerWindowFunction.RowNumber,
subquery.Output.CreateSubQuery(
this.Database.QueryFactory.Build().With(
over => over.Sort.AddColumns(table.Table.PrimaryKeys)
)
)
).Alias = string.Format(
"{0}_RowNumber",
filter.Id
);
subquery.Source.AddTable(table.Table);
})
).Alias = table.Table.TableName;
}
protected override void VisitSort(IFragmentBuilder parent, IQueryGraphBuilder graph, ISortBuilder expression)
{
if (expression.Expressions.Any())
{
return;
}
var filter = graph.Fragment <IFilterBuilder>();
if (!filter.Limit.HasValue && !filter.Offset.HasValue)
{
return;
}
var table = graph.Source.Tables.FirstOrDefault();
if (table == null)
{
throw new NotImplementedException();
}
var sort = graph.Parent.Fragment <ISortBuilder>();
if (sort != null)
{
expression.Expressions.AddRange(sort.GetColumns(table.Table));
}
if (expression.IsEmpty())
{
expression.AddColumns(table.Table.PrimaryKeys);
}
}
protected override void VisitFilter(IFragmentBuilder parent, IQueryGraphBuilder graph, IFilterBuilder expression)
{
if (!expression.Offset.HasValue)
{
return;
}
var offset = expression.Offset.Value + 1;
expression.Add().With(filter =>
{
filter.Left = filter.CreateIdentifier(
string.Format(
"{0}_RowNumber",
expression.Id
)
);
if (expression.Limit.HasValue)
{
var limit = expression.Limit.Value - 1;
filter.Operator = filter.CreateOperator(QueryOperator.Between);
filter.Right = filter.CreateBinary(
filter.CreateConstant(offset),
filter.CreateOperator(QueryOperator.AndAlso),
filter.CreateConstant(offset + limit)
);
}
else
{
filter.Operator = filter.CreateOperator(QueryOperator.GreaterOrEqual);
filter.Right = filter.CreateConstant(offset);
}
});
}
public SqlRuleVisitor(IRuleVisitorBuilder ruleVisitorBuilder, IFragmentBuilder fragmentBuilder, IReporter reporter, ISqlStreamReaderBuilder sqlStreamReaderBuilder)
{
this.fragmentBuilder = fragmentBuilder;
this.reporter = reporter;
this.ruleVisitorBuilder = ruleVisitorBuilder;
this.sqlStreamReaderBuilder = sqlStreamReaderBuilder;
}
protected override void VisitSort(IFragmentBuilder parent, IQueryGraphBuilder graph, ISortBuilder expression)
{
if (EnsureOrderBy.Predicate(parent, graph, expression))
{
new EnsureOrderBy(this.Database).Visit(parent, graph, expression);
}
base.VisitSort(parent, graph, expression);
}
public ICaseConditionBuilder CreateCaseCondition(IFragmentBuilder condition, IFragmentBuilder result)
{
return(this.Fragment <ICaseConditionBuilder>().With(builder =>
{
builder.Condition = condition;
builder.Result = result;
}));
}
public IUnaryExpressionBuilder CreateUnary(IOperatorBuilder @operator, IFragmentBuilder expression)
{
return(this.Fragment <IUnaryExpressionBuilder>().With(builder =>
{
builder.Operator = @operator;
builder.Expression = expression;
}));
}
public IBinaryExpressionBuilder CreateBinary(IFragmentBuilder left, IOperatorBuilder @operator, IFragmentBuilder right)
{
return(this.Fragment <IBinaryExpressionBuilder>().With(builder =>
{
builder.Left = left;
builder.Operator = @operator;
builder.Right = right;
}));
}
public TableBuilder(IFragmentBuilder parent, IQueryGraphBuilder graph)
: base(parent, graph)
{
this.Expressions = new List <IFragmentBuilder>();
this.Constants = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
this.Filter = this.Fragment <IFilterBuilder>();
this.Sort = this.Fragment <ISortBuilder>();
this.LockHints = LockHints.None;
}
public ICaseConditionBuilder Add(IFragmentBuilder condition, IFragmentBuilder result)
{
var expression = this.Fragment <ICaseConditionBuilder>();
expression.Condition = condition;
expression.Result = result;
this.Expressions.Add(expression);
return(expression);
}
protected override void VisitFilter(IFragmentBuilder parent, IQueryGraphBuilder graph, IFilterBuilder expression)
{
if (expression.Limit.HasValue || !expression.Offset.HasValue)
{
return;
}
//This is enforcing a LIMIT when the syntax requires it.
//The value -1 actually gets "unsigned" making it a very large number.
expression.Limit = -1;
}
public virtual void Visit(IFragmentBuilder parent, IQueryGraphBuilder graph, IFragmentBuilder fragment)
{
var handler = default(QueryGraphVisitorHandler);
if (!Handlers.TryGetValue(fragment.FragmentType, out handler))
{
throw new NotImplementedException();
}
handler(this, parent, graph, fragment);
}
protected virtual T Capture <T>(IFragmentBuilder parent, Expression node, out CaptureFragmentContext context) where T : IFragmentBuilder
{
var expression = default(T);
if (!this.TryCapture <T>(parent, node, out expression, out context))
{
throw new InvalidOperationException(string.Format("Failed to capture fragment of type \"{0}\".", typeof(T).FullName));
}
return(expression);
}
public static bool IsEmpty(this IFragmentBuilder builder)
{
if (builder is IFragmentContainer)
{
return(!(builder as IFragmentContainer).Expressions.Any(expression => expression != null));
}
else
{
return(false);
}
}
public virtual bool Equals(IFragmentBuilder other)
{
if (other == null)
{
return(false);
}
if (this.FragmentType != other.FragmentType)
{
return(false);
}
return(true);
}
protected virtual bool TryCapture <T>(IFragmentBuilder parent, Expression node, out T result) where T : IFragmentBuilder
{
var context = default(CaptureFragmentContext);
if (!this.TryCapture <T>(parent, node, out result, out context))
{
return(false);
}
if (context.Constants.Any())
{
throw new InvalidOperationException("Capture resulted in unhandled constants.");
}
return(true);
}
public override bool Equals(IFragmentBuilder obj)
{
var other = obj as ITableBuilder;
if (other == null || !base.Equals(obj))
{
return(false);
}
if ((TableConfig)this.Table != (TableConfig)other.Table)
{
return(false);
}
return(true);
}
public override bool Equals(IFragmentBuilder obj)
{
var other = obj as IIdentifierBuilder;
if (other == null || !base.Equals(obj))
{
return(false);
}
if (!string.Equals(this.Identifier, other.Identifier, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
return(true);
}
public override bool Equals(IFragmentBuilder obj)
{
var other = obj as IIndexBuilder;
if (other == null || !base.Equals(obj))
{
return(false);
}
if (this.Index != other.Index)
{
return(false);
}
return(true);
}
public T Write <T>(T fragment) where T : IFragmentBuilder
{
if (this.Condition == null)
{
this.Condition = fragment;
return(fragment);
}
else if (this.Result == null)
{
this.Result = fragment;
return(fragment);
}
throw new NotImplementedException();
}
public override bool Equals(IFragmentBuilder obj)
{
var other = obj as IUnaryExpressionBuilder;
if (other == null || !base.Equals(obj))
{
return(false);
}
if (this.Operator != other.Operator || this.Expression != other.Expression)
{
return(false);
}
return(true);
}
public override bool Equals(IFragmentBuilder obj)
{
var other = obj as IColumnBuilder;
if (other == null || !base.Equals(obj))
{
return(false);
}
if (this.Column != other.Column)
{
return(false);
}
return(true);
}
protected override void VisitOutput(IFragmentBuilder parent, IQueryGraphBuilder graph, IOutputBuilder expression)
{
var sequence = GetExpressions(expression).ToArray();
foreach (var element in sequence)
{
expression.Expressions.Remove(element);
expression.AddCase(
expression.CreateCaseCondition(
element, expression.CreateConstant(1)
),
expression.CreateCaseCondition(expression.CreateConstant(0))
).Alias = element.Alias;
}
}
public T Write <T>(T fragment) where T : IFragmentBuilder
{
if (this.Operator == null)
{
if (fragment is IOperatorBuilder)
{
this.Operator = fragment as IOperatorBuilder;
return(fragment);
}
}
else if (this.Expression == null)
{
this.Expression = fragment;
return(fragment);
}
throw new NotImplementedException();
}
protected SqlQueryWriter(IFragmentBuilder parent, IQueryGraphBuilder graph)
: base(parent, graph)
{
if (parent is ISqlQueryWriter)
{
this.FragmentContext = new Stack <IFragmentBuilder>((parent as ISqlQueryWriter).FragmentContext);
this.RenderContext = new Stack <RenderHints>((parent as ISqlQueryWriter).RenderContext);
}
else
{
this.FragmentContext = new Stack <IFragmentBuilder>();
this.RenderContext = new Stack <RenderHints>();
}
this.Builder = new StringBuilder();
this.Handlers = this.GetHandlers();
this.Operators = this.GetOperators();
this.Functions = this.GetFunctions();
this.WindowFunctions = this.GetWindowFunctions();
}
public static bool GetSourceTable(this IFragmentBuilder builder, out ITableBuilder table)
{
var column = builder as IColumnBuilder;
var container = builder as IFragmentContainer;
if (column != null)
{
table = builder.Graph.Source.GetTable(column.Column.Table);
}
else if (container != null)
{
table = container.GetTables().Select(builder.Graph.Source.GetTable).FirstOrDefault();
}
else
{
table = default(ITableBuilder);
return(false);
}
return(table != null);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActiveViewMapperBehavior"/> class.
/// </summary>
/// <param name="navigatioBar">Navigation bar.</param>
/// <param name="fragmentBuilder">The fragment builder.</param>
public ActiveViewMapperBehavior(INavigationBar navigatioBar, IFragmentBuilder fragmentBuilder)
{
_navigatioBar = navigatioBar;
_fragmentBuilder = fragmentBuilder;
}
