internal static DbType GetDbType(PrimitiveTypeKind primitiveType)
 {
     switch (primitiveType)
     {
         case PrimitiveTypeKind.Binary:
             return DbType.Binary;
         case PrimitiveTypeKind.Boolean:
             return DbType.Boolean;
         case PrimitiveTypeKind.Byte:
             return DbType.Byte;
         case PrimitiveTypeKind.DateTime:
             return DbType.DateTime;
         case PrimitiveTypeKind.Decimal:
             return DbType.Decimal;
         case PrimitiveTypeKind.Double:
             return DbType.Double;
         case PrimitiveTypeKind.Single:
             return DbType.Single;
         case PrimitiveTypeKind.Guid:
             return DbType.Guid;
         case PrimitiveTypeKind.Int16:
             return DbType.Int16;
         case PrimitiveTypeKind.Int32:
             return DbType.Int32;
         case PrimitiveTypeKind.Int64:
             return DbType.Int64;
         case PrimitiveTypeKind.String:
             return DbType.String;
         default:
             Debug.Fail("unknown PrimitiveTypeKind" + primitiveType.ToString());
             throw ADP1.InvalidOperation(String.Empty);
     }
 }

        internal void AddAggregate(
            PrimitiveTypeKind returnTypeKind, string aggregateFunctionName, PrimitiveTypeKind collectionArgumentElementTypeKind)
        {
            DebugCheck.NotEmpty(aggregateFunctionName);

            var returnParameter = CreateReturnParameter(returnTypeKind);
            var collectionParameter = CreateAggregateParameter(collectionArgumentElementTypeKind);

            var function = new EdmFunction(
                aggregateFunctionName,
                EdmConstants.EdmNamespace,
                DataSpace.CSpace,
                new EdmFunctionPayload
                    {
                        IsAggregate = true,
                        IsBuiltIn = true,
                        ReturnParameters = new[] { returnParameter },
                        Parameters = new FunctionParameter[1] { collectionParameter },
                        IsFromProviderManifest = true,
                    });

            function.SetReadOnly();

            functions.Add(function);
        }

 private static Facet CreateConstFacet(string facetName, PrimitiveTypeKind facetTypeKind, object value)
 {
     return Facet.Create(
         new FacetDescription(
             facetName, PrimitiveType.GetEdmPrimitiveType(facetTypeKind),
             null, null, value, true, null), value);
 }

 /// <summary>
 ///     Initializes a new instance of the  class.
 /// </summary>
 /// <param name = "type">The data type for this column.</param>
 /// <param name = "typeUsage">
 ///     Additional details about the data type.
 ///     This includes details such as maximum length, nullability etc.
 /// </param>
 public ColumnModel(PrimitiveTypeKind type, TypeUsage typeUsage)
 {
     _type = type;
     _typeUsage = typeUsage;
     _clrType = PrimitiveType.GetEdmPrimitiveType(_type).ClrEquivalentType;
     _clrDefaultValue = CreateDefaultValue();
 }

 /// <summary>
 ///     Translate a conceptual primitive type to an adequate store specific primitive type according to the
 ///     provider configuration of the model.
 /// </summary>
 /// <param name="model">A DbModel instance with provider information</param>
 /// <param name="typeKind">A PrimitiveTypeKind instance representing the conceptual primitive type to be translated</param>
 /// <returns>An EdmType instance representing the store primitive type</returns>
 public static EdmType GetStorePrimitiveType( this DbModel model, PrimitiveTypeKind typeKind )
 {
     return model
         .ProviderManifest
         .GetStoreType(
             TypeUsage.CreateDefaultTypeUsage(
                 PrimitiveType.GetEdmPrimitiveType( typeKind ) ) ).EdmType;
 }

 internal static bool IsPrimitiveType(TypeUsage type, PrimitiveTypeKind primitiveType)
 {
     PrimitiveTypeKind typeKind;
     if (TypeHelpers.TryGetPrimitiveTypeKind(type, out typeKind))
     {
         return (typeKind == primitiveType);
     }
     return false;
 }

        public static string GetStoreTypeName(
            this DbProviderManifest providerManifest, PrimitiveTypeKind primitiveTypeKind)
        {
            Contract.Requires(providerManifest != null);

            var edmTypeUsage = TypeUsage.CreateDefaultTypeUsage(
                PrimitiveType.GetEdmPrimitiveType(primitiveTypeKind));

            return providerManifest.GetStoreType(edmTypeUsage).EdmType.Name;
        }

            private static void Check_result_for_basic_type(PrimitiveTypeKind primitiveTypeKind, object defaultValue)
            {
                var primitiveType = PrimitiveType.GetEdmPrimitiveType(primitiveTypeKind);
                PropagatorResult result;

                Propagator.ExtentPlaceholderCreator.GetPropagatorResultForPrimitiveType(primitiveType, out result);

                Assert.NotNull(result);
                Assert.Equal(true, result.IsSimple);
                Assert.Equal(defaultValue, result.GetSimpleValue());
            }

 /// <summary>
 /// 动态设置实体字段的值
 /// </summary>
 /// <param name="entry">ObjectStateEntry 实体封装对象</param>
 /// <param name="osm">对象缓冲</param>
 /// <param name="FieldName">字段名</param>
 /// <param name="EDMType">字段类型</param>
 /// <param name="Value">字段值</param>
 internal static void FixupModifiedDates(this ObjectStateEntry entry, ObjectStateManager osm, string FieldName, PrimitiveTypeKind EDMType, object Value)
 {
     var fieldMetaData = entry.CurrentValues.DataRecordInfo.FieldMetadata;
     FieldMetadata modifiedField = fieldMetaData
         .Where(f => f.FieldType.Name == FieldName)
         .FirstOrDefault();
     if (modifiedField.FieldType != null)
     {
         string fieldTypeName = modifiedField.FieldType.TypeUsage.EdmType.Name;
         if (fieldTypeName == EDMType.ToString())
         {
             entry.CurrentValues.SetValue(modifiedField.Ordinal, Value);
         }
     }
 }

        public void GenerateCanOutputAddColumnStatement(PrimitiveTypeKind type, string typeName)
        {
            var migrationSqlGenerator = new PostgreSqlMigrationSqlGenerator();

            var column = new ColumnModel(type)
            {
                Name = "Bar",
                IsIdentity = true
            };
            var addColumnOperation = new AddColumnOperation("Foo", column);

            var sql = migrationSqlGenerator.Generate(
                new[] { addColumnOperation }, "9.2").Join(s => s.Sql, Environment.NewLine);

            Assert.True(sql.Contains(string.Format("ALTER TABLE \"Foo\" ADD \"Bar\" {0}", typeName)));
        }

        private static string HandlIdentity_adds_cast_for_identity_columns(PrimitiveTypeKind primitiveTypeKind)
        {
            var typeUsage = ProviderRegistry.SqlCe4_ProviderManifest.GetStoreType(
                TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(primitiveTypeKind)));

            var mockMember = new Mock<EdmMember>();
            mockMember.Setup(m => m.TypeUsage).Returns(typeUsage);

            var mockTransalator = new Mock<DmlSqlGenerator.ExpressionTranslator>();
            mockTransalator.Setup(m => m.MemberValues).Returns(new Dictionary<EdmMember, DbParameter>());

            var builder = new SqlStringBuilder();
            DmlSqlGenerator.HandleIdentity(builder, mockTransalator.Object, mockMember.Object, false, new Mock<EntitySetBase>().Object);

            return builder.ToString();
        }

            private static void Check_result_for_geometry_type(PrimitiveTypeKind primitiveTypeKind, object wellKnownText)
            {
                var primitiveType = PrimitiveType.GetEdmPrimitiveType(primitiveTypeKind);
                PropagatorResult result;

                Propagator.ExtentPlaceholderCreator.GetPropagatorResultForPrimitiveType(primitiveType, out result);

                Assert.NotNull(result);
                Assert.Equal(true, result.IsSimple);

                var geometry = result.GetSimpleValue() as DbGeometry;

                Assert.NotNull(geometry);
                Assert.NotNull(geometry.WellKnownValue);
                Assert.Equal(wellKnownText, geometry.WellKnownValue.WellKnownText);
            }

 internal static DbType GetDbType(PrimitiveTypeKind _primitiveType)
 {
     switch (_primitiveType)
     {
         case PrimitiveTypeKind.Binary:
             return DbType.Binary;
         case PrimitiveTypeKind.Boolean:
             return DbType.Boolean;
         case PrimitiveTypeKind.Byte:
             return DbType.Byte;
         case PrimitiveTypeKind.SByte:
             return DbType.SByte;
         case PrimitiveTypeKind.DateTime:
             return DbType.DateTime;
         case PrimitiveTypeKind.DateTimeOffset:
             return DbType.DateTimeOffset;
         case PrimitiveTypeKind.Decimal:
             return DbType.Decimal;
         case PrimitiveTypeKind.Double:
             return DbType.Double;
         case PrimitiveTypeKind.Int16:
             return DbType.Int16;
         case PrimitiveTypeKind.Int32:
             return DbType.Int32;
         case PrimitiveTypeKind.Int64:
             return DbType.Int64;
         case PrimitiveTypeKind.Single:
             return DbType.Single;
         case PrimitiveTypeKind.Time:
             return DbType.Time;
         case PrimitiveTypeKind.Guid:
             return DbType.Guid;
         case PrimitiveTypeKind.String:
             return DbType.String;
         default:
             return DbType.Object;
     }
 }

        internal void AddAggregate(PrimitiveTypeKind returnTypeKind, string aggregateFunctionName, PrimitiveTypeKind collectionArgumentElementTypeKind)
        {
            Debug.Assert(!string.IsNullOrEmpty(aggregateFunctionName) && !string.IsNullOrWhiteSpace(aggregateFunctionName), "Aggregate function name should be valid");

            FunctionParameter returnParameter = CreateReturnParameter(returnTypeKind);
            FunctionParameter collectionParameter = CreateAggregateParameter(collectionArgumentElementTypeKind);

            EdmFunction function = new EdmFunction(aggregateFunctionName,
                EdmConstants.EdmNamespace,
                DataSpace.CSpace,
                new EdmFunctionPayload
                {
                    IsAggregate = true,
                    IsBuiltIn = true,
                    ReturnParameters = new FunctionParameter[] {returnParameter},
                    Parameters = new FunctionParameter[1] { collectionParameter },
                    IsFromProviderManifest = true,
                });

            function.SetReadOnly();

            this.functions.Add(function);
        }

 internal static NpgsqlDbType GetNpgsqlDbType(PrimitiveTypeKind _primitiveType)
 {
     switch (_primitiveType)
     {
         case PrimitiveTypeKind.Binary:
             return NpgsqlDbType.Bytea;
         case PrimitiveTypeKind.Boolean:
             return NpgsqlDbType.Boolean;
         case PrimitiveTypeKind.Byte:
         case PrimitiveTypeKind.SByte:
         case PrimitiveTypeKind.Int16:
             return NpgsqlDbType.Smallint;
         case PrimitiveTypeKind.DateTime:
             return NpgsqlDbType.Timestamp;
         case PrimitiveTypeKind.DateTimeOffset:
             return NpgsqlDbType.TimestampTZ;
         case PrimitiveTypeKind.Decimal:
             return NpgsqlDbType.Numeric;
         case PrimitiveTypeKind.Double:
             return NpgsqlDbType.Double;
         case PrimitiveTypeKind.Int32:
             return NpgsqlDbType.Integer;
         case PrimitiveTypeKind.Int64:
             return NpgsqlDbType.Bigint;
         case PrimitiveTypeKind.Single:
             return NpgsqlDbType.Real;
         case PrimitiveTypeKind.Time:
             return NpgsqlDbType.Interval;
         case PrimitiveTypeKind.Guid:
             return NpgsqlDbType.Uuid;
         case PrimitiveTypeKind.String:
             // Send strings as unknowns to be compatible with other datatypes than text
             return NpgsqlDbType.Unknown;
         default:
             return NpgsqlDbType.Unknown;
     }
 }

		private PrimitiveType(JniWrapper vm, PrimitiveTypeKind kind)
		{
			_kind = kind;
			_vm = vm;
		}

 // <summary>
 // Initialize the primitive type with the given
 // </summary>
 // <param name="clrType"> The CLR type of this type </param>
 // <param name="primitiveTypeKind"> The primitive type kind of the primitive type </param>
 private PrimitiveType CreatePrimitiveType(Type clrType, PrimitiveTypeKind primitiveTypeKind)
 {
     // Figures out the base type
     var baseType = MetadataItem.EdmProviderManifest.GetPrimitiveType(primitiveTypeKind);
     var primitiveType = new PrimitiveType(clrType, baseType, this);
     primitiveType.SetReadOnly();
     return primitiveType;
 }

        private static ParameterModel BuildParameter(
            PrimitiveTypeKind primitiveTypeKind,
            object defaultValue,
            string defaultValueSql = null,
            int? maxLength = null,
            byte? precision = null,
            byte? scale = null,
            bool? unicode = null,
            bool? fixedLength = null,
            string name = null,
            string storeType = null,
            bool outParameter = false)
        {
            var parameter
                = new ParameterModel(primitiveTypeKind)
                      {
                          MaxLength = maxLength,
                          Precision = precision,
                          Scale = scale,
                          IsUnicode = unicode,
                          IsFixedLength = fixedLength,
                          DefaultValue = defaultValue,
                          DefaultValueSql = defaultValueSql,
                          Name = name,
                          StoreType = storeType,
                          IsOutParameter = outParameter
                      };

            return parameter;
        }

 /// <summary>
 /// Given the canonical primitive type, get the mapping primitive type in the given dataspace
 /// </summary>
 /// <param name="primitiveTypeKind">canonical primitive type</param>
 /// <returns>The mapped scalar type</returns>
 internal override PrimitiveType GetMappedPrimitiveType(PrimitiveTypeKind primitiveTypeKind)
 {
     PrimitiveType type = null;
     _primitiveTypeMaps.TryGetType(primitiveTypeKind, null, out type);
     return type;
 }

 public static PrimitiveType GetEdmPrimitiveType(PrimitiveTypeKind primitiveTypeKind)
 {
     return EdmProviderManifest.GetPrimitiveType(primitiveTypeKind);
 }