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;
}
// <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);
}
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 PrimitiveType CreatePrimitiveType(
Type clrType,
PrimitiveTypeKind primitiveTypeKind)
{
PrimitiveType primitiveType1 = MetadataItem.EdmProviderManifest.GetPrimitiveType(primitiveTypeKind);
PrimitiveType primitiveType2 = new PrimitiveType(clrType, primitiveType1, (DbProviderManifest)this);
primitiveType2.SetReadOnly();
return(primitiveType2);
}
internal static bool TryGetPrimitiveTypeKind(TypeUsage type, out PrimitiveTypeKind typeKind)
{
if (type != null && type.EdmType != null && type.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType)
{
typeKind = ((PrimitiveType)type.EdmType).PrimitiveTypeKind;
return(true);
}
typeKind = PrimitiveTypeKind.Binary;
return(false);
}
internal static bool IsPrimitiveType(TypeUsage type, PrimitiveTypeKind primitiveTypeKind)
{
PrimitiveTypeKind typeKind;
if (EF6MetadataHelpers.TryGetPrimitiveTypeKind(type, out typeKind))
{
return(typeKind == primitiveTypeKind);
}
return(false);
}
internal static bool IsSpatialType(this PrimitiveType type)
{
PrimitiveTypeKind primitiveTypeKind = type.PrimitiveTypeKind;
if (primitiveTypeKind >= PrimitiveTypeKind.Geometry)
{
return(primitiveTypeKind <= PrimitiveTypeKind.GeographyCollection);
}
return(false);
}
internal static bool IsPrimitiveType(TypeUsage type, PrimitiveTypeKind primitiveType)
{
PrimitiveTypeKind typeKind;
if (TryGetPrimitiveTypeKind(type, out typeKind))
{
return(typeKind == primitiveType);
}
return(false);
}
internal static bool IsSpatialType(this TypeUsage type, out PrimitiveTypeKind spatialType)
{
if (type.IsSpatialType())
{
spatialType = ((PrimitiveType)type.EdmType).PrimitiveTypeKind;
return(true);
}
spatialType = PrimitiveTypeKind.Binary;
return(false);
}
public static bool IsPrimitiveTypeOf(this TypeUsage tu, PrimitiveTypeKind primitiveType)
{
PrimitiveTypeKind typeKind;
if (TryGetPrimitiveTypeKind(tu, out typeKind))
{
return(typeKind == primitiveType);
}
return(false);
}
internal void AddFunction(
PrimitiveTypeKind returnType,
string functionName,
PrimitiveTypeKind argumentTypeKind,
string argumentName)
{
this.AddFunction(returnType, functionName, new KeyValuePair <string, PrimitiveTypeKind>[1]
{
new KeyValuePair <string, PrimitiveTypeKind>(argumentName, argumentTypeKind)
});
}
internal static void ForAllBasePrimitiveTypes(Action <PrimitiveTypeKind> forEachType)
{
for (int index = 0; index < 31; ++index)
{
PrimitiveTypeKind kind = (PrimitiveTypeKind)index;
if (!Helper.IsStrongSpatialTypeKind(kind))
{
forEachType(kind);
}
}
}
internal static bool TryGetPrimitiveTypeKind(this TypeUsage typeUsage, out PrimitiveTypeKind typeKind) {
if (typeUsage.EdmType != null && typeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType) {
typeKind = ((PrimitiveType)typeUsage.EdmType).PrimitiveTypeKind;
return true;
}
typeKind = default(PrimitiveTypeKind);
return false;
}
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());
}
internal IngresType GetIngresType(PrimitiveTypeKind primitiveTypeKind)
{
switch (primitiveTypeKind)
{
case PrimitiveTypeKind.Binary:
return(IngresType.Binary);
case PrimitiveTypeKind.Boolean:
return(IngresType.Boolean);
case PrimitiveTypeKind.Byte:
return(IngresType.SmallInt);
case PrimitiveTypeKind.DateTime:
return(IngresType.DateTime);
// case PrimitiveTypeKind.DateTimeOffset:
// return IngresType.DateTime;
case PrimitiveTypeKind.Decimal:
return(IngresType.Decimal);
case PrimitiveTypeKind.Double:
return(IngresType.Double);
// case PrimitiveTypeKind.Guid:
// return IngresType.Guid;
case PrimitiveTypeKind.Int16:
return(IngresType.SmallInt);
case PrimitiveTypeKind.Int32:
return(IngresType.Int);
case PrimitiveTypeKind.Int64:
return(IngresType.BigInt);
case PrimitiveTypeKind.SByte:
return(IngresType.TinyInt);
case PrimitiveTypeKind.Single:
return(IngresType.Real);
case PrimitiveTypeKind.String:
return(IngresType.NVarChar);
case PrimitiveTypeKind.Time:
return(IngresType.IntervalDayToSecond);
default:
throw new ArgumentException(
String.Format(
"Ingres Entity Framework provider does not support the type '{0}'.",
primitiveTypeKind));
} // end switch (primitiveTypeKind)
}
public static bool TryGetPrimitiveTypeKind(this TypeUsage tu, out PrimitiveTypeKind typeKind)
{
if (tu != null && tu.EdmType != null && tu.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType)
{
typeKind = ((PrimitiveType)tu.EdmType).PrimitiveTypeKind;
return(true);
}
typeKind = default(PrimitiveTypeKind);
return(false);
}
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());
}
internal void ForAllBasePrimitiveTypes(Action <PrimitiveTypeKind> forEachType)
{
for (int idx = 0; idx < EdmConstants.NumPrimitiveTypes; idx++)
{
PrimitiveTypeKind typeKind = (PrimitiveTypeKind)idx;
if (!Helper.IsStrongSpatialTypeKind(typeKind))
{
forEachType(typeKind);
}
}
}
private TypeUsage GetStorePrimitiveTypeIfPostSql9(
string storeTypeName,
string nameForException,
PrimitiveTypeKind primitiveTypeKind)
{
if (this.SqlVersion != SqlVersion.Sql8 && this.SqlVersion != SqlVersion.Sql9)
{
return(TypeUsage.CreateDefaultTypeUsage((EdmType)this.StoreTypeNameToStorePrimitiveType[storeTypeName]));
}
throw new NotSupportedException(Strings.NoStoreTypeForEdmType((object)nameForException, (object)primitiveTypeKind));
}
/// <summary>
/// Determines SqlDbType for the given primitive type. Extracts facet
/// information as well.
/// </summary>
private static FbDbType GetSqlDbType(TypeUsage type, bool isOutParam, out int?size)
{
// only supported for primitive type
PrimitiveTypeKind primitiveTypeKind = MetadataHelpers.GetPrimitiveTypeKind(type);
size = default(int?);
switch (primitiveTypeKind)
{
case PrimitiveTypeKind.Boolean:
return(FbDbType.SmallInt);
case PrimitiveTypeKind.Int16:
return(FbDbType.SmallInt);
case PrimitiveTypeKind.Int32:
return(FbDbType.Integer);
case PrimitiveTypeKind.Int64:
return(FbDbType.BigInt);
case PrimitiveTypeKind.Double:
return(FbDbType.Double);
case PrimitiveTypeKind.Single:
return(FbDbType.Float);
case PrimitiveTypeKind.Decimal:
return(FbDbType.Decimal);
case PrimitiveTypeKind.Binary:
// for output parameters, ensure there is space...
size = GetParameterSize(type, isOutParam);
return(GetBinaryDbType(type));
case PrimitiveTypeKind.String:
size = GetParameterSize(type, isOutParam);
return(GetStringDbType(type));
case PrimitiveTypeKind.DateTime:
return(FbDbType.TimeStamp);
case PrimitiveTypeKind.Time:
return(FbDbType.Time);
case PrimitiveTypeKind.Guid:
return(FbDbType.Guid);
default:
Debug.Fail("unknown PrimitiveTypeKind " + primitiveTypeKind);
throw new InvalidOperationException("unknown PrimitiveTypeKind " + primitiveTypeKind);
}
}
internal void AddFunction(
PrimitiveTypeKind returnType, string functionName, PrimitiveTypeKind argument1TypeKind, string argument1Name,
PrimitiveTypeKind argument2TypeKind, string argument2Name)
{
AddFunction(
returnType, functionName,
new[]
{
new KeyValuePair <string, PrimitiveTypeKind>(argument1Name, argument1TypeKind),
new KeyValuePair <string, PrimitiveTypeKind>(argument2Name, argument2TypeKind)
});
}
/// <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([NotNull] this DbModel model, PrimitiveTypeKind typeKind)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
return(model
.ProviderManifest
.GetStoreType(
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(typeKind))).EdmType);
}
/// <summary>
///
/// </summary>
/// <param name="element"></param>
/// <param name="modelType"></param>
/// <returns></returns>
public static bool TryGetPrimitiveTypeKind(EdmType type, out PrimitiveTypeKind modelType)
{
if (!Helper.IsPrimitiveType(type))
{
// set it to something bogus because I have to
modelType = PrimitiveTypeKind.Binary;
return(false);
}
modelType = ((PrimitiveType)type).PrimitiveTypeKind;
return(true);
}
internal override StringBuilder AsEsql(StringBuilder builder, MemberPath outputMember, string blockAlias)
{
Debug.Assert(outputMember.LeafEdmMember != null, "Constant can't correspond to an empty member path.");
TypeUsage modelTypeUsage = Helper.GetModelTypeUsage(outputMember.LeafEdmMember);
EdmType modelType = modelTypeUsage.EdmType;
// Some built-in constants
if (BuiltInTypeKind.PrimitiveType == modelType.BuiltInTypeKind)
{
PrimitiveTypeKind primitiveTypeKind = ((PrimitiveType)modelType).PrimitiveTypeKind;
if (primitiveTypeKind == PrimitiveTypeKind.Boolean)
{
// This better be a boolean. Else we crash!
bool val = (bool)m_scalar;
string value = StringUtil.FormatInvariant("{0}", val);
builder.Append(value);
return(builder);
}
else if (primitiveTypeKind == PrimitiveTypeKind.String)
{
bool isUnicode;
if (!TypeHelpers.TryGetIsUnicode(modelTypeUsage, out isUnicode))
{
// If can't determine - use the safest option, assume unicode.
isUnicode = true;
}
if (isUnicode)
{
builder.Append('N');
}
AppendEscapedScalar(builder);
return(builder);
}
}
else if (BuiltInTypeKind.EnumType == modelType.BuiltInTypeKind)
{
// Enumerated type - we should be able to cast it
EnumMember enumMember = (EnumMember)m_scalar;
builder.Append(enumMember.Name);
return(builder);
}
// Need to cast
builder.Append("CAST(");
AppendEscapedScalar(builder);
builder.Append(" AS ");
CqlWriter.AppendEscapedTypeName(builder, modelType);
builder.Append(')');
return(builder);
}
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);
}
}
public static bool TryGetPrimitiveTypeKind(this EdmType edmType, out PrimitiveTypeKind typeKind)
{
if (edmType.IsPrimitiveType())
{
typeKind = ((PrimitiveType)edmType).PrimitiveTypeKind;
return(true);
}
typeKind = default(PrimitiveTypeKind);
return(false);
}
public ConstantExpression(object value, TypeUsage edmType)
{
if (edmType == null)
{
throw new ArgumentNullException("edmType");
}
if (edmType.EdmType == null || edmType.EdmType.BuiltInTypeKind != BuiltInTypeKind.PrimitiveType)
{
throw new ArgumentException("Require primitive EdmType", "edmType");
}
_primitiveType = ((PrimitiveType)edmType.EdmType).PrimitiveTypeKind;
_value = value;
}
internal static bool IsSpatialType(this TypeUsage type, out PrimitiveTypeKind spatialType)
{
DebugCheck.NotNull(type);
if (IsSpatialType(type))
{
spatialType = ((PrimitiveType)type.EdmType).PrimitiveTypeKind;
return(true);
}
spatialType = default(PrimitiveTypeKind);
return(false);
}
private TypeUsage GetStorePrimitiveTypeIfPostSql9(
string storeTypeName, string nameForException, PrimitiveTypeKind primitiveTypeKind)
{
if ((SqlVersion != SqlVersion.Sql8) &&
(SqlVersion != SqlVersion.Sql9))
{
return(TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType[storeTypeName]));
}
else
{
throw new NotSupportedException(Strings.NoStoreTypeForEdmType(nameForException, primitiveTypeKind));
}
}
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));
}
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 void InitializeSpatialPromotionGroup(
ReadOnlyCollection <PrimitiveType>[] promotionTypes,
PrimitiveTypeKind[] promotableKinds,
PrimitiveTypeKind baseKind)
{
foreach (PrimitiveTypeKind promotableKind in promotableKinds)
{
promotionTypes[(int)promotableKind] = new ReadOnlyCollection <PrimitiveType>((IList <PrimitiveType>) new PrimitiveType[2]
{
this._primitiveTypes[(int)promotableKind],
this._primitiveTypes[(int)baseKind]
});
}
}
internal static bool IsSpatialType(TypeUsage type, out PrimitiveTypeKind spatialType)
{
if (type.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType)
{
PrimitiveType edmType = (PrimitiveType)type.EdmType;
if (Helper.IsGeographicTypeKind(edmType.PrimitiveTypeKind) || Helper.IsGeometricTypeKind(edmType.PrimitiveTypeKind))
{
spatialType = edmType.PrimitiveTypeKind;
return(true);
}
}
spatialType = PrimitiveTypeKind.Binary;
return(false);
}
/// <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);
}
}
}
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);
}
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();
}
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;
}
}
/// <summary>
/// Determines if the function requires the return type be enforced by use of a cast expression
/// </summary>
/// <param name="e"></param>
/// <param name="functionsRequiringReturnTypeCast"></param>
/// <param name="type"></param>
/// <returns></returns>
private static bool CastReturnTypeToGivenType(
DbFunctionExpression e, ISet<string> functionsRequiringReturnTypeCast, PrimitiveTypeKind type)
{
if (!functionsRequiringReturnTypeCast.Contains(e.Function.FullName))
{
return false;
}
return e.Arguments.Any(t => t.ResultType.IsPrimitiveType(type));
}
// <summary>
// Returns the <see cref="PrimitiveTypeKind" /> corresponding to the given CLR type
// </summary>
// <param name="clrType"> The CLR type for which the PrimitiveTypeKind value should be resolved </param>
// <param name="resolvedPrimitiveTypeKind"> The PrimitiveTypeKind value to which the CLR type resolves, if any. </param>
// <returns> True if the CLR type represents a primitive (EDM) type; otherwise false. </returns>
internal static bool TryGetPrimitiveTypeKind(Type clrType, out PrimitiveTypeKind resolvedPrimitiveTypeKind)
{
PrimitiveTypeKind? primitiveTypeKind = null;
if (!clrType.IsEnum()) // Enums return the TypeCode of their underlying type
{
// As an optimization, short-circuit when the provided type has a known type code.
switch (Type.GetTypeCode(clrType))
{
// PrimitiveTypeKind.Binary = byte[] = TypeCode.Object
case TypeCode.Boolean:
primitiveTypeKind = PrimitiveTypeKind.Boolean;
break;
case TypeCode.Byte:
primitiveTypeKind = PrimitiveTypeKind.Byte;
break;
case TypeCode.DateTime:
primitiveTypeKind = PrimitiveTypeKind.DateTime;
break;
// PrimitiveTypeKind.DateTimeOffset = System.DateTimeOffset = TypeCode.Object
case TypeCode.Decimal:
primitiveTypeKind = PrimitiveTypeKind.Decimal;
break;
case TypeCode.Double:
primitiveTypeKind = PrimitiveTypeKind.Double;
break;
// PrimitiveTypeKind.Geography = System.Data.Entity.Spatial.DbGeometry (or subtype) = TypeCode.Object
// PrimitiveTypeKind.Geometry = System.Data.Entity.Spatial.DbGeometry (or subtype) = TypeCode.Object
// PrimitiveTypeKind.Guid = System.Guid = TypeCode.Object
case TypeCode.Int16:
primitiveTypeKind = PrimitiveTypeKind.Int16;
break;
case TypeCode.Int32:
primitiveTypeKind = PrimitiveTypeKind.Int32;
break;
case TypeCode.Int64:
primitiveTypeKind = PrimitiveTypeKind.Int64;
break;
case TypeCode.SByte:
primitiveTypeKind = PrimitiveTypeKind.SByte;
break;
case TypeCode.Single:
primitiveTypeKind = PrimitiveTypeKind.Single;
break;
case TypeCode.String:
primitiveTypeKind = PrimitiveTypeKind.String;
break;
// PrimitiveTypeKind.Time = System.TimeSpan = TypeCode.Object
case TypeCode.Object:
{
if (typeof(byte[]) == clrType)
{
primitiveTypeKind = PrimitiveTypeKind.Binary;
}
else if (typeof(DateTimeOffset) == clrType)
{
primitiveTypeKind = PrimitiveTypeKind.DateTimeOffset;
}
// DbGeography/Geometry are abstract so subtypes must be allowed
else if (typeof(DbGeography).IsAssignableFrom(clrType))
{
primitiveTypeKind = PrimitiveTypeKind.Geography;
}
else if (typeof(DbGeometry).IsAssignableFrom(clrType))
{
primitiveTypeKind = PrimitiveTypeKind.Geometry;
}
else if (typeof(Guid) == clrType)
{
primitiveTypeKind = PrimitiveTypeKind.Guid;
}
else if (typeof(TimeSpan) == clrType)
{
primitiveTypeKind = PrimitiveTypeKind.Time;
}
break;
}
}
}
if (primitiveTypeKind.HasValue)
{
resolvedPrimitiveTypeKind = primitiveTypeKind.Value;
return true;
}
else
{
resolvedPrimitiveTypeKind = default(PrimitiveTypeKind);
return false;
}
}
// <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 PrimitiveType(JniWrapper vm, PrimitiveTypeKind kind)
{
_kind = kind;
_vm = vm;
}
/// <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;
}
private TypeUsage GetStorePrimitiveTypeIfPostSql9(
string storeTypeName, string nameForException, PrimitiveTypeKind primitiveTypeKind)
{
if ((SqlVersion != SqlVersion.Sql8)
&& (SqlVersion != SqlVersion.Sql9))
{
return TypeUsage.CreateDefaultTypeUsage(StoreTypeNameToStorePrimitiveType[storeTypeName]);
}
else
{
throw new NotSupportedException(Strings.NoStoreTypeForEdmType(nameForException, primitiveTypeKind));
}
}
public ConstantExpression(object value, TypeUsage edmType)
{
if (edmType == null)
throw new ArgumentNullException("edmType");
if (edmType.EdmType == null || edmType.EdmType.BuiltInTypeKind != BuiltInTypeKind.PrimitiveType)
throw new ArgumentException("Require primitive EdmType", "edmType");
_primitiveType = ((PrimitiveType)edmType.EdmType).PrimitiveTypeKind;
_value = value;
}
private DbType GetDbType(PrimitiveTypeKind _primitiveType)
{
switch (_primitiveType)
{
case PrimitiveTypeKind.Boolean:
return DbType.Boolean;
case PrimitiveTypeKind.Guid:
return DbType.Guid;
case PrimitiveTypeKind.String:
return DbType.String;
default:
return DbType.Object;
}
}
/// <summary>
/// Initializes a new attribute with primitive type kind
/// </summary>
/// <param name="primitiveTypeKind">Primitive type setting Type property</param>
/// <param name="isCollectionType">Sets IsCollectionType property</param>
internal MetadataPropertyAttribute(PrimitiveTypeKind primitiveTypeKind, bool isCollectionType)
: this(MetadataItem.EdmProviderManifest.GetPrimitiveType(primitiveTypeKind), isCollectionType)
{
}
public static PrimitiveType GetEdmPrimitiveType(PrimitiveTypeKind primitiveTypeKind)
{
return EdmProviderManifest.GetPrimitiveType(primitiveTypeKind);
}
/// <summary>
/// Perform initialization that's common across all constructors
/// </summary>
/// <param name="primitiveType"> The primitive type to initialize </param>
/// <param name="primitiveTypeKind"> The primitive type kind of this primitive type </param>
/// <param name="providerManifest"> The ProviderManifest of the provider of this type </param>
internal static void Initialize(
PrimitiveType primitiveType,
PrimitiveTypeKind primitiveTypeKind,
DbProviderManifest providerManifest)
{
primitiveType._primitiveTypeKind = primitiveTypeKind;
primitiveType._providerManifest = providerManifest;
}
/// <summary>
/// Determines whether the given function is a canonical function the translates
/// to a spatial (geography/geometry) property access or method call.
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
private static bool IsSpatialCanonicalFunction(DbFunctionExpression e, out PrimitiveTypeKind spatialTypeKind)
{
if (e.Function.IsCanonicalFunction())
{
if (e.ResultType.IsSpatialType(out spatialTypeKind))
{
return true;
}
foreach (var functionParameter in e.Function.Parameters)
{
if (functionParameter.TypeUsage.IsSpatialType(out spatialTypeKind))
{
return true;
}
}
}
spatialTypeKind = default(PrimitiveTypeKind);
return false;
}
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;
}
private static ISqlFragment HandleSpatialCanonicalFunction(
SqlGenerator sqlgen, DbFunctionExpression functionExpression, PrimitiveTypeKind spatialTypeKind)
{
Debug.Assert(
spatialTypeKind == PrimitiveTypeKind.Geography || spatialTypeKind == PrimitiveTypeKind.Geometry,
"Spatial function does not refer to a valid spatial primitive type kind?");
if (spatialTypeKind == PrimitiveTypeKind.Geography)
{
return HandleSpatialCanonicalFunction(
sqlgen, functionExpression, _geographyFunctionNameToStaticMethodHandlerDictionary,
_geographyFunctionNameToInstancePropertyNameDictionary, _geographyRenamedInstanceMethodFunctionDictionary);
}
else
{
return HandleSpatialCanonicalFunction(
sqlgen, functionExpression, _geometryFunctionNameToStaticMethodHandlerDictionary,
_geometryFunctionNameToInstancePropertyNameDictionary, _geometryRenamedInstanceMethodFunctionDictionary);
}
}
/// <summary>
/// Gets the type name to use for a column of the given data type.
/// </summary>
/// <param name="primitiveTypeKind"> The data type to translate. </param>
/// <returns> The type name to use in the generated migration. </returns>
protected virtual string TranslateColumnType(PrimitiveTypeKind primitiveTypeKind)
{
switch (primitiveTypeKind)
{
case PrimitiveTypeKind.Int16:
return "Short";
case PrimitiveTypeKind.Int32:
return "Int";
case PrimitiveTypeKind.Int64:
return "Long";
default:
return Enum.GetName(typeof(PrimitiveTypeKind), primitiveTypeKind);
}
}
