protected SqlFormatter(QueryLanguage language, bool forDebug) { this.language = language; this.sb = new StringBuilder(); this.aliases = new Dictionary<IdentifiableAlias, string>(); this.forDebug = forDebug; }
protected QueryBinder(QueryMapper mapper, Expression root) { this.mapper = mapper; this.language = mapper.Translator.Linguist.Language; this.map = new Dictionary<ParameterExpression, Expression>(); this.groupByMap = new Dictionary<Expression, GroupByInfo>(); this.root = root; this.repoType = mapper.Mapping.RepositoryType; }
public static SelectExpression AddRedundantSelect(this SelectExpression sel, QueryLanguage language, IdentifiableAlias newAlias) { var newFields = from d in sel.Fields let qt = (d.Expression is FieldExpression) ? ((FieldExpression)d.Expression).QueryType : language.TypeSystem.GetStorageType(d.Expression.Type) select new FieldDeclaration(d.Name, new FieldExpression(d.Expression.Type, qt, newAlias, d.Name), qt); var newFrom = new SelectExpression(newAlias, sel.Fields, sel.From, sel.Where, sel.OrderBy, sel.GroupBy, sel.IsDistinct, sel.Skip, sel.Take, sel.IsReverse); return new SelectExpression(sel.Alias, newFields, newFrom, null, null, null, false, null, null, false); }
public static ProjectionExpression AddOuterJoinTest(this ProjectionExpression proj, QueryLanguage language, Expression expression) { string colName = proj.Select.Fields.GetAvailableFieldName("Test"); var colType = language.TypeSystem.GetStorageType(expression.Type); SelectExpression newSource = proj.Select.AddField(new FieldDeclaration(colName, expression, colType)); Expression newProjector = new OuterJoinedExpression( new FieldExpression(expression.Type, colType, newSource.Alias, colName), proj.Projector ); return new ProjectionExpression(newSource, newProjector, proj.Aggregator); }
public DataProvider(IRepository repository, QueryLanguage language, QueryMapping mapping, QueryPolicy policy) { if (language == null) throw new InvalidOperationException("Language not specified"); if (mapping == null) throw new InvalidOperationException("Mapping not specified"); if (policy == null) throw new InvalidOperationException("Policy not specified"); this._language = language; this._mapping = mapping; this._policy = policy; this.Repository = repository; }
private FieldProjector(QueryLanguage language, Expression expression, IEnumerable<FieldDeclaration> existingFields, IdentifiableAlias newAlias, IEnumerable<IdentifiableAlias> existingAliases) { this.language = language; this.newAlias = newAlias; this.existingAliases = new HashSet<IdentifiableAlias>(existingAliases); this.map = new Dictionary<FieldExpression, FieldExpression>(); if (existingFields != null) { this.fields = new List<FieldDeclaration>(existingFields); this.fieldNames = new HashSet<string>(existingFields.Select(c => c.Name)); } else { this.fields = new List<FieldDeclaration>(); this.fieldNames = new HashSet<string>(); } this.candidates = Nominator.Nominate(language, expression); }
private Nominator(QueryLanguage language) { this.language = language; this.candidates = new HashSet<Expression>(); this.isBlocked = false; }
public static Expression Rewrite(QueryPolicy policy, QueryLanguage language, Expression expression) { return new ClientJoinedProjectionRewriter(policy, language).Visit(expression); }
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; }
protected OAggregateRewriter(QueryLanguage language, Expression expr) : base(language, expr) { }
public static ProjectedFields ProjectFields(QueryLanguage language, Expression expression, IEnumerable<FieldDeclaration> existingFields, IdentifiableAlias newAlias, IEnumerable<IdentifiableAlias> existingAliases) { FieldProjector projector = new FieldProjector(language, expression, existingFields, newAlias, existingAliases); Expression expr = projector.Visit(expression); return new ProjectedFields(expr, projector.fields.AsReadOnly()); }
protected OQueryFormatter(QueryLanguage language, bool forDebug) : base(language, forDebug) { }
public QueryLinguist(QueryLanguage language, QueryTranslator translator) { this.language = language; this.translator = translator; }
public static Expression Rewrite(QueryLanguage language, Expression expr) { return new AggregateRewriter(language, expr).Visit(expr); }
protected AggregateRewriter(QueryLanguage language, Expression expr) { this.language = language; this.map = new Dictionary<AggregateSubqueryExpression, Expression>(); this.lookup = Gather(expr).ToLookup(a => a.GroupByAlias); }
public static string WriteToString(QueryLanguage language, Expression expression) { StringWriter sw = new StringWriter(); Write(sw, language, expression); return sw.ToString(); }
public static void Write(TextWriter writer, QueryLanguage language, Expression expression) { new DbExpressionWriter(writer, language).Visit(expression); }
protected DbExpressionWriter(TextWriter writer, QueryLanguage language) : base(writer) { this.language = language; }
internal static HashSet<Expression> Nominate(QueryLanguage language, Expression expression) { Nominator nominator = new Nominator(language); nominator.Visit(expression); return nominator.candidates; }
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); }
public static ProjectedFields ProjectFields(QueryLanguage language, Expression expression, IEnumerable<FieldDeclaration> existingFields, IdentifiableAlias newAlias, params IdentifiableAlias[] existingAliases) { return ProjectFields(language, expression, existingFields, newAlias, (IEnumerable<IdentifiableAlias>)existingAliases); }
public static new Expression Parameterize(QueryLanguage language, Expression expression) { return new OParameterizer((OQueryLanguage)language).Visit(expression); }
protected RelationshipBinder(QueryMapper mapper) { this.mapper = mapper; this.mapping = mapper.Mapping; this.language = mapper.Translator.Linguist.Language; }
public OQueryLinguist(QueryLanguage language, QueryTranslator translator) : base(language, translator) { }
protected OQueryFormatter(QueryLanguage language) : this(language, false) { }
private CrossApplyRewriter(QueryLanguage language) { this.language = language; }