Ejemplo n.º 1
0
        public ColumnModification(
            [NotNull] IUpdateEntry entry,
            [NotNull] IProperty property,
            [NotNull] IRelationalPropertyAnnotations propertyAnnotations,
            [NotNull] Func <string> generateParameterName,
            bool isRead,
            bool isWrite,
            bool isKey,
            bool isCondition,
            bool isConcurrencyToken)
        {
            Check.NotNull(entry, nameof(entry));
            Check.NotNull(property, nameof(property));
            Check.NotNull(propertyAnnotations, nameof(propertyAnnotations));
            Check.NotNull(generateParameterName, nameof(generateParameterName));

            Entry                  = entry;
            Property               = property;
            ColumnName             = propertyAnnotations.ColumnName;
            _generateParameterName = generateParameterName;
            IsRead                 = isRead;
            IsWrite                = isWrite;
            IsKey                  = isKey;
            IsCondition            = isCondition;
            IsConcurrencyToken     = isConcurrencyToken;
        }
        /// <summary>
        ///     Creates a new <see cref="ColumnModification" /> instance.
        /// </summary>
        /// <param name="entry"> The <see cref="IUpdateEntry" /> that represents the entity that is being modified. </param>
        /// <param name="property"> The property that maps to the column. </param>
        /// <param name="propertyAnnotations"> Provides access to relational-specific annotations for the column. </param>
        /// <param name="generateParameterName"> A delegate for generating parameter names for the update SQL. </param>
        /// <param name="isRead"> Indicates whether or not a value must be read from the database for the column. </param>
        /// <param name="isWrite"> Indicates whether or not a value must be written to the database for the column. </param>
        /// <param name="isKey"> Indicates whether or not the column part of a primary or alternate key.</param>
        /// <param name="isCondition"> Indicates whether or not the column is used in the <c>WHERE</c> clause when updating. </param>
        /// <param name="isConcurrencyToken"> Indicates whether or not the column is acting as an optimistic concurrency token. </param>
        public ColumnModification(
            [NotNull] IUpdateEntry entry,
            [NotNull] IProperty property,
            [NotNull] IRelationalPropertyAnnotations propertyAnnotations,
            [NotNull] Func <string> generateParameterName,
            bool isRead,
            bool isWrite,
            bool isKey,
            bool isCondition,
            bool isConcurrencyToken)
            : this(
                Check.NotNull(propertyAnnotations, nameof(propertyAnnotations)).ColumnName,
                originalValue : null,
                value : null,
                property : property,
                isRead : isRead,
                isWrite : isWrite,
                isKey : isKey,
                isCondition : isCondition)
        {
            Check.NotNull(entry, nameof(entry));
            Check.NotNull(property, nameof(property));
            Check.NotNull(generateParameterName, nameof(generateParameterName));

            Entry = entry;
            IsConcurrencyToken     = isConcurrencyToken;
            _generateParameterName = generateParameterName;
            _useParameters         = true;
        }
Ejemplo n.º 3
0
        public ColumnModification(
            [NotNull] IUpdateEntry entry,
            [NotNull] IProperty property,
            [NotNull] IRelationalPropertyAnnotations propertyAnnotations,
            [NotNull] ParameterNameGenerator parameterNameGenerator,
            bool isRead,
            bool isWrite,
            bool isKey,
            bool isCondition)
        {
            Check.NotNull(entry, nameof(entry));
            Check.NotNull(property, nameof(property));
            Check.NotNull(propertyAnnotations, nameof(propertyAnnotations));
            Check.NotNull(parameterNameGenerator, nameof(parameterNameGenerator));

            Entry      = entry;
            Property   = property;
            ColumnName = propertyAnnotations.ColumnName;

            _parameterName = isWrite
                ? new LazyRef <string>(parameterNameGenerator.GenerateNext)
                : new LazyRef <string>((string)null);
            _originalParameterName = isCondition
                ? new LazyRef <string>(parameterNameGenerator.GenerateNext)
                : new LazyRef <string>((string)null);
            _outputParameterName = isRead
                ? new LazyRef <string>(parameterNameGenerator.GenerateNext)
                : new LazyRef <string>((string)null);

            IsRead      = isRead;
            IsWrite     = isWrite;
            IsKey       = isKey;
            IsCondition = isCondition;
        }
        /// <summary>
        /// Oracle值生成策略
        /// </summary>
        /// <param name="fallbackToModel">回退模式</param>
        /// <returns></returns>
        public virtual OracleValueGenerationStrategy?GetOracleValueGenerationStrategy(bool fallbackToModel)
        {
            OracleValueGenerationStrategy?result = (OracleValueGenerationStrategy?)Annotations.Metadata[OracleAnnotationNames.ValueGenerationStrategy];

            if (result.HasValue)
            {
                return(result);
            }
            IRelationalPropertyAnnotations relationalPropertyAnnotations = Property.Relational();

            if (!fallbackToModel || Property.ValueGenerated != ValueGenerated.OnAdd || relationalPropertyAnnotations.DefaultValue != null || relationalPropertyAnnotations.DefaultValueSql != null || relationalPropertyAnnotations.ComputedColumnSql != null)
            {
                return(null);
            }
            OracleValueGenerationStrategy?valueGenerationStrategy = Property.DeclaringEntityType.Model.Oracle().ValueGenerationStrategy;

            if (valueGenerationStrategy == OracleValueGenerationStrategy.SequenceHiLo && IsCompatibleSequenceHiLo(Property))
            {
                return(OracleValueGenerationStrategy.SequenceHiLo);
            }
            if (valueGenerationStrategy == OracleValueGenerationStrategy.IdentityColumn && IsCompatibleIdentityColumn(Property))
            {
                return(OracleValueGenerationStrategy.IdentityColumn);
            }
            return(null);
        }
