private static void InitializeSharedColumns(IUpdateEntry entry, bool updating, Dictionary <string, ColumnValuePropagator> columnMap)
        {
            foreach (var property in entry.EntityType.GetProperties())
            {
                var columnName = property.GetColumnName();
                if (!columnMap.TryGetValue(columnName, out var columnPropagator))
                {
                    columnPropagator = new ColumnValuePropagator();
                    columnMap.Add(columnName, columnPropagator);
                }

                if (updating)
                {
                    columnPropagator.RecordValue(property, entry);
                }
            }
        }
Пример #2
0
        private void InitializeSharedColumns(
            IUpdateEntry entry, ITableMappingBase tableMapping, bool updating, Dictionary <string, ColumnValuePropagator> columnMap)
        {
            foreach (var columnMapping in tableMapping.ColumnMappings)
            {
                var columnName = columnMapping.Column.Name;
                if (!columnMap.TryGetValue(columnName, out var columnPropagator))
                {
                    columnPropagator = new ColumnValuePropagator();
                    columnMap.Add(columnName, columnPropagator);
                }

                if (updating)
                {
                    columnPropagator.RecordValue(columnMapping.Property, entry);
                }
            }
        }
Пример #3
0
        private void InitializeSharedColumns(IUpdateEntry entry, bool updating, Dictionary <string, ColumnValuePropagator> columnMap)
        {
            foreach (var property in entry.EntityType.GetProperties())
            {
                var columnName = property.FindColumn(StoreObjectIdentifier.Table(TableName, Schema))?.Name;
                if (columnName == null)
                {
                    continue;
                }

                if (!columnMap.TryGetValue(columnName, out var columnPropagator))
                {
                    columnPropagator = new ColumnValuePropagator();
                    columnMap.Add(columnName, columnPropagator);
                }

                if (updating)
                {
                    columnPropagator.RecordValue(property, entry);
                }
            }
        }
Пример #4
0
        private IReadOnlyList <ColumnModification> GenerateColumnModifications()
        {
            var state               = EntityState;
            var adding              = state == EntityState.Added;
            var updating            = state == EntityState.Modified;
            var columnModifications = new List <ColumnModification>();
            Dictionary <string, ColumnValuePropagator> sharedTableColumnMap = null;

            if (_entries.Count > 1 ||
                (_entries.Count == 1 && _entries[0].SharedIdentityEntry != null))
            {
                sharedTableColumnMap = new Dictionary <string, ColumnValuePropagator>();

                if (_comparer != null)
                {
                    _entries.Sort(_comparer);
                }

                foreach (var entry in _entries)
                {
                    var tableMapping = GetTableMapping(entry.EntityType);
                    if (tableMapping == null)
                    {
                        continue;
                    }

                    if (entry.SharedIdentityEntry != null)
                    {
                        var sharedTableMapping = GetTableMapping(entry.SharedIdentityEntry.EntityType);
                        if (sharedTableMapping != null)
                        {
                            InitializeSharedColumns(entry.SharedIdentityEntry, sharedTableMapping, updating, sharedTableColumnMap);
                        }
                    }

                    InitializeSharedColumns(entry, tableMapping, updating, sharedTableColumnMap);
                }
            }

            foreach (var entry in _entries)
            {
                var nonMainEntry = updating &&
                                   (entry.EntityState == EntityState.Deleted ||
                                    entry.EntityState == EntityState.Added);

                var tableMapping = GetTableMapping(entry.EntityType);
                if (tableMapping == null)
                {
                    continue;
                }

                foreach (var columnMapping in tableMapping.ColumnMappings)
                {
                    var property    = columnMapping.Property;
                    var column      = (IColumn)columnMapping.Column;
                    var isKey       = property.IsPrimaryKey();
                    var isCondition = !adding && (isKey || property.IsConcurrencyToken);
                    var readValue   = state != EntityState.Deleted && entry.IsStoreGenerated(property);

                    ColumnValuePropagator columnPropagator = null;
                    sharedTableColumnMap?.TryGetValue(column.Name, out columnPropagator);

                    var writeValue = false;
                    if (!readValue)
                    {
                        if (adding)
                        {
                            writeValue = property.GetBeforeSaveBehavior() == PropertySaveBehavior.Save;
                        }
                        else if ((updating && property.GetAfterSaveBehavior() == PropertySaveBehavior.Save) ||
                                 (!isKey && nonMainEntry))
                        {
                            writeValue = columnPropagator?.TryPropagate(property, entry)
                                         ?? entry.IsModified(property);
                        }
                    }

                    if (readValue ||
                        writeValue ||
                        isCondition)
                    {
                        if (readValue)
                        {
                            _requiresResultPropagation = true;
                        }

                        var columnModification = new ColumnModification(
                            entry,
                            property,
                            column,
                            _generateParameterName,
                            columnMapping.TypeMapping,
                            readValue,
                            writeValue,
                            isKey,
                            isCondition,
                            _sensitiveLoggingEnabled);

                        if (columnPropagator != null &&
                            column.PropertyMappings.Count() != 1)
                        {
                            if (columnPropagator.ColumnModification != null)
                            {
                                columnPropagator.ColumnModification.AddSharedColumnModification(columnModification);

                                continue;
                            }

                            columnPropagator.ColumnModification = columnModification;
                        }

                        columnModifications.Add(columnModification);
                    }
                }
            }

            return(columnModifications);
        }