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