public static DbFunctionExpression GetReparentedValue(this DbExpression hierarchyIdValue, DbExpression oldRoot, DbExpression newRoot)
{
Check.NotNull(hierarchyIdValue, "hierarchyIdValue");
Check.NotNull(oldRoot, "oldRoot");
Check.NotNull(newRoot, "newRoot");
return(EdmFunctions.InvokeCanonicalFunction("GetReparentedValue", hierarchyIdValue, oldRoot, newRoot));
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
#region ENTITY SETs
builder.EntitySet <Agenda>("Agenda");
builder.EntitySet <Cep>("Cep");
builder.EntitySet <Produto>("Produtos");
builder.EntitySet <Loja>("Lojas");
builder.EntitySet <Cliente>("Clientes");
builder.EntitySet <ContaBancaria>("ContaBancaria");
builder.EntitySet <ContaPagar>("ContaPagar");
builder.EntitySet <ContaReceber>("ContaReceber");
builder.EntitySet <Despesa>("Despesas");
builder.EntitySet <DocumentoEntrada>("DocumentoEntrada");
builder.EntitySet <DocumentoEntradaItem>("DocumentoEntradaItem");
builder.EntitySet <Fornecedor>("Fornecedores");
builder.EntitySet <Funcionario>("Funcionarios");
builder.EntitySet <Historico>("Historicos");
builder.EntitySet <Marca>("Marcas");
builder.EntitySet <MovimentoEstoque>("MovimentoEstoque");
builder.EntitySet <Operadora>("Operadoras");
builder.EntitySet <PedidoVenda>("PedidoVenda");
builder.EntitySet <PedidoVendaItem>("PedidoVendaItem");
builder.EntitySet <PreVenda>("PreVenda");
builder.EntitySet <PreVendaItem>("PreVendaItem");
builder.EntitySet <Produto>("Produtos");
builder.EntitySet <RecebimentoConta>("RecebimentoConta");
builder.EntitySet <SaldoEstoque>("SaldoEstoque");
builder.EntitySet <Secao>("Secao");
builder.EntitySet <Tabela>("Tabelas");
builder.EntitySet <Tipo>("Tipos");
builder.EntitySet <Usuario>("Usuarios");
builder.EntitySet <Venda>("Vendas");
builder.EntitySet <Vendedor>("Vendedores");
builder.EntitySet <ContaCorrente>("ContaCorrente");
builder.EntitySet <Parametro>("Parametros");
builder.EntitySet <EntradaAntecipada>("EntradaAntecipada");
builder.EntitySet <Cheque>("Cheques");
builder.EntitySet <MovimentoCaixa>("MovimentoCaixa");
builder.EntitySet <Cancelada>("Canceladas");
builder.EntitySet <ContaReceberTemp>("ContaReceberTemp");
builder.EntitySet <ContaPagarTemp>("ContaPagarTemp");
builder.EntitySet <HistoricoCliente>("HistoricoCliente");
builder.EntitySet <CondicaoPagamento>("CondicaoPagamento");
builder.EntitySet <Relatorios>("Relatorios");
builder.EntitySet <Pergunta>("Perguntas");
builder.EntitySet <FechamentoCaixa>("FechamentoCaixa");
builder.EntitySet <Modulo>("Modulos");
builder.EntitySet <ModuloAplicativo>("ModuloAplicativos");
builder.EntitySet <Aplicativo>("Aplicativos");
builder.EntitySet <UsuarioFuncao>("UsuarioFuncoes");
#endregion
EdmFunctions.BuildFunctions(builder);
return(builder.GetEdmModel());
}
/// <summary>
/// Creates a <see cref="DbFunctionExpression" /> that invokes the canonical 'GetDescendant' function with the
/// specified argument, which must have a HierarchyId result type.
/// The result type of the expression is Edm.HierarchyId.
/// </summary>
/// <param name="hierarchyIdValue"> An expression that specifies the hierarchyid value. </param>
/// <param name="child1"> An expression that provides a hierarchyid value. </param>
/// <param name="child2"> An expression that provides a hierarchyid value. </param>
/// <returns> A new DbFunctionExpression that returns a hierarchyid. </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="hierarchyIdValue" />
/// or
/// <paramref name="child1" />
/// or
/// <paramref name="child2" />
/// is null.
/// </exception>
/// <exception cref="ArgumentException">
/// No overload of the canonical 'GetDescendant' function accept an argument with the result type of
/// <paramref name="child1" />
/// and
/// <paramref name="child2" />
/// .
/// </exception>
public static DbFunctionExpression GetDescendant(this DbExpression hierarchyIdValue, DbExpression child1, DbExpression child2)
{
Check.NotNull(hierarchyIdValue, "hierarchyIdValue");
Check.NotNull(child1, "child1");
Check.NotNull(child2, "child2");
return(EdmFunctions.InvokeCanonicalFunction("GetDescendant", hierarchyIdValue, child1, child2));
}
private static string BuildSqlForDateTimeOffset(DateTimeOffset dateTimeOffset, SqlVersion sqlVersion)
{
var builder = new StringBuilder();
var sqlGenerator = new SqlGenerator(sqlVersion);
var functionExpression = EdmFunctions.CreateDateTimeOffset(
DbExpression.FromInt32(dateTimeOffset.Year),
DbExpression.FromInt32(dateTimeOffset.Month),
DbExpression.FromInt32(dateTimeOffset.Day),
DbExpression.FromInt32(dateTimeOffset.Hour),
DbExpression.FromInt32(dateTimeOffset.Minute),
DbExpression.FromInt32(dateTimeOffset.Second),
DbExpression.FromInt32(Convert.ToInt32(dateTimeOffset.Offset.TotalMinutes)));
var sqlFragment = SqlFunctionCallHandler.GenerateFunctionCallSql(
sqlGenerator, functionExpression);
using (var sqlWriter = new SqlWriter(builder))
{
sqlFragment.WriteSql(sqlWriter, sqlGenerator);
}
return(builder.ToString());
}
public override DbExpression Visit(DbNewInstanceExpression expression)
{
var arguments = expression.Arguments.Select(a =>
{
var propertyArg = a as DbPropertyExpression;
if (propertyArg != null && _typesToTrim.Contains(propertyArg.Property.TypeUsage.EdmType.Name))
{
return(EdmFunctions.Trim(a));
}
return(a);
});
var temp = new List <DbExpression>();
foreach (var a in expression.Arguments)
{
var propertyArg = a as DbPropertyExpression;
if (propertyArg != null && _typesToTrim.Contains(propertyArg.Property.TypeUsage.EdmType.Name))
{
temp.Add(EdmFunctions.Trim(a));
}
else
{
temp.Add(a);
}
}
return(DbExpressionBuilder.New(expression.ResultType, temp));
}
public override DbExpression Visit(DbNewInstanceExpression expression)
{
var argments = expression.Arguments.Select(t =>
{
if (t is DbPropertyExpression propertyArg && _typeToTrim.Contains(propertyArg.Property.TypeUsage.EdmType.Name))
{
return(EdmFunctions.Trim(t));
}
return(t);
});
return(DbExpressionBuilder.New(expression.ResultType, argments));
}
public override DbExpression Visit(DbNewInstanceExpression expression)
{
var arguments = expression.Arguments.Select(a =>
{
var propertyArg = a as DbPropertyExpression;
if (propertyArg != null && _typesToTrim.Contains(propertyArg.Property.TypeUsage.EdmType.Name))
{
return(EdmFunctions.Trim(a));
}
return(a);
});
return(DbExpressionBuilder.New(expression.ResultType, arguments));
}
private static string BuildSqlForTruncateTime(DateTimeOffset dateTimeOffset, SqlVersion sqlVersion)
{
var builder = new StringBuilder();
var sqlGenerator = new SqlGenerator(sqlVersion);
var functionExpression = EdmFunctions.TruncateTime(
DbExpression.FromDateTimeOffset(dateTimeOffset));
var sqlFragment = SqlFunctionCallHandler.GenerateFunctionCallSql(
sqlGenerator, functionExpression);
using (var sqlWriter = new SqlWriter(builder))
{
sqlFragment.WriteSql(sqlWriter, sqlGenerator);
}
return(builder.ToString());
}
public static IEdmModel GetEdmModel()
{
ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet <Produto>("Produtos");
builder.EntitySet <Loja>("Lojas");
builder.EntitySet <Cliente>("Clientes");
builder.EntitySet <PedidoVenda>("PedidoVenda");
builder.EntitySet <PedidoVendaItem>("PedidoVendaItem");
builder.EntitySet <PreVenda>("PreVenda");
builder.EntitySet <PreVendaItem>("PreVendaItem");
builder.EntitySet <Produto>("Produtos");
builder.EntitySet <Vendedor>("Vendedores");
builder.EntitySet <ContaReceberTemp>("ContaReceberTemp");
builder.EntitySet <Operadora>("Operadoras");
EdmFunctions.BuildFunctions(builder);
return(builder.GetEdmModel());
}
protected override Expression VisitBinary(BinaryExpression node)
{
#if (DEBUG_VISITS)
System.Diagnostics.Debug.Print("VisitBinary: {0}", node);
#endif
var expression = base.VisitBinary(node) as BinaryExpression;
DbExpression dbExpression;
// Need special handling for comparisons against the null constant. If we don't translate these
// using an "IsNull" expression, EF will convert it literally as "= null" which doesn't work in SQL Server.
if (IsNullConstantExpression(expression.Right))
{
dbExpression = MapNullComparison(expression.Left, expression.NodeType);
}
else if (IsNullConstantExpression(expression.Left))
{
dbExpression = MapNullComparison(expression.Right, expression.NodeType);
}
else
{
DbExpression leftExpression = GetDbExpressionForExpression(expression.Left);
DbExpression rightExpression = GetDbExpressionForExpression(expression.Right);
switch (expression.NodeType)
{
case ExpressionType.Equal:
// DbPropertyExpression = class property that has been mapped to a database column
// DbParameterReferenceExpression = lambda parameter
if (IsNullableExpressionOfType <DbPropertyExpression>(leftExpression) && IsNullableExpressionOfType <DbParameterReferenceExpression>(rightExpression))
{
dbExpression = CreateEqualComparisonOfNullablePropToNullableParam(leftExpression, rightExpression);
}
else if (IsNullableExpressionOfType <DbPropertyExpression>(rightExpression) && IsNullableExpressionOfType <DbParameterReferenceExpression>(leftExpression))
{
dbExpression = CreateEqualComparisonOfNullablePropToNullableParam(rightExpression, leftExpression);
}
else
{
dbExpression = DbExpressionBuilder.Equal(leftExpression, rightExpression);
}
break;
case ExpressionType.NotEqual:
dbExpression = DbExpressionBuilder.NotEqual(leftExpression, rightExpression);
break;
case ExpressionType.GreaterThan:
dbExpression = DbExpressionBuilder.GreaterThan(leftExpression, rightExpression);
break;
case ExpressionType.GreaterThanOrEqual:
dbExpression = DbExpressionBuilder.GreaterThanOrEqual(leftExpression, rightExpression);
break;
case ExpressionType.LessThan:
dbExpression = DbExpressionBuilder.LessThan(leftExpression, rightExpression);
break;
case ExpressionType.LessThanOrEqual:
dbExpression = DbExpressionBuilder.LessThanOrEqual(leftExpression, rightExpression);
break;
case ExpressionType.AndAlso:
dbExpression = DbExpressionBuilder.And(leftExpression, rightExpression);
break;
case ExpressionType.OrElse:
dbExpression = DbExpressionBuilder.Or(leftExpression, rightExpression);
break;
case ExpressionType.And:
dbExpression = EdmFunctions.BitwiseAnd(leftExpression, rightExpression);
break;
case ExpressionType.Or:
dbExpression = EdmFunctions.BitwiseOr(leftExpression, rightExpression);
break;
case ExpressionType.ExclusiveOr:
dbExpression = EdmFunctions.BitwiseXor(leftExpression, rightExpression);
break;
default:
throw new NotImplementedException(string.Format("Unhandled NodeType of {0} in LambdaToDbExpressionVisitor.VisitBinary", expression.NodeType));
}
}
MapExpressionToDbExpression(expression, dbExpression);
return(expression);
}
public static DbFunctionExpression GetAncestor(this DbExpression hierarchyIdValue, DbExpression n)
{
Check.NotNull(hierarchyIdValue, "hierarchyIdValue");
Check.NotNull(n, "n");
return(EdmFunctions.InvokeCanonicalFunction("GetAncestor", hierarchyIdValue, n));
}
public static DbFunctionExpression HierarchyIdGetRoot()
{
return(EdmFunctions.InvokeCanonicalFunction("HierarchyIdGetRoot"));
}
// HierarchyId ‘Static’ Functions
/// <summary>
/// Creates a <see cref="DbFunctionExpression" /> that invokes the canonical 'HierarchyIdParse' function with the
/// specified argument, which must have a string result type.
/// The result type of the expression is Edm.HierarchyId.
/// </summary>
/// <param name="input"> An expression that provides the canonical representation of the hierarchyid value. </param>
/// <returns> A new DbFunctionExpression that returns a new hierarchyid value based on the specified value. </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="input" />
/// is null.
/// </exception>
/// <exception cref="ArgumentException">
/// No overload of the canonical 'HierarchyIdParse' function accept an argument with the result type of
/// <paramref name="input" />
/// .
/// </exception>
public static DbFunctionExpression HierarchyIdParse(DbExpression input)
{
Check.NotNull(input, "input");
return(EdmFunctions.InvokeCanonicalFunction("HierarchyIdParse", input));
}
/// <summary>
/// Creates a <see cref="DbFunctionExpression" /> that invokes the canonical 'IsDescendantOf' function with the
/// specified argument, which must have a HierarchyId result type.
/// The result type of the expression is Int32.
/// </summary>
/// <param name="hierarchyIdValue"> An expression that specifies the hierarchyid value. </param>
/// <param name="parent"> An expression that provides a hierarchyid value. </param>
/// <returns> A new DbFunctionExpression that returns an integer value. </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="hierarchyIdValue" />
/// or
/// <paramref name="parent" />
/// is null.
/// </exception>
/// <exception cref="ArgumentException">
/// No overload of the canonical 'IsDescendantOf' function accept an argument with the result type of
/// <paramref name="parent" />
/// .
/// </exception>
public static DbFunctionExpression IsDescendantOf(this DbExpression hierarchyIdValue, DbExpression parent)
{
Check.NotNull(hierarchyIdValue, "hierarchyIdValue");
Check.NotNull(parent, "parent");
return(EdmFunctions.InvokeCanonicalFunction("IsDescendantOf", hierarchyIdValue, parent));
}
/// <summary>
/// Creates a <see cref="DbFunctionExpression" /> that invokes the canonical 'GetLevel' function.
/// The result type of the expression is Int32.
/// </summary>
/// <param name="hierarchyIdValue"> An expression that specifies the hierarchyid value. </param>
/// <returns> A new DbFunctionExpression that returns the level of the given hierarchyid. </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="hierarchyIdValue" />
/// is null.
/// </exception>
public static DbFunctionExpression GetLevel(this DbExpression hierarchyIdValue)
{
Check.NotNull(hierarchyIdValue, "hierarchyIdValue");
return(EdmFunctions.InvokeCanonicalFunction("GetLevel", hierarchyIdValue));
}
public void TreeCreated(DbCommandTreeInterceptionContext interceptionContext)
{
if (interceptionContext.OriginalResult.DataSpace == DataSpace.SSpace)
{
var insertCommand = interceptionContext.Result as DbInsertCommandTree;
if (insertCommand != null)
{
List <DbModificationClause> finalSetClauses =
new List <DbModificationClause>(
(IEnumerable <DbModificationClause>)insertCommand.SetClauses.Select(
a =>
{
var dbSetClause = a as DbSetClause;
if (dbSetClause != null)
{
var dbPropertyExpression = dbSetClause.Property as DbPropertyExpression;
if (dbPropertyExpression != null)
{
var edmProperty = dbPropertyExpression.Property as EdmProperty;
if (edmProperty != null && edmProperty.MaxLength != null &&
_typesToTrim.Contains(edmProperty.TypeName))
{
var dbConstantExpression = dbSetClause.Value as DbConstantExpression;
if (dbConstantExpression != null && dbConstantExpression.Value != null)
{
var value = dbConstantExpression.Value.ToString();
if (!string.IsNullOrEmpty(value) &&
value.Length > (int)edmProperty.MaxLength)
{
return(DbExpressionBuilder.SetClause(
DbExpressionBuilder.Property(
DbExpressionBuilder.Variable(
insertCommand.Target.VariableType,
insertCommand.Target.VariableName),
dbPropertyExpression.Property.Name),
EdmFunctions.Trim(
dbConstantExpression.Value.ToString()
.Substring(0, (int)edmProperty.MaxLength))));
}
}
}
}
}
return(a);
}));
var newInsertCommand = new DbInsertCommandTree(
insertCommand.MetadataWorkspace,
insertCommand.DataSpace,
insertCommand.Target,
new ReadOnlyCollection <DbModificationClause>(finalSetClauses),
insertCommand.Returning);
interceptionContext.Result = newInsertCommand;
}
}
var updateCommand = interceptionContext.Result as DbUpdateCommandTree;
if (updateCommand != null)
{
List <DbModificationClause> finalSetClauses =
new List <DbModificationClause>(
(IEnumerable <DbModificationClause>)updateCommand.SetClauses.Select(
a =>
{
var dbSetClause = a as DbSetClause;
if (dbSetClause != null)
{
var dbPropertyExpression = dbSetClause.Property as DbPropertyExpression;
if (dbPropertyExpression != null)
{
var edmProperty = dbPropertyExpression.Property as EdmProperty;
if (edmProperty != null && edmProperty.MaxLength != null &&
_typesToTrim.Contains(edmProperty.TypeName))
{
var dbConstantExpression = dbSetClause.Value as DbConstantExpression;
if (dbConstantExpression != null && dbConstantExpression.Value != null)
{
var value = dbConstantExpression.Value.ToString();
if (!string.IsNullOrEmpty(value) &&
value.Length > (int)edmProperty.MaxLength)
{
return(DbExpressionBuilder.SetClause(
DbExpressionBuilder.Property(
DbExpressionBuilder.Variable(
updateCommand.Target.VariableType,
updateCommand.Target.VariableName),
dbPropertyExpression.Property.Name),
EdmFunctions.Trim(
dbConstantExpression.Value.ToString()
.Substring(0, (int)edmProperty.MaxLength))));
}
}
}
}
}
return(a);
}));
var newInsertCommand = new DbUpdateCommandTree(
updateCommand.MetadataWorkspace,
updateCommand.DataSpace,
updateCommand.Target,
updateCommand.Predicate,
new ReadOnlyCollection <DbModificationClause>(finalSetClauses),
updateCommand.Returning);
interceptionContext.Result = newInsertCommand;
}
}