public override DbExpression Visit(DbScanExpression expression)
{
// a bit harder to get the metadata in CSpace
var item = expression.Target.ElementType.MetadataProperties.First(p => p.Name == "Configuration");
// using reflection to get the Annotations property as EntityTtypeConfiguration is an internal class in EF
Dictionary<string, object> annotations = new Dictionary<string, object>();
var value = item.Value;
var propertyInfo = value.GetType().GetProperty("Annotations");
if (propertyInfo != null)
{
annotations = (Dictionary<string, object>) propertyInfo.GetValue(value, null);
}
if (!annotations.Any())
{
return base.Visit(expression);
}
DbExpression current = expression;
foreach (var globalFilter in annotations.Where(a => a.Key.StartsWith("globalFilter")))
{
var convention = (FilterDefinition)globalFilter.Value;
Filter filterConfig;
string filterName = globalFilter.Key.Split(new[] { "globalFilter_" }, StringSplitOptions.None)[1];
if (!FilterExtensions.FilterConfigurations.TryGetValue(new Tuple<string, object>(filterName, _contextForInterception.GetInternalContext()), out filterConfig))
continue;
if (!filterConfig.IsEnabled)
continue;
var linqExpression = convention.Predicate(_contextForInterception, filterConfig.ParameterValues);
var funcletizerType = typeof(DefaultExpressionVisitor).Assembly.GetType(
"System.Data.Entity.Core.Objects.ELinq.Funcletizer");
var funcletizerFactoryMethod = funcletizerType.GetMethod("CreateQueryFuncletizer",
BindingFlags.Static | BindingFlags.NonPublic);
var funcletizer = funcletizerFactoryMethod.Invoke(null, new[] { _objectContext });
var converterType = typeof(DefaultExpressionVisitor).Assembly.GetType(
"System.Data.Entity.Core.Objects.ELinq.ExpressionConverter");
var converter = Activator.CreateInstance(converterType,
BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { funcletizer, linqExpression }, null);
var convertMethod = converterType.GetMethod("Convert",
BindingFlags.NonPublic | BindingFlags.Instance);
var result = (DbFilterExpression)convertMethod.Invoke(converter, null);
var binding = current.Bind();
var normalizer = new BindingNormalizer(binding);
var output = result.Predicate.Accept(normalizer);
current = binding.Filter(output);
}
return current;
}
public override DbExpression Visit(DbScanExpression expression)
{
var column = SoftDeleteAttribute.GetSoftDeleteColumnName(expression.Target.ElementType);
if (column != null)
{
// Just because the entity has the soft delete annotation doesn't mean that
// this particular table has the column. This occurs in situation like TPT
// inheritance mapping and entity splitting where one type maps to multiple
// tables.
// We only apply the filter if the column is actually present in this table.
// If not, then the query is going to be joining to the table that does have
// the column anyway, so the filter will still be applied.
var table = (EntityType)expression.Target.ElementType;
if (table.Properties.Any(p => p.Name == column))
{
var binding = DbExpressionBuilder.Bind(expression);
return DbExpressionBuilder.Filter(
binding,
DbExpressionBuilder.NotEqual(
DbExpressionBuilder.Property(
DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName),
column),
DbExpression.FromBoolean(true)));
}
}
return base.Visit(expression);
}
public override DbExpression Visit(DbScanExpression expression)
{
#if DEBUG_VISITS
System.Diagnostics.Debug.Print("Visit(DbScanExpression): Target.Name={0}", expression.Target.Name);
#endif
// If using SSpace:
// This method will be called for all query expressions. If there is a filter included (in a .Where() for example),
// Visit(DbFilterExpression) will be called first and our dynamic filters will have already been included.
// Otherwise, we do that here.
// If using CSpace:
// This method will only be called for the initial entity. Any other references to other entities will be
// handled by the Visit(DbPropertyExpression) - this includes filter references and includes.
var filterList = FindFiltersForEntitySet(expression.Target.ElementType.MetadataProperties);
System.Diagnostics.Debug.Print(" Found {0} filters", filterList.Count());
var baseResult = base.Visit(expression);
if (filterList.Any())
{
var binding = DbExpressionBuilder.Bind(baseResult);
var newFilterExpression = BuildFilterExpressionWithDynamicFilters(filterList, binding, null);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return newFilterExpression;
}
}
return baseResult;
}
public override DbExpression Visit(DbScanExpression expression)
{
// This method will be called for all query expressions. If there is a filter included (in a .Where() for example),
// Visit(DbFilterExpression) will be called first and our dynamic filters will have already been included.
// Otherwise, we do that here.
string entityName = expression.Target.Name;
var filterList = expression.Target.ElementType.MetadataProperties
.Where(mp => mp.Name.Contains("customannotation:" + DynamicFilterConstants.AttributeNamePrefix))
.Select(m => m.Value as DynamicFilterDefinition);
var baseResult = base.Visit(expression);
if (filterList.Any())
{
var binding = DbExpressionBuilder.Bind(baseResult);
var newFilterExpression = BuildFilterExpressionWithDynamicFilters(entityName, filterList, binding, null);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return newFilterExpression;
}
}
return baseResult;
}
public override DbExpression Visit(DbScanExpression expression)
{
expression = (DbScanExpression)base.Visit(expression);
var column = UserAwareAttribute.GetUserColumnName(expression.Target.ElementType);
if (!string.IsNullOrEmpty(column))
{
// Check that there is an authenticated user in this context
var identity = System.Threading.Thread.CurrentPrincipal.Identity as System.Security.Claims.ClaimsIdentity;
if (identity == null)
{
throw new System.Security.SecurityException("Unauthenticated access");
}
var userIdclaim = identity.Claims.SingleOrDefault(c => c.Type == System.Security.Claims.ClaimTypes.NameIdentifier);
if (userIdclaim == null)
{
throw new System.Security.SecurityException("Unauthenticated access");
}
// Get the current expression binding
var currentExpressionBinding = DbExpressionBuilder.Bind(expression);
var newFilterExpression = BuildFilterExpression(currentExpressionBinding, column);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return newFilterExpression;
}
}
return expression;
}
protected override void OnVisited(DbScanExpression expression)
{
EntitySetBase table = expression.Target;
if (!this.tables.Contains(table))
{
this.tables.Add(table);
}
}
public override void Visit(DbScanExpression e)
{
Check.NotNull(e, "e");
VisitExprKind(e.ExpressionKind);
_key.Append('(');
_key.Append(e.Target.EntityContainer.Name);
_key.Append('.');
_key.Append(e.Target.Name);
_key.Append(':');
_key.Append(e.ResultType.EdmType.Identity);
_key.Append(')');
}
public override DbExpression Visit(DbScanExpression expression)
{
if (!expression.Target.ElementType.MetadataProperties.Any(mp => mp.Name.EndsWith("customannotation:" + AbpEfConsts.SoftDeleteCustomAnnotationName)))
{
return base.Visit(expression);
}
var binding = expression.Bind();
return binding
.Filter(binding.VariableType.Variable(binding.VariableName)
.Property("IsDeleted")//TODO: User may want to bind to another column name. It's better to use actual database column name
.Equal(DbExpression.FromBoolean(false)));
}
public override Expression Visit(DbScanExpression expression)
{
if (tableProvider == null)
{
throw new InvalidOperationException("TableProvider is not set");
}
// TODO: make this database independent
string tableName = expression.Target.GetTableName();
object table = this.tableProvider.GetTable(tableName);
return Expression.Constant(table);
}
public override DbExpression Visit(DbScanExpression expression)
{
if (!expression.Target.ElementType.MetadataProperties.Any(mp => mp.Name.EndsWith("customannotation:" + AbpEfConsts.SoftDeleteCustomAnnotationName)))
{
return(base.Visit(expression));
}
var binding = expression.Bind();
return(binding
.Filter(binding.VariableType.Variable(binding.VariableName)
.Property("IsDeleted")//TODO: User may want to bind to another column name. It's better to use actual database column name
.Equal(DbExpression.FromBoolean(false))));
}
public override Expression Visit(DbScanExpression expression)
{
if (tableProvider == null)
{
throw new InvalidOperationException("TableProvider is not set");
}
// TODO: make this database independent
string tableName = expression.Target.GetTableName();
object table = this.tableProvider.GetTable(tableName);
return(Expression.Constant(table));
}
public static ITable GetTable(
DbModificationCommandTree commandTree,
DbContainer container)
{
DbScanExpression source = commandTree.Target.Expression as DbScanExpression;
if (source == null)
{
throw new NotSupportedException(
"The type of the Target property is not DbScanExpression");
}
return(container.Internal.GetTable(source.Target.GetTableName()));
}
public override DbExpression Visit(DbScanExpression expression)
{
if (this.FilterValue > 0)
{
// Get the current expression
var dbExpression = base.Visit(expression);
var binding = expression.Bind();
return(binding.Filter(
binding.VariableType
.Variable(binding.VariableName)
.Property("FilterFieldName")
.Equal(DbExpression.FromInt32(this.FilterValue))));
}
return(base.Visit(expression));
}
public override DbExpression Visit(DbScanExpression expression)
{
var table = (EntityType)expression.Target.ElementType;
if (table.Properties.All(p => p.Name != DeletedColumnName))
{
return(base.Visit(expression));
}
var binding = expression.Bind();
return(binding.Filter(
binding.VariableType
.Variable(binding.VariableName)
.Property(DeletedColumnName).IsNull()));
}
// <summary>
// Handles extent expressions (these are the terminal nodes in update mapping views). This handler
// retrieves the changes from the grouper.
// </summary>
// <param name="node"> Extent expression node </param>
public override ChangeNode Visit(DbScanExpression node)
{
Check.NotNull(node, "node");
// Gets modifications requested for this extent from the grouper.
var extent = node.Target;
var extentModifications = UpdateTranslator.GetExtentModifications(extent);
if (null == extentModifications.Placeholder)
{
// Bootstrap placeholder (essentially a record for the extent populated with default values).
extentModifications.Placeholder = ExtentPlaceholderCreator.CreatePlaceholder(extent);
}
return(extentModifications);
}
public override DbExpression Visit(DbScanExpression expression)
{
var column = EdmHelper.GetFactoryColumnName(expression.Target.ElementType);
if (!string.IsNullOrEmpty(column))
{
// Get the current expression
var dbExpression = base.Visit(expression);
// Get the current expression binding
var currentExpressionBinding = DbExpressionBuilder.Bind(dbExpression);
//FactoryId = @Paramname_1
// Create the variable reference in order to create the property
var variableReferenceLeftSide = DbExpressionBuilder.Variable(currentExpressionBinding.VariableType,
currentExpressionBinding.VariableName);
// Create the property based on the variable in order to apply the equality
var tenantPropertyLeftSide = DbExpressionBuilder.Property(variableReferenceLeftSide, column);
// Create the parameter which is an object representation of a sql parameter.
// We have to create a parameter and not perform a direct comparison with Equal function for example
// as this logic is cached per query and called only once
var tenantParameterLeftSide = DbExpressionBuilder.Parameter(tenantPropertyLeftSide.Property.TypeUsage,
FactoryConstants.FactoryIdFilterParameterName);
// Apply the equality between property and parameter.
var filterExpressionLeftSide = DbExpressionBuilder.Equal(tenantPropertyLeftSide, tenantParameterLeftSide);
//1 = @Paramname_2
// Create the variable reference in order to create the property
var variableReferenceRightSide = DbExpressionBuilder.Variable(currentExpressionBinding.VariableType,
currentExpressionBinding.VariableName);
// Create the property based on the variable in order to apply the equality
var tenantPropertyRightSide = DbExpression.FromInt32(1);
// Create the parameter which is an object representation of a sql parameter.
// We have to create a parameter and not perform a direct comparison with Equal function for example
// as this logic is cached per query and called only once
var tenantParameterRightSide = DbExpressionBuilder.Parameter(TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
FactoryConstants.FactoryOverrideFilterParameterName);
// Apply the equality between property and parameter.
var filterExpressionRightSide = DbExpressionBuilder.Equal(tenantPropertyRightSide, tenantParameterRightSide);
DbExpressionBuilder.
var filterExpression = DbExpressionBuilder.Or(filterExpressionLeftSide, filterExpressionRightSide);
// Apply the filtering to the initial query
return(DbExpressionBuilder.Filter(currentExpressionBinding, filterExpression));
}
return(base.Visit(expression));
}
public override void Visit(DbScanExpression expression)
{
Check.NotNull(expression, "expression");
// we know we won't hit this code unless there is no function defined for this
// ModificationOperation, so if this EntitySet is using a DefiningQuery, instead
// of a table, that is an error
MetadataProperty definingQuery;
if (expression.Target.MetadataProperties.TryGetValue("DefiningQuery", false, out definingQuery)
&&
null != definingQuery.Value)
{
string missingCudElement;
var ict = _commandTree as DbInsertCommandTree;
var dct = _commandTree as DbDeleteCommandTree;
#if DEBUG
var uct = _commandTree as DbUpdateCommandTree;
#endif
if (null != dct)
{
missingCudElement = "DeleteFunction" /*StorageMslConstructs.DeleteFunctionElement*/;
}
else if (null != ict)
{
missingCudElement = "InsertFunction" /*StorageMslConstructs.InsertFunctionElement*/;
}
else
{
#if DEBUG
Debug.Assert(null != uct, "did you add a new option?");
#endif
missingCudElement = "UpdateFunction" /*StorageMslConstructs.UpdateFunctionElement*/;
}
throw ADP1.Update(
EntityRes.GetString(
EntityRes.Update_SqlEntitySetWithoutDmlFunctions,
expression.Target.Name,
missingCudElement,
"ModificationFunctionMapping" /*StorageMslConstructs.ModificationFunctionMappingElement*/),
null);
}
_commandText.Append(SqlGenerator.GetTargetTSql(expression.Target));
}
public override DbExpression Visit(DbScanExpression expression)
{
const string column = "IsActive";
var table = (EntityType)expression.Target.ElementType;
if (!table.Properties.Any(p => p.Name == column))
return base.Visit(expression);
var binding = expression.Bind();
return
binding.Filter(
binding.VariableType.Variable(binding.VariableName)
.Property(column)
.Equal(DbExpression.FromBoolean(true)));
}
public override DbExpression Visit(DbScanExpression expression)
{
var column = SoftDeleteAttribute.GetSoftDeleteColumnName(expression.Target.ElementType);
if (column != null) {
var binding = DbExpressionBuilder.Bind(expression);
return DbExpressionBuilder.Filter(
binding,
DbExpressionBuilder.NotEqual(
DbExpressionBuilder.Property(
DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName),
column),
DbExpression.FromBoolean(true)));
}
else {
return base.Visit(expression);
}
}
public override VisitedExpression Visit(DbPropertyExpression expression)
{
DbVariableReferenceExpression variable = expression.Instance as DbVariableReferenceExpression;
if (variable == null || variable.VariableName != _projectVarName.Peek())
{
throw new NotSupportedException();
}
if (!_processingReturning)
{
return(new PropertyExpression(expression.Property));
}
else
{
// the table name needs to be quoted, the column name does not.
// http://archives.postgresql.org/pgsql-bugs/2007-01/msg00102.php
string tableName = QuoteIdentifier(_variableSubstitution[variable.VariableName]);
if (variable.VariableName == _commandTree.Target.VariableName)
{
// try to get the table name schema qualified.
DbScanExpression scan = _commandTree.Target.Expression as DbScanExpression;
if (scan != null)
{
#if ENTITIES6
System.Data.Entity.Core.Metadata.Edm.MetadataProperty metadata;
#else
System.Data.Metadata.Edm.MetadataProperty metadata;
#endif
string overrideSchema = "http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreSchemaGenerator:Schema";
if (scan.Target.MetadataProperties.TryGetValue(overrideSchema, false, out metadata) && metadata.Value != null)
{
tableName = QuoteIdentifier(metadata.Value.ToString()) + "." + tableName;
}
else if (scan.Target.MetadataProperties.TryGetValue("Schema", false, out metadata) && metadata.Value != null)
{
tableName = QuoteIdentifier(metadata.Value.ToString()) + "." + tableName;
}
else
{
tableName = QuoteIdentifier(scan.Target.EntityContainer.Name) + "." + tableName;
}
}
}
return(new LiteralExpression("currval(pg_get_serial_sequence('" + tableName + "', '" + expression.Property.Name + "'))"));
}
}
public override DbExpression Visit(DbScanExpression expression)
{
var table = (EntityType)expression.Target.ElementType;
if (table.Properties.All(p => p.Name != IsDeletedColumnName) || this.EnableSoftDeleteQuery)
{
return(base.Visit(expression));
}
var binding = expression.Bind();
return(binding.Filter(
binding.VariableType
.Variable(binding.VariableName)
.Property(IsDeletedColumnName)
.NotEqual(DbExpression.FromBoolean(true))));
}
public override DbExpression Visit(DbScanExpression expression)
{
var columnName = SoftDeleteAttribute.GetSoftDeleteColumnName(expression.Target.ElementType);
var entityType = (EntityType)expression.Target.ElementType;
if (columnName == null || entityType.Properties.All(p => p.Name != columnName))
{
return(base.Visit(expression));
}
var binding = expression.Bind();
return(binding.Filter(
binding.VariableType
.Variable(binding.VariableName)
.Property(columnName)
.NotEqual(DbExpression.FromBoolean(true))));
}
public override DbExpression Visit(DbScanExpression expression)
{
const string NAMESPACE = "OrderTest";
var type =
Assembly.GetExecutingAssembly().GetType(string.Format("{0}.{1}", NAMESPACE, expression.Target.Name));
var attribute =
type.GetCustomAttributes(typeof(DefaultOrderFieldAttribute)).SingleOrDefault() as
DefaultOrderFieldAttribute;
if (attribute != null)
{
return(expression.OrderBy(ex => ex.Property(attribute.FieldName)));
}
return(expression);
}
public override DbExpression Visit(DbScanExpression expression)
{
var column = TenantAwareAttribute.GetTenantColumnName(expression.Target.ElementType);
if (!_injectedDynamicFilter && !string.IsNullOrEmpty(column))
{
// Get the current expression
var dbExpression = base.Visit(expression);
// Get the current expression binding
var currentExpressionBinding = DbExpressionBuilder.Bind(dbExpression);
var newFilterExpression = BuildFilterExpression(currentExpressionBinding, null, column);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return base.Visit(newFilterExpression);
}
}
return base.Visit(expression);
}
public override DbExpression Visit(DbScanExpression expression)
{
const string column = "IsActive";
var table = (EntityType)expression.Target.ElementType;
if (!table.Properties.Any(p => p.Name == column))
{
return(base.Visit(expression));
}
var binding = expression.Bind();
return
(binding.Filter(
binding.VariableType.Variable(binding.VariableName)
.Property(column)
.Equal(DbExpression.FromBoolean(true))));
}
public override void Visit(DbScanExpression expression)
{
base.Visit(expression);
Debug.Assert(null != expression.Target);
// Verify scan target is in S-space.
EntitySetBase target = expression.Target;
EntityContainer targetContainer = target.EntityContainer;
Debug.Assert(null != target.EntityContainer);
if ((targetContainer.DataSpace != DataSpace.SSpace))
{
_errors.Add(new EdmSchemaError(System.Data.Entity.Strings.Mapping_UnsupportedScanTarget_QueryView(
_setMapping.Set.Name, target.Name), (int)StorageMappingErrorCode.MappingUnsupportedScanTargetQueryView,
EdmSchemaErrorSeverity.Error, _setMapping.EntityContainerMapping.SourceLocation, _setMapping.StartLineNumber,
_setMapping.StartLinePosition));
}
}
public override SqlFragment Visit(DbScanExpression expression)
{
EntitySetBase target = expression.Target;
TableFragment fragment = new TableFragment();
MetadataProperty property;
bool propExists = target.MetadataProperties.TryGetValue("DefiningQuery", true, out property);
if (propExists && property.Value != null)
{
MetadataProperty prop2;
if (target.MetadataProperties.TryGetValue("http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreSchemaGenerator:Type", true, out prop2) && (prop2.Value as string == "Views"))
{
// avoid storing view query as DefiningQuery because that hurts query fusing.
fragment.Schema = target.MetadataProperties.GetValue("http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreSchemaGenerator:Schema", true).Value as string;
fragment.Table = target.Name;
}
else
{
fragment.DefiningQuery = new LiteralFragment(property.Value as string);
}
}
else
{
fragment.Schema = target.EntityContainer.Name;
fragment.Table = target.Name;
propExists = target.MetadataProperties.TryGetValue("Schema", true, out property);
if (propExists && property.Value != null)
{
fragment.Schema = property.Value as string;
}
propExists = target.MetadataProperties.TryGetValue("Table", true, out property);
if (propExists && property.Value != null)
{
fragment.Table = property.Value as string;
}
}
return(fragment);
}
public override DbExpression Visit(DbScanExpression expression)
{
var column = TenantAwareAttribute.GetTenantColumnName(expression.Target.ElementType);
if (!_injectedDynamicFilter && !string.IsNullOrEmpty(column))
{
// Get the current expression
var dbExpression = base.Visit(expression);
// Get the current expression binding
var currentExpressionBinding = DbExpressionBuilder.Bind(dbExpression);
var newFilterExpression = BuildFilterExpression(currentExpressionBinding, null, column);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return(base.Visit(newFilterExpression));
}
}
return(base.Visit(expression));
}
public override DbExpression Visit(DbScanExpression expression)
{
var column = ColumnAnnotationAttribute.GetColumnName <TrackDeletedBitAttribute>(expression.Target.ElementType);
// var column = TrackDeletedBitAttribute.GetColumnName(expression.Target.ElementType);
if (column != null)
{
var binding = expression.Bind();
return(binding
.Filter(binding.VariableType.Variable(binding.VariableName)
.Property(column)
.NotEqual(DbExpression.FromBoolean(true))
.Or(binding.VariableType.Variable(binding.VariableName)
.Property(column).IsNull())));
}
else
{
return(base.Visit(expression));
}
}
public override DbExpression Visit(DbScanExpression expression)
{
var column = TenantAwareAttribute.GetColumnName(expression.Target.ElementType);
if (column != null)
{
var binding = DbExpressionBuilder.Bind(expression);
return(DbExpressionBuilder.Filter(
binding,
DbExpressionBuilder.NotEqual(
DbExpressionBuilder.Property(
DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName),
column),
DbExpression.FromInt16(1))));
}
else
{
return(base.Visit(expression));
}
}
public override DbExpression Visit(DbScanExpression expression)
{
expression = (DbScanExpression)base.Visit(expression);
var column = UserAwareAttribute.GetUserColumnName(expression.Target.ElementType);
if (!string.IsNullOrEmpty(column))
{
// Check that there is an authenticated user in this context
var principal = Thread.CurrentPrincipal;
var identity = principal.Identity as ClaimsIdentity;
if (identity == null)
{
throw new SecurityException("Unauthenticated access");
}
var userIdclaim = identity.Claims.SingleOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
if (userIdclaim == null)
{
throw new SecurityException("Unauthenticated access");
}
// If it's admin, then no need to filter
if (principal.IsInRole("Administrator"))
{
return(expression);
}
// Get the current expression binding
var currentExpressionBinding = DbExpressionBuilder.Bind(expression);
var newFilterExpression = BuildFilterExpression(currentExpressionBinding, column);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return(newFilterExpression);
}
}
return(expression);
}
public override DbExpression Visit(DbScanExpression expression)
{
var column = SoftDeleteAttribute.GetSoftDeleteColumnName(expression.Target.ElementType);
if (column != null)
{
var table = (EntityType)expression.Target.ElementType;
if (table.Properties.Any(p => p.Name == column))
{
var binding = expression.Bind();
var filter = binding
.VariableType
.Variable(binding.VariableName)
.Property(column)
.NotEqual(DbExpression.FromBoolean(true));
return binding.Filter(filter);
}
}
return base.Visit(expression);
}
public override DbExpression Visit(DbScanExpression expression)
{
var column = SoftDeleteAttribute.GetSoftDeleteColumnName(expression.Target.ElementType);
if (column != null)
{
var table = (EntityType)expression.Target.ElementType;
if (table.Properties.Any(p => p.Name == column))
{
var binding = DbExpressionBuilder.Bind(expression);
return(DbExpressionBuilder.Filter(
binding,
DbExpressionBuilder.NotEqual(
DbExpressionBuilder.Property(
DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName),
column),
DbExpression.FromBoolean(true))));
}
}
return(base.Visit(expression));
}
private string CreateNewAlias(DbExpression expr)
{
DbScanExpression dbScanExpression = expr as DbScanExpression;
if (dbScanExpression != null)
{
return(dbScanExpression.Target.Name);
}
DbPropertyExpression propertyExpression = expr as DbPropertyExpression;
if (propertyExpression != null)
{
return(propertyExpression.Property.Name);
}
DbVariableReferenceExpression referenceExpression = expr as DbVariableReferenceExpression;
if (referenceExpression != null)
{
return(referenceExpression.VariableName);
}
return(this.GenerateInternalName(string.Empty));
}
public override void Visit(DbScanExpression scanExpression)
{
DebugCheck.NotNull(scanExpression);
var tableSql
= SqlGenerator.GetTargetTSql(scanExpression.Target)
+ " AS "
+ (_currentTableAlias = "t" + _aliasCount++);
var table = scanExpression.Target.ElementType;
if (_from.Length == 0)
{
_baseTable = (EntityType)table;
_from.Append("FROM ");
_from.Append(tableSql);
}
else
{
_from.AppendLine();
_from.Append("JOIN ");
_from.Append(tableSql);
_from.Append(" ON ");
for (var i = 0; i < table.KeyMembers.Count; i++)
{
if (i > 0)
{
_from.Append(" AND ");
}
_from.Append(_currentTableAlias + ".");
_from.Append(SqlGenerator.QuoteIdentifier(table.KeyMembers[i].Name));
_from.Append(" = t0.");
_from.Append(SqlGenerator.QuoteIdentifier(_baseTable.KeyMembers[i].Name));
}
}
}
public override DbExpression Visit(DbScanExpression expression)
{
var columnName = SoftDeleteAttibute.GetSoftDeleteColumnName(expression.Target.ElementType);
if (!string.IsNullOrEmpty(columnName))
{
var table = (EntityType)expression.Target.ElementType;
if (table.Properties.Any(p => p.Name == columnName))
{
var binding = DbExpressionBuilder.Bind(expression);
return DbExpressionBuilder.Filter(
binding,
DbExpressionBuilder.NotEqual(
DbExpressionBuilder.Property(
DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName),
columnName),
DbExpression.FromBoolean(true)));
}
}
return base.Visit(expression);
}
public override DbExpression Visit(DbScanExpression expression)
{
// This method will be called for all query expressions. If there is a filter included (in a .Where() for example),
// Visit(DbFilterExpression) will be called first and our dynamic filters will have already been included.
// Otherwise, we do that here.
string entityName = expression.Target.Name;
var filterList = FindFiltersForEntitySet(expression.Target.ElementType.MetadataProperties, expression.Target.EntityContainer);
var baseResult = base.Visit(expression);
if (filterList.Any())
{
var binding = DbExpressionBuilder.Bind(baseResult);
var newFilterExpression = BuildFilterExpressionWithDynamicFilters(entityName, filterList, binding, null);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return newFilterExpression;
}
}
return baseResult;
}
public override DbExpression Visit(DbScanExpression expression)
{
expression = (DbScanExpression)base.Visit(expression);
var column = UserAwareAttribute.GetUserColumnName(expression.Target.ElementType);
if (!string.IsNullOrEmpty(column))
{
// Validate user
Security.ValidateCurrentUser();
// Get the current expression binding
var currentExpressionBinding = DbExpressionBuilder.Bind(expression);
var newFilterExpression = BuildFilterExpression(currentExpressionBinding, column);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return(newFilterExpression);
}
}
return(expression);
}
public override DbExpression Visit(DbScanExpression expression)
{
#if DEBUG_VISITS
System.Diagnostics.Debug.Print("Visit(DbScanExpression): Target.Name={0}", expression.Target.Name);
#endif
// If using SSpace:
// This method will be called for all query expressions. If there is a filter included (in a .Where() for example),
// Visit(DbFilterExpression) will be called first and our dynamic filters will have already been included.
// Otherwise, we do that here.
// If using CSpace:
// This method will only be called for the initial entity. Any other references to other entities will be
// handled by the Visit(DbPropertyExpression) - this includes filter references and includes.
var baseResult = base.Visit(expression);
if (_IgnoreNextDbScan)
{
_IgnoreNextDbScan = false;
return(baseResult);
}
string entityName = expression.Target.Name;
var filterList = FindFiltersForEntitySet(expression.Target.ElementType.MetadataProperties, expression.Target.EntityContainer);
if (filterList.Any())
{
var binding = DbExpressionBuilder.Bind(baseResult);
var newFilterExpression = BuildFilterExpressionWithDynamicFilters(entityName, filterList, binding, null);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return(newFilterExpression);
}
}
return(baseResult);
}
public override DbExpression Visit(DbScanExpression expression)
{
// This method will be called for all query expressions. If there is a filter included (in a .Where() for example),
// Visit(DbFilterExpression) will be called first and our dynamic filters will have already been included.
// Otherwise, we do that here.
string entityName = expression.Target.Name;
var filterList = FindFiltersForEntitySet(expression.Target.ElementType.MetadataProperties, expression.Target.EntityContainer);
var baseResult = base.Visit(expression);
if (filterList.Any())
{
var binding = DbExpressionBuilder.Bind(baseResult);
var newFilterExpression = BuildFilterExpressionWithDynamicFilters(entityName, filterList, binding, null);
if (newFilterExpression != null)
{
// If not null, a new DbFilterExpression has been created with our dynamic filters.
return(newFilterExpression);
}
}
return(baseResult);
}
public override DbExpression Visit(DbScanExpression expression)
{
var table = (EntityType)expression.Target.ElementType;
if (table.Properties.All(p => p.Name != IsDeletedColumnName))
{
return(base.Visit(expression));
}
DbExpression newConditionExpression = null;
var binding = expression.Bind();
if (table.Properties.Any(p => p.Name == IsDeletedColumnName))
{
var param = DbExpression.FromBoolean(false);
var columnProperty = DbExpressionBuilder.Property(DbExpressionBuilder.Variable(binding.VariableType, binding.VariableName), IsDeletedColumnName);
if ((columnProperty.ResultType.EdmType.FullName == "Edm.Boolean") &&
param.ResultType.EdmType.FullName.StartsWith("Oracle", StringComparison.CurrentCultureIgnoreCase) && (param.ResultType.EdmType.Name == "number"))
{
newConditionExpression = DbExpressionBuilder.Equal(DbExpressionBuilder.CastTo(columnProperty, param.ResultType), param);
}
else
{
newConditionExpression = DbExpressionBuilder.Equal(columnProperty, param);
}
}
return(DbExpressionBuilder.Filter(binding, newConditionExpression));
//return binding.Filter(
// binding.VariableType
// .Variable(binding.VariableName)
// .Property(IsDeletedColumnName)
// .Equal(DbExpression.FromBoolean(false)));
}
/** <inheritdoc /> */
public override void Visit(DbScanExpression expression)
{
_entitySets.Add(expression.Target);
base.Visit(expression);
}
public override bool Visit(DbScanExpression expression)
{
return(false);
}
public override void Visit(DbScanExpression expression)
{
string definingQuery = MetadataHelpers.TryGetValueForMetadataProperty<string>(expression.Target, "DefiningQuery");
if (definingQuery != null)
{
throw new NotSupportedException(String.Format("Unable to update the EntitySet '{0}' because it has a DefiningQuery and no <{1}> element exists in the <ModificationFunctionMapping> element to support the current operation.", expression.Target.Name, _kind));
}
_commandText.Append(SqlGenerator.GetTargetTSql(expression.Target));
}
public override void Visit(DbScanExpression expression)
{
// we know we won't hit this code unless there is no function defined for this
// ModificationOperation, so if this EntitySet is using a DefiningQuery, instead
// of a table, that is an error
if (expression.Target.DefiningQuery != null)
{
string missingCudElement;
if (_commandTree.CommandTreeKind == DbCommandTreeKind.Delete)
{
missingCudElement = StorageMslConstructs.DeleteFunctionElement;
}
else if (_commandTree.CommandTreeKind == DbCommandTreeKind.Insert)
{
missingCudElement = StorageMslConstructs.InsertFunctionElement;
}
else
{
Debug.Assert(_commandTree.CommandTreeKind == DbCommandTreeKind.Update, "did you add a new option?");
missingCudElement = StorageMslConstructs.UpdateFunctionElement;
}
throw EntityUtil.Update(System.Data.Entity.Strings.Update_SqlEntitySetWithoutDmlFunctions(expression.Target.Name, missingCudElement, StorageMslConstructs.ModificationFunctionMappingElement), null);
}
_commandText.Append(SqlGenerator.GetTargetTSql(expression.Target));
}
/// <summary> /// Visitor pattern method for DbScanExpression. /// </summary> /// <param name="expression"> The DbScanExpression that is being visited. </param> public abstract void Visit(DbScanExpression expression);
/// <summary>
/// Visitor pattern method for <see cref="DbScanExpression" />.
/// </summary>
/// <param name="expression"> The DbScanExpression that is being visited. </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="expression" />
/// is null
/// </exception>
public override void Visit(DbScanExpression expression)
{
Check.NotNull(expression, "expression");
}
public override void Visit(DbScanExpression expression) { }
public override void Visit(DbScanExpression expression)
{
// we know we won't hit this code unless there is no function defined for this
// ModificationOperation, so if this EntitySet is using a DefiningQuery, instead
// of a table, that is an error
if (expression.Target.GetMetadataPropertyValue<string>("DefiningQuery") != null)
{
string missingCudElement;
if (_commandTree is DbDeleteCommandTree)
{
missingCudElement = "DeleteFunction";
}
else if (_commandTree is DbInsertCommandTree)
{
missingCudElement = "InsertFunction";
}
else
{
Contract.Assert(_commandTree is DbUpdateCommandTree);
missingCudElement = "UpdateFunction";
}
throw new UpdateException(
Strings.Update_SqlEntitySetWithoutDmlFunctions(
expression.Target.Name, missingCudElement, "ModificationFunctionMapping"));
}
_commandText.Append(SqlGenerator.GetTargetTSql(expression.Target));
}
public override void Visit(DbScanExpression e)
{
Begin(e);
Begin("Target", "Name", e.Target.Name, "Container", e.Target.EntityContainer.Name);
Dump(e.Target.ElementType, "TargetElementType");
End("Target");
End(e);
}
/// <summary>
/// Implements the visitor pattern for the command tree.
/// </summary>
/// <param name="expression">Represents a scan of all elements of a given entity set.</param>
public override void Visit(DbScanExpression expression)
{
var type = getEntityType(expression.Target);
if (type != null) _entityClrTypes.Add(type);
base.Visit(expression);
}
/// <summary>
/// Visitor pattern method for <see cref="DbScanExpression" />.
/// </summary>
/// <param name="expression"> The DbScanExpression that is being visited. </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="expression" />
/// is null
/// </exception>
public override void Visit(DbScanExpression expression)
{
// #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here.
Check.NotNull(expression, "expression");
}
/// <summary>
/// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbScanExpression"/>.
/// </summary>
/// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbScanExpression"/> that is visited.</param>
public override void Visit(DbScanExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
base.Visit(expression);
this.affectedEntitySets.Add(expression.Target);
}
public override void Visit(DbScanExpression scanExpression)
{
DebugCheck.NotNull(scanExpression);
var tableSql
= SqlGenerator.GetTargetTSql(scanExpression.Target)
+ " AS "
+ (_currentTableAlias = "t" + _aliasCount++);
var table = scanExpression.Target.ElementType;
if (_from.Length == 0)
{
_baseTable = (EntityType)table;
_from.Append("FROM ");
_from.Append(tableSql);
}
else
{
_from.AppendLine();
_from.Append("JOIN ");
_from.Append(tableSql);
_from.Append(" ON ");
for (var i = 0; i < table.KeyMembers.Count; i++)
{
if (i > 0)
{
_from.Append(" AND ");
}
_from.Append(_currentTableAlias + ".");
_from.Append(SqlGenerator.QuoteIdentifier(table.KeyMembers[i].Name));
_from.Append(" = t0.");
_from.Append(SqlGenerator.QuoteIdentifier(_baseTable.KeyMembers[i].Name));
}
}
}
/** <inheritdoc /> */
public override void Visit(DbScanExpression expression)
{
_entitySets.Add(expression.Target);
base.Visit(expression);
}
public override void Visit(DbScanExpression expression)
{
commandText.Append(SqlGenerator.GetTargetSql(expression.Target));
}
public override DbExpressionEntitySetInfo Visit(DbScanExpression expression)
{
return(null);
}
public override void Visit(DbScanExpression e)
{
VisitExprKind(e.ExpressionKind);
_key.Append('(');
_key.Append(e.Target.EntityContainer.Name);
_key.Append('.');
_key.Append(e.Target.Name);
_key.Append(':');
_key.Append(e.ResultType.EdmType.Identity);
_key.Append(')');
}
public override void Visit(DbScanExpression expression)
{
// we know we won't hit this code unless there is no function defined for this
// ModificationOperation, so if this EntitySet is using a DefiningQuery, instead
// of a table, that is an error
MetadataProperty definingQuery;
if (expression.Target.MetadataProperties.TryGetValue("DefiningQuery", false, out definingQuery)
&&
null != definingQuery.Value)
{
string missingCudElement;
var ict = _commandTree as DbInsertCommandTree;
var dct = _commandTree as DbDeleteCommandTree;
#if DEBUG
var uct = _commandTree as DbUpdateCommandTree;
#endif
if (null != dct)
{
missingCudElement = "DeleteFunction" /*StorageMslConstructs.DeleteFunctionElement*/;
}
else if (null != ict)
{
missingCudElement = "InsertFunction" /*StorageMslConstructs.InsertFunctionElement*/;
}
else
{
#if DEBUG
Debug.Assert(null != uct, "did you add a new option?");
#endif
missingCudElement = "UpdateFunction" /*StorageMslConstructs.UpdateFunctionElement*/;
}
throw ADP1.Update(
EntityRes.GetString(
EntityRes.Update_SqlEntitySetWithoutDmlFunctions,
expression.Target.Name,
missingCudElement,
"ModificationFunctionMapping" /*StorageMslConstructs.ModificationFunctionMappingElement*/),
null);
}
_commandText.Append(SqlGenerator.GetTargetTSql(expression.Target));
}
public override void Visit(DbScanExpression expression)
{
Contract.Requires(expression != null);
}
