protected virtual RelationalSequenceBuilder VisitSequence([NotNull] ModelBuilder modelBuilder, [NotNull] SequenceModel sequence) { Check.NotNull(modelBuilder, nameof(modelBuilder)); Check.NotNull(sequence, nameof(sequence)); if (string.IsNullOrEmpty(sequence.Name)) { Logger.LogWarning(RelationalDesignStrings.SequencesRequireName); return(null); } Type sequenceType = null; if (sequence.DataType != null) { sequenceType = _typeMapper.FindMapping(sequence.DataType)?.ClrType; } if (sequenceType != null && !Sequence.SupportedTypes.Contains(sequenceType)) { Logger.LogWarning(RelationalDesignStrings.BadSequenceType(sequence.Name, sequence.DataType)); return(null); } var builder = sequenceType != null ? modelBuilder.HasSequence(sequenceType, sequence.Name, sequence.SchemaName) : modelBuilder.HasSequence(sequence.Name, sequence.SchemaName); if (sequence.IncrementBy.HasValue) { builder.IncrementsBy(sequence.IncrementBy.Value); } if (sequence.Max.HasValue) { builder.HasMax(sequence.Max.Value); } if (sequence.Min.HasValue) { builder.HasMin(sequence.Min.Value); } if (sequence.Start.HasValue) { builder.StartsAt(sequence.Start.Value); } if (sequence.IsCyclic.HasValue) { builder.IsCyclic(sequence.IsCyclic.Value); } return(builder); }
private string GetDataType(IProperty property) { var typeName = property.Firebird().ColumnType; if (typeName == null) { var propertyDefault = property.FindPrincipal(); typeName = propertyDefault?.Firebird().ColumnType; if (typeName == null) { if (property.ClrType == typeof(string)) { typeName = _typeMapperRelational.StringMapper?.FindMapping(property.IsUnicode() ?? propertyDefault?.IsUnicode() ?? true, false, null).StoreType; } else if (property.ClrType == typeof(byte[])) { typeName = _typeMapperRelational.ByteArrayMapper?.FindMapping(false, false, null).StoreType; } else { typeName = _typeMapperRelational.FindMapping(property.ClrType).StoreType; } } } if (property.ClrType == typeof(byte[]) && typeName != null) { return("BLOB SUB_TYPE BINARY"); } return(typeName); }
private string GetTypeNameForCopy(IProperty property) { var typeName = property.SqlServer().ColumnType; if (typeName == null) { var principalProperty = property.FindPrincipal(); typeName = principalProperty?.SqlServer().ColumnType; if (typeName == null) { if (property.ClrType == typeof(string)) { typeName = _typeMapper.StringMapper?.FindMapping( property.IsUnicode() ?? principalProperty?.IsUnicode() ?? true, keyOrIndex: false, maxLength: null).StoreType; } else if (property.ClrType == typeof(byte[])) { typeName = _typeMapper.ByteArrayMapper?.FindMapping( rowVersion: false, keyOrIndex: false, size: null).StoreType; } return(typeName ?? _typeMapper.FindMapping(property.ClrType).StoreType); } } return(property.ClrType == typeof(byte[]) && (typeName.Equals("rowversion", StringComparison.OrdinalIgnoreCase) || typeName.Equals("timestamp", StringComparison.OrdinalIgnoreCase)) ? (property.IsNullable ? "varbinary(8)" : "binary(8)") : typeName); }
public static string GetTypeNameForCopy_SqlServer(this IProperty property, IRelationalTypeMapper typeMapper) { var typeName = property.AS400().ColumnType; if (typeName == null) { var principalProperty = property.FindPrincipal(); typeName = principalProperty?.AS400().ColumnType; if (typeName == null) { if (property.ClrType == typeof(string)) { typeName = typeMapper.StringMapper?.FindMapping( property.IsUnicode() ?? principalProperty?.IsUnicode() ?? true, false, null).StoreType; } else if (property.ClrType == typeof(byte[])) { typeName = typeMapper.ByteArrayMapper?.FindMapping(false, false, null).StoreType; } else { typeName = typeMapper.FindMapping(property.ClrType).StoreType; } } } if (property.ClrType == typeof(byte[]) && typeName != null && (typeName.Equals("rowversion", StringComparison.OrdinalIgnoreCase) || typeName.Equals("timestamp", StringComparison.OrdinalIgnoreCase))) { return(property.IsNullable ? "varbinary(8)" : "binary(8)"); } return(typeName); }
/// <summary> /// Gets a value indicating whether the given .NET type is mapped. /// </summary> /// <param name="typeMapper"> The type mapper. </param> /// <param name="clrType"> The .NET type. </param> /// <returns> True if the type can be mapped; otherwise false. </returns> public static bool IsTypeMapped( [NotNull] this IRelationalTypeMapper typeMapper, [NotNull] Type clrType) { Check.NotNull(typeMapper, nameof(typeMapper)); Check.NotNull(clrType, nameof(clrType)); return(typeMapper.FindMapping(clrType) != null); }
/// <summary> /// Visit constant /// </summary> /// <param name="expression"></param> /// <returns></returns> protected override Expression VisitConstant(ConstantExpression expression) { Check.NotNull(expression, nameof(expression)); if (expression.Value is null) { return(expression); } var underlyingType = expression.Type.UnwrapNullableType().UnwrapEnumType(); if (underlyingType == typeof(Enum)) { underlyingType = expression.Value.GetType(); } return(!(_relationalTypeMapper.FindMapping(underlyingType) is null) ? expression : null); }
/// <summary> /// Gets the mapping that represents the given database type, throwing if no mapping is found. /// </summary> /// <param name="typeMapper"> The type mapper. </param> /// <param name="typeName"> The type to get the mapping for. </param> /// <returns> The type mapping to be used. </returns> public static RelationalTypeMapping GetMapping( [NotNull] this IRelationalTypeMapper typeMapper, [NotNull] string typeName) { Check.NotNull(typeMapper, nameof(typeMapper)); Check.NotNull(typeName, nameof(typeName)); var mapping = typeMapper.FindMapping(typeName); if (mapping != null) { return(mapping); } throw new InvalidOperationException(RelationalStrings.UnsupportedType(typeName)); }
public static RelationalTypeMapping GetMapping( [NotNull] this IRelationalTypeMapper typeMapper, [NotNull] Type clrType) { Check.NotNull(typeMapper, nameof(typeMapper)); Check.NotNull(clrType, nameof(clrType)); var mapping = typeMapper.FindMapping(clrType); if (mapping != null) { return(mapping); } throw new NotSupportedException(RelationalStrings.UnsupportedType(clrType)); }
/// <summary> /// Gets the relational database type for a given property, throwing if no mapping is found. /// </summary> /// <param name="typeMapper"> The type mapper. </param> /// <param name="property"> The property to get the mapping for. </param> /// <returns> The type mapping to be used. </returns> public static RelationalTypeMapping GetMapping( [NotNull] this IRelationalTypeMapper typeMapper, [NotNull] IProperty property) { Check.NotNull(typeMapper, nameof(typeMapper)); Check.NotNull(property, nameof(property)); var mapping = typeMapper.FindMapping(property); if (mapping != null) { return(mapping); } throw new InvalidOperationException(RelationalStrings.UnsupportedPropertyType( property.DeclaringEntityType.DisplayName(), property.Name, property.ClrType.ShortDisplayName())); }
private RelationalTypeMapping FindMappingForProperty(RelationalTypeMappingInfo mappingInfo) => mappingInfo.Property != null ? _relationalTypeMapper.FindMapping(mappingInfo.Property) : null;
/// <summary> /// Visits a sub-query expression. /// </summary> /// <param name="expression"> The expression to visit. </param> /// <returns> /// An Expression. /// </returns> protected override Expression VisitSubQuery(SubQueryExpression expression) { Check.NotNull(expression, nameof(expression)); var subQueryModel = expression.QueryModel; var subQueryOutputDataInfo = subQueryModel.GetOutputDataInfo(); if (subQueryModel.IsIdentityQuery() && subQueryModel.ResultOperators.Count == 1 && subQueryModel.ResultOperators.First() is ContainsResultOperator) { var contains = (ContainsResultOperator)subQueryModel.ResultOperators.First(); var fromExpression = subQueryModel.MainFromClause.FromExpression; if (fromExpression.NodeType == ExpressionType.Parameter || fromExpression.NodeType == ExpressionType.Constant || fromExpression.NodeType == ExpressionType.ListInit || fromExpression.NodeType == ExpressionType.NewArrayInit) { var containsItem = Visit(contains.Item)?.RemoveConvert(); if (containsItem != null) { return(new InExpression(containsItem, new[] { fromExpression })); } } } else if (!(subQueryOutputDataInfo is StreamedSequenceInfo)) { var streamedSingleValueInfo = subQueryOutputDataInfo as StreamedSingleValueInfo; var streamedSingleValueSupportedType = streamedSingleValueInfo != null && _relationalTypeMapper.FindMapping( streamedSingleValueInfo.DataType .UnwrapNullableType() .UnwrapEnumType()) != null; if (_inProjection && !(subQueryOutputDataInfo is StreamedScalarValueInfo) && !streamedSingleValueSupportedType) { return(null); } var querySourceReferenceExpression = subQueryModel.SelectClause.Selector as QuerySourceReferenceExpression; if (querySourceReferenceExpression == null || _inProjection || !_queryModelVisitor.QueryCompilationContext .QuerySourceRequiresMaterialization(querySourceReferenceExpression.ReferencedQuerySource)) { var queryModelVisitor = (RelationalQueryModelVisitor)_queryModelVisitor.QueryCompilationContext .CreateQueryModelVisitor(_queryModelVisitor); var queriesProjectionCountMapping = _queryModelVisitor.Queries .ToDictionary(k => k, s => s.Projection.Count); var queryModelMapping = new Dictionary <QueryModel, QueryModel>(); subQueryModel.PopulateQueryModelMapping(queryModelMapping); queryModelVisitor.VisitSubQueryModel(subQueryModel); if (queryModelVisitor.Queries.Count == 1 && !queryModelVisitor.RequiresClientFilter && !queryModelVisitor.RequiresClientProjection && !queryModelVisitor.RequiresClientResultOperator) { var selectExpression = queryModelVisitor.Queries.First(); selectExpression.Alias = string.Empty; // anonymous foreach (var mappingElement in queriesProjectionCountMapping) { mappingElement.Key.RemoveRangeFromProjection(mappingElement.Value); } return(selectExpression); } subQueryModel.RecreateQueryModelFromMapping(queryModelMapping); } } return(null); }
private string GetVariableType(ColumnModification columnModification) { return(_typeMappingSource.FindMapping(columnModification.Property).StoreType); }
public static object GetTypeColumnToString(ColumnModification column, IRelationalTypeMapper mapper) { var mapping = mapper.FindMapping(column.Property); return(mapping.StoreType);//"VARCHAR(100)"; }
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public virtual TypeScaffoldingInfo FindMapping( string storeType, bool keyOrIndex, bool rowVersion) { // This is because certain providers can have no type specified as a default type e.g. SQLite Check.NotNull(storeType, nameof(storeType)); var mapping = _typeMapper.FindMapping(storeType); if (mapping == null) { return(null); } var canInfer = false; bool?scaffoldUnicode = null; int? scaffoldMaxLength = null; if (mapping.ClrType == typeof(byte[]) && _typeMapper.ByteArrayMapper != null) { // Check for inference var byteArrayMapping = _typeMapper.ByteArrayMapper.FindMapping(rowVersion, keyOrIndex, mapping.Size); if (byteArrayMapping.StoreType.Equals(storeType, StringComparison.OrdinalIgnoreCase)) { canInfer = true; // Check for size var sizedMapping = _typeMapper.ByteArrayMapper.FindMapping(rowVersion, keyOrIndex, size: null); scaffoldMaxLength = sizedMapping.Size != byteArrayMapping.Size ? byteArrayMapping.Size : null; } } else if (mapping.ClrType == typeof(string) && _typeMapper.StringMapper != null) { // Check for inference var stringMapping = _typeMapper.StringMapper.FindMapping(mapping.IsUnicode, keyOrIndex, mapping.Size); if (stringMapping.StoreType.Equals(storeType, StringComparison.OrdinalIgnoreCase)) { canInfer = true; // Check for unicode var unicodeMapping = _typeMapper.StringMapper.FindMapping(unicode: true, keyOrIndex: keyOrIndex, maxLength: mapping.Size); scaffoldUnicode = unicodeMapping.IsUnicode != stringMapping.IsUnicode ? (bool?)stringMapping.IsUnicode : null; // Check for size var sizedMapping = _typeMapper.StringMapper.FindMapping(mapping.IsUnicode, keyOrIndex, maxLength: null); scaffoldMaxLength = sizedMapping.Size != stringMapping.Size ? stringMapping.Size : null; } } else { var defaultMapping = _typeMapper.GetMapping(mapping.ClrType); if (defaultMapping.StoreType.Equals(storeType, StringComparison.OrdinalIgnoreCase)) { canInfer = true; } } return(new TypeScaffoldingInfo( mapping.ClrType, canInfer, scaffoldUnicode, scaffoldMaxLength)); }