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);
}