Ejemplo n.º 5
0
        public override TableMetaInfo GetTableMetaInfo(Type type)
        {
            IModel      model      = db.Model;
            IEntityType entityType = model.FindEntityType(type);

            IEntityType[] allEntityTypes   = model.GetEntityTypes().ToArray();
            IProperty[]   entityProperties = entityType.GetProperties().ToArray();

            IRelationalEntityTypeAnnotations mapping = entityType.Relational();

            EFPropertyInfo[] pProperties = new EFPropertyInfo[entityProperties.Length];

            // Column info
            for (int i = 0; i < entityProperties.Length; i++)               // (var property in entityProperties) {
            {
                IProperty prop = entityProperties[i];

                IRelationalPropertyAnnotations rProp = prop.Relational();

                if (rProp == null || rProp.ColumnName.IsNulle())
                {
                    continue;
                }

                bool isIndex = prop.IsIndex();
                var  idx1    = prop.GetContainingKeys().ToArray();

                EFPropertyInfo pInfo = new EFPropertyInfo()
                {
                    EntityName   = prop.Name,
                    ColumnName   = rProp.ColumnName,
                    IsIdentity   = false,
                    IsKey        = prop.IsKey(),
                    IsIndex      = isIndex,
                    IsPrimaryKey = prop.IsPrimaryKey()
                };

                string columnType = rProp.ColumnType;

                pProperties[i] = pInfo;
            }
            ;


            var info = new TableMetaInfo()
            {
                TableName           = mapping.TableName,                                                                //table.Table, // watch out! not table.Name
                TableSchema         = mapping.Schema,                                                                   //table.Schema,
                TypeNameFull        = entityType.Name,                                                                  // or: == type.FullName,
                TypeName            = type.Name,
                TableColumnNames    = pProperties.Select(p => p.ColumnName).Where(n => n.NotNulle()).ToArray(),         //declaredProps.Select(dp => dp.Name).ToArray(),
                EntityPropertyNames = pProperties.Select(p => p.EntityName).Where(n => n.NotNulle()).ToArray(),         //mapped.Select(dd => dd.Name).ToArray()
                KeyColumnNames      = pProperties.Where(p => p != null && p.IsKey).Select(p => p.ColumnName).ToArray(), // table.ElementType.KeyMembers.Select(m => m.Name).ToArray(),
            };

            return(info);
        }
        public IEnumerable <ColumnMapping <TEntity> > GetColumns()
        {
            foreach (IProperty property in _entityType.GetProperties())
            {
                IRelationalPropertyAnnotations relationalProperty = property.Relational();

                bool isKey = _entityType.FindPrimaryKey().Properties.Contains(property);

                _relationSqlTypeTranslator.GetMetaData(relationalProperty.ColumnType, out int?precision, out int?scale, out System.Data.DbType dbType);

                yield return(new ColumnMapping <TEntity>(
                                 dbColumnName: relationalProperty.ColumnName,
                                 dbType: dbType,
                                 isIdentity: property.ValueGenerated == ValueGenerated.OnAdd,
                                 propertyInfo: typeof(TEntity).GetProperty(property.Name),
                                 precision: precision,
                                 isRequired: !property.IsNullable,
                                 length: property.GetMaxLength(),
                                 scale: scale
                                 ));
            }
        }
Ejemplo n.º 7
0
 public static DatabaseColumn GetColumn(this DatabaseModel model, IRelationalEntityTypeAnnotations table, IRelationalPropertyAnnotations column)
 {
     return(GetColumn(model, table.Schema, table.TableName, column.ColumnName));
 }
Ejemplo n.º 8
0
 public static bool ColumnExists(this DatabaseModel model,
                                 IRelationalEntityTypeAnnotations table,
                                 IRelationalPropertyAnnotations column)
 {
     return(ColumnExists(model, table.Schema, table.TableName, column.ColumnName));
 }