public ICommonTableExpressionBuilder AddCommonTableExpression(IQueryGraphBuilder query)
{
var builder = this.CreateCommonTableExpression(query);
this.Expressions.Add(builder);
return(builder);
}
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 virtual void Visit(IQueryGraphBuilder graph)
{
foreach (var fragment in graph.Fragments)
{
this.Visit(fragment.Parent, graph, fragment);
}
}
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);
}
}
public ISubQueryBuilder AddSubQuery(IQueryGraphBuilder query)
{
var builder = this.CreateSubQuery(query);
this.Expressions.Add(builder);
return(builder);
}
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);
}
});
}
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 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;
}
public void Reset()
{
this.Fetch = this.Composer.Fetch;
this.Add = this.Composer.Add;
this.Update = this.Composer.Update;
this.Delete = this.Composer.Delete;
this.Parameters = this.OriginalParameters;
}
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 EnumerableVisitor(IDatabaseSetQuery provider, IDatabase database, IQueryGraphBuilder query, Type elementType)
: this()
{
this.Provider = provider;
this.Database = database;
this.Query = query;
this.ElementType = elementType;
}
public virtual IQueryGraphBuilder Count(IQueryGraphBuilder query)
{
var builder = this.Build();
builder.Output.AddFunction(QueryFunction.Count, builder.Output.CreateOperator(QueryOperator.Star));
builder.Source.AddSubQuery(query);
return(builder);
}
public IDatabaseQuery Create(IQueryGraphBuilder graph)
{
if (graph is AggregateQueryGraphBuilder)
{
return(this.Create((graph as AggregateQueryGraphBuilder).Queries));
}
return(this.CreateBuilder(this.Database, graph).Query);
}
private static IEnumerable <ITableConfig> GetTables(IQueryGraphBuilder graph)
{
return(graph.Fragments
.OfType <ISourceBuilder>()
.SelectMany(
source => source.Tables.Select(table => table.Table)
));
}
public ISubQueryBuilder CreateSubQuery(IQueryGraphBuilder query)
{
if (query == null)
{
throw new NotImplementedException();
}
return(this.Fragment <ISubQueryBuilder>().With(builder => builder.Query = query));
}
public ICommonTableExpressionBuilder GetCommonTableExpression(IQueryGraphBuilder query)
{
return(this.GetExpression <ICommonTableExpressionBuilder>(
builder => Enumerable.SequenceEqual(
builder.SubQueries.Select(subQuery => subQuery.Query),
new[] { query }
)
));
}
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 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 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 override IQueryGraphBuilder Count(ITableConfig table, IQueryGraphBuilder query)
{
var builder = this.Build();
builder.Output.AddFunction(
QueryFunction.Count,
builder.Output.CreateColumn(table.PrimaryKey).With(
column => column.Flags = ColumnBuilderFlags.Identifier | ColumnBuilderFlags.Distinct
)
);
builder.Source.AddSubQuery(query).With(
subQuery => subQuery.Alias = table.TableName
);
return(builder);
}
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;
}
}
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 override IQueryGraphBuilder Count(ITableConfig table, IQueryGraphBuilder query)
{
var builder = this.Build();
builder.Output.AddFunction(
QueryFunction.Count,
builder.Output.CreateOperator(QueryOperator.Star)
);
builder.Source.AddSubQuery(
query.Clone().With(subQuery =>
{
subQuery.Output.Expressions.Clear();
subQuery.Output.AddColumn(table.PrimaryKey);
subQuery.Aggregate.AddColumn(table.PrimaryKey);
subQuery.Sort.Expressions.Clear();
})
).Alias = table.TableName;
return(builder);
}
protected override void VisitSort(IFragmentBuilder parent, IQueryGraphBuilder graph, ISortBuilder expression)
{
throw new NotImplementedException();
}
protected override IQueryBuilder CreateBuilder(IDatabase database, IQueryGraphBuilder graph)
{
return(new SQLiteQueryBuilder(database, graph));
}
public SubQueryBuilder(IFragmentBuilder parent, IQueryGraphBuilder graph)
: base(parent, graph)
{
}
public ParameterBuilder(IFragmentBuilder parent, IQueryGraphBuilder graph)
: base(parent, graph)
{
}
public RelationManager(IQueryGraphBuilder graph)
{
this.Calculator = new EntityRelationCalculator(GetTables(graph));
}
protected abstract IQueryBuilder CreateBuilder(IDatabase database, IQueryGraphBuilder graph);
public abstract IQueryGraphBuilder Count(ITableConfig table, IQueryGraphBuilder query);
