private static Expression DeserializedQueryExpressionAndValidate(InternalQuery internalRemoteQuery) { var deserializedQuery = internalRemoteQuery.SerializedExpression.ToExpression(); ExpressionValidator.Validate(deserializedQuery); return(deserializedQuery); }
/// <summary> /// Instancie o objeto e clona /// </summary> /// <param name="pTableQuery">Objeto table query</param> public TableQuery(TableQuery pTableQuery) : this() { DbName = pTableQuery.DbName; TableName = pTableQuery.TableName; FieldName = pTableQuery.FieldName; Alias = pTableQuery.Alias; SchemaTable = pTableQuery.SchemaTable; Top = pTableQuery.Top; Distinct = pTableQuery.Distinct; Fields = new TableAdapterFieldCollection(pTableQuery.Fields); foreach (OrderBy myItem in pTableQuery.OrderBy) { OrderBy.Add(new OrderBy(myItem)); } pTableQuery.Wheres.ForEach( w => Wheres.Add(new WhereCollection(w))); if (pTableQuery.Joins != null) { pTableQuery.Joins.ForEach( j => Joins.Add(new Join(j))); } if (pTableQuery.Union != eUnionType.eutNone) { pTableQuery.InternalQuery.ForEach( c => InternalQuery.Add(new TableQuery(c))); } }
InternalQuery <T1> CreateFunctionQuery <T1>(MethodInfo method, List <Expression> parameters) { FunctionExpression e = new FunctionExpression(typeof(T1), this._expression, method, parameters); var q = new Query <T1>(this._dbContext, e, false); InternalQuery <T1> iterator = q.GenenateIterator(); return(iterator); }
InternalQuery <TResult> CreateAggregateQuery <TResult>(MethodInfo method, List <Expression> parameters) { AggregateQueryExpression e = new AggregateQueryExpression(this._expression, method, parameters); var q = new Query <TResult>(this._dbContext, e, false); InternalQuery <TResult> iterator = q.GenerateIterator(); return(iterator); }
/// <summary> /// Resolve requested data type. /// </summary> /// <param name="internalRemoteQuery">Query from server.</param> /// <returns>Info of requested type.</returns> private static TypeInfo ResolveType(InternalQuery internalRemoteQuery) { var targetAssemblyName = internalRemoteQuery.RequestedTypeAssemblyName; var targetAssembly = GetAssemblyOrThrownEx(internalRemoteQuery, targetAssemblyName); var targetType = GetTypeFromAssemblyOrThrownEx(targetAssembly, internalRemoteQuery.RequestedTypeName, targetAssemblyName); return(targetType); }
InternalQuery <TReturn> CreateAggregateQuery <TReturn>(string methodName, List <Expression> parameters) { MethodInfo method = this.GetCalledMethod(methodName, parameters); AggregateQueryExpression e = new AggregateQueryExpression(this._expression, method, parameters); var q = new Query <TReturn>(this._dbContext, e, false); InternalQuery <TReturn> iterator = q.GenerateIterator(); return(iterator); }
private static string SerializeQuery(Expression expression) { var newInternalQuery = InternalQuery.CreateMessage(expression, typeof(T)); var serializedQuery = JsonConvert.SerializeObject(newInternalQuery, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore, TypeNameHandling = TypeNameHandling.All }); return(serializedQuery); }
private InternalQuery GetInternalQuery() { var queryBuilder = _queryWriter.Query <T>(); var parameters = GetParameters(queryBuilder); var query = new InternalQuery { Sql = queryBuilder.Builder.ToString(), Parameters = parameters }; Console.WriteLine(query.Sql); return(query); }
private static Assembly GetAssemblyOrThrownEx(InternalQuery internalRemoteQuery, string targetAssemblyName) { var targetAssembly = AppDomain.CurrentDomain.GetAssemblies() .FirstOrDefault(asm => asm.FullName.Equals(internalRemoteQuery.RequestedTypeAssemblyName, StringComparison.OrdinalIgnoreCase)); if (targetAssembly == null) { throw new InvalidOperationException(string.Format("Assembly with name '{0}' not found in server app domain", targetAssemblyName)); } return(targetAssembly); }
TResult ExecuteAggregateQuery <TResult>(MethodInfo method, Expression argument, bool checkArgument = true) { if (checkArgument) { Utils.CheckNull(argument); } List <Expression> arguments = argument == null ? EmptyArgumentList : new List <Expression>(1) { argument }; var q = this.CreateAggregateQuery <TResult>(method, arguments); InternalQuery <TResult> iterator = q.GenerateIterator(); return(iterator.Single()); }
/// <summary> /// Returns a <see cref="System.String" /> representation of the underlying query. /// </summary> /// <returns> The query string. </returns> public override string ToString() { return(InternalQuery == null?base.ToString() : InternalQuery.ToString()); }
public new virtual DbSqlQuery AsStreaming() { return(InternalQuery == null ? this : new DbSqlQuery(InternalQuery.AsStreaming())); }
/// <summary> /// Returns a new query where the entities returned will not be cached in the <see cref="DbContext" />. /// </summary> /// <returns> A new query with NoTracking applied. </returns> public DbSqlQuery <TEntity> AsNoTracking() { return(new DbSqlQuery <TEntity>(InternalQuery.AsNoTracking())); }
/// <summary> /// Returns a new query that will stream the results instead of buffering. /// </summary> /// <returns> A new query with AsStreaming applied. </returns> public new DbSqlQuery AsStreaming() { return(new DbSqlQuery(InternalQuery.AsStreaming())); }
/// <summary> /// Returns a new query that will stream the results instead of buffering. /// </summary> /// <returns> A new query with AsStreaming applied. </returns> public new DbSqlQuery <TEntity> AsStreaming() { return(new DbSqlQuery <TEntity>(InternalQuery.AsStreaming())); }
async Task <List <T> > GenerateIteratorAsync() { InternalQuery <T> internalQuery = new InternalQuery <T>(this); return(await internalQuery.ExecuteAsync()); }
/// <summary> /// Returns a <see cref="System.String" /> representation of the underlying query. /// </summary> /// <returns> The query string. </returns> public override string ToString() { return(InternalQuery.ToString()); }
IEnumerator IEnumerable.GetEnumerator() { return(InternalQuery.GetEnumerator()); }
/// <summary> /// Returns a new query where the results of the query will not be tracked by the associated /// <see cref="DbContext" />. /// </summary> /// <returns> A new query with NoTracking applied. </returns> public virtual DbSqlQuery AsNoTracking() { return(InternalQuery == null ? this : new DbSqlQuery(InternalQuery.AsNoTracking())); }
IDbAsyncEnumerator IDbAsyncEnumerable.GetAsyncEnumerator() { return(InternalQuery.GetAsyncEnumerator()); }
InternalQuery <T> GenerateIterator() { InternalQuery <T> internalQuery = new InternalQuery <T>(this); return(internalQuery); }
/// <summary> /// Returns a new query where the results of the query will not be tracked by the associated /// <see cref="DbContext" />. /// </summary> /// <returns> A new query with no-tracking applied. </returns> public DbSqlQuery AsNoTracking() { return(new DbSqlQuery(InternalQuery.AsNoTracking())); }
public override string ToString() { InternalQuery <T> internalQuery = this.GenerateIterator(); return(internalQuery.ToString()); }
Chloe.Collections.Generic.IAsyncEnumerable <T> GenerateAsyncIterator() { InternalQuery <T> internalQuery = new InternalQuery <T>(this); return(internalQuery); }