public static string WriteToString(QueryLanguage language, Expression expression)
{
StringWriter writer = new StringWriter();
Write(writer, language, expression);
return(writer.ToString());
}
private SqlFormatter(QueryLanguage language, bool forDebug)
{
this.indent = 2;
this.language = language;
this.sb = new StringBuilder();
this.aliases = new Dictionary <TableAlias, string>();
this.forDebug = forDebug;
}
public static SelectExpression AddRedundantSelect(this SelectExpression sel, QueryLanguage language, TableAlias newAlias)
{
IEnumerable <ColumnDeclaration> columns = from d in sel.Columns
let qt = (d.Expression is ColumnExpression) ? ((IEnumerable <ColumnDeclaration>)((ColumnExpression)d.Expression).QueryType) : ((IEnumerable <ColumnDeclaration>)language.TypeSystem.GetColumnType(d.Expression.Type))
select new ColumnDeclaration(d.Name, new ColumnExpression(d.Expression.Type, qt as QueryType, newAlias, d.Name), qt as QueryType);
return(new SelectExpression(sel.Alias, columns, new SelectExpression(newAlias, sel.Columns, sel.From, sel.Where, sel.OrderBy, sel.GroupBy, sel.IsDistinct, sel.Skip, sel.Take, sel.IsReverse), null, null, null, false, null, null, false));
}
private ColumnProjector(QueryLanguage language, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, IEnumerable <TableAlias> existingAliases)
{
this.language = language;
this.newAlias = newAlias;
this.existingAliases = new HashSet <TableAlias>(existingAliases);
this.map = new Dictionary <ColumnExpression, ColumnExpression>();
if (existingColumns != null)
{
this.columns = new List <ColumnDeclaration>(existingColumns);
this.columnNames = new HashSet <string>(from c in existingColumns select c.Name);
}
else
{
this.columns = new List <ColumnDeclaration>();
this.columnNames = new HashSet <string>();
}
this.candidates = Nominator.Nominate(language, expression);
}
private Nominator(QueryLanguage language)
{
this.language = language;
this.candidates = new HashSet <Expression>();
this.isBlocked = false;
}
private Parameterizer(QueryLanguage language)
{
this.language = language;
}
private OrderByRewriter(QueryLanguage language)
{
this.language = language;
this.isOuterMostSelect = true;
}
private SkipToNestedOrderByRewriter(QueryLanguage language)
{
this.language = language;
}
protected SqlFormatter(QueryLanguage language) : this(language, false)
{
}
private AggregateRewriter(QueryLanguage language, Expression expr)
{
this.language = language;
this.map = new Dictionary <AggregateSubqueryExpression, Expression>();
this.lookup = AggregateGatherer.Gather(expr).ToLookup <AggregateSubqueryExpression, TableAlias>(a => a.GroupByAlias);
}
public static ProjectedColumns ProjectColumns(QueryLanguage language, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, IEnumerable <TableAlias> existingAliases)
{
ColumnProjector projector = new ColumnProjector(language, expression, existingColumns, newAlias, existingAliases);
return(new ProjectedColumns(projector.Visit(expression), projector.columns.AsReadOnly()));
}
private ClientJoinedProjectionRewriter(QueryPolicy policy, QueryLanguage language)
{
this.policy = policy;
this.language = language;
}
public static Expression Rewrite(QueryLanguage language, Expression expression)
{
return(new SingletonProjectionRewriter(language).Visit(expression));
}
private SingletonProjectionRewriter(QueryLanguage language)
{
this.language = language;
}
private RelationshipBinder(QueryMapper mapper)
{
this.mapper = mapper;
this.mapping = mapper.Mapping;
this.language = mapper.Translator.Linguist.Language;
}
public QueryLinguist(QueryLanguage language, QueryTranslator translator)
{
this.language = language;
this.translator = translator;
}
public static Expression Rewrite(QueryLanguage language, Expression expression)
{
return(new SkipToNestedOrderByRewriter(language).Visit(expression));
}
internal static HashSet <Expression> Nominate(QueryLanguage language, Expression expression)
{
ColumnProjector.Nominator nominator = new ColumnProjector.Nominator(language);
nominator.Visit(expression);
return(nominator.candidates);
}
public static Expression Rewrite(QueryPolicy policy, QueryLanguage language, Expression expression)
{
return(new ClientJoinedProjectionRewriter(policy, language).Visit(expression));
}
private SkipToRowNumberRewriter(QueryLanguage language)
{
this.language = language;
}
public static ProjectedColumns ProjectColumns(QueryLanguage language, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, params TableAlias[] existingAliases)
{
return(ProjectColumns(language, expression, existingColumns, newAlias, (IEnumerable <TableAlias>)existingAliases));
}
public static ProjectionExpression AddOuterJoinTest(this ProjectionExpression proj, QueryLanguage language, Expression expression)
{
string availableColumnName = proj.Select.Columns.GetAvailableColumnName("Test");
QueryType columnType = language.TypeSystem.GetColumnType(expression.Type);
SelectExpression source = proj.Select.AddColumn(new ColumnDeclaration(availableColumnName, expression, columnType));
return(new ProjectionExpression(source, new OuterJoinedExpression(new ColumnExpression(expression.Type, columnType, source.Alias, availableColumnName), proj.Projector), proj.Aggregator));
}
public static Expression Rewrite(QueryLanguage language, Expression expr)
{
return(new AggregateRewriter(language, expr).Visit(expr));
}
private CrossApplyRewriter(QueryLanguage language)
{
this.language = language;
}
public static Expression Rewrite(QueryLanguage language, Expression expression)
{
return(new SkipToRowNumberRewriter(language).Visit(expression));
}
public static Expression Parameterize(QueryLanguage language, Expression expression)
{
return(new Parameterizer(language).Visit(expression));
}
protected DbExpressionWriter(TextWriter writer, QueryLanguage language) : base(writer)
{
this.aliasMap = new Dictionary <TableAlias, int>();
this.language = language;
}
public static void Write(TextWriter writer, QueryLanguage language, Expression expression)
{
new DbExpressionWriter(writer, language).Visit(expression);
}
public static Expression Rewrite(QueryLanguage language, Expression expression)
{
return(new CrossApplyRewriter(language).Visit(expression));
}
public QueryTranslator(QueryLanguage language, QueryMapping mapping, QueryPolicy policy)
{
this.linguist = language.CreateLinguist(this);
this.mapper = mapping.CreateMapper(this);
this.police = policy.CreatePolice(this);
}
