protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { Check.NotNull(providerManifest, "providerManifest"); Check.NotNull(commandTree, "commandTree"); return CreateDbCommandDefinition(providerManifest, commandTree, new DbInterceptionContext()); }
static LegacyDbProviderManifestWrapperTests() { LegacyProviderManifest = ((Legacy.DbProviderServices) ((IServiceProvider)Legacy.DbProviderFactories.GetFactory("System.Data.SqlClient")) .GetService(typeof(Legacy.DbProviderServices))) .GetProviderManifest("2008"); ProviderManifestWrapper = new LegacyDbProviderManifestWrapper(LegacyProviderManifest); const string emptyCsdl = @"<Schema xmlns=""http://schemas.microsoft.com/ado/2009/11/edm"" Namespace=""dummy"" />"; using (var reader = XmlReader.Create(new StringReader(emptyCsdl))) { EdmPrimitiveTypes = new EdmItemCollection(new[] { reader }).GetItems<PrimitiveType>().ToDictionary(t => t.Name, t => t); } using (var reader = XmlReader.Create(new StringReader(emptyCsdl))) { LegacyEdmPrimitiveTypes = new LegacyMetadata.EdmItemCollection(new[] { reader }) .GetItems<LegacyMetadata.PrimitiveType>() .ToDictionary(t => t.Name, t => t); } }
/// <summary> /// Creates the provider manifest wrapper. /// </summary> /// <param name="providerInvariantName">Provider invariant name.</param> /// <param name="providerManifest">The provider manifest to be wrapped.</param> /// <returns><see cref="DbProviderManifest"/> wrapper for given provider invariant name wrapping given provider manifest.</returns> public virtual DbProviderManifest CreateProviderManifest(string providerInvariantName, DbProviderManifest providerManifest) { return new DbProviderManifestWrapper( this.ProviderInvariantName, providerInvariantName, providerManifest); }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return new CachingCommandDefinition( _providerServices.CreateCommandDefinition(providerManifest, commandTree), new CommandTreeFacts(commandTree), _cacheTransactionHandler, _cachingPolicy); }
/// <summary> /// Create a Command Definition object, given the connection and command tree /// </summary> /// <param name="connection"> connection to the underlying provider </param> /// <param name="commandTree"> command tree for the statement </param> /// <returns> an executable command definition object </returns> /// <exception cref="ArgumentNullException">connection and commandTree arguments must not be null</exception> protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { Check.NotNull(providerManifest, "providerManifest"); Check.NotNull(commandTree, "commandTree"); var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); return CreateCommandDefinition(storeMetadata.StoreProviderFactory, commandTree); }
private void InitializeProviderServices(string providerManifestToken) { using (var connection = CreateConnection()) { _providerServices = DbProviderServices.GetProviderServices(connection); _providerManifest = _providerServices.GetProviderManifest(providerManifestToken); } }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { Debug.Assert(providerManifest != null, "CreateCommandDefinition passed null provider manifest to CreateDbCommandDefinition?"); Debug.Assert(commandTree != null, "CreateCommandDefinition did not validate commandTree argument?"); var prototype = CreateCommand(providerManifest, commandTree); var result = CreateCommandDefinition(prototype); return result; }
protected override DbCommandDefinition CreateDbCommandDefinition( DbProviderManifest providerManifest, DbCommandTree commandTree) { if (commandTree == null) throw new ArgumentNullException("commandTree"); SqlGenerator generator = null; if (commandTree is DbQueryCommandTree) generator = new SelectGenerator(); else if (commandTree is DbInsertCommandTree) generator = new InsertGenerator(); else if (commandTree is DbUpdateCommandTree) generator = new UpdateGenerator(); else if (commandTree is DbDeleteCommandTree) generator = new DeleteGenerator(); else if (commandTree is DbFunctionCommandTree) generator = new FunctionGenerator(); string sql = generator.GenerateSQL(commandTree); EFMySqlCommand cmd = new EFMySqlCommand(); cmd.CommandText = sql; if (generator is FunctionGenerator) cmd.CommandType = (generator as FunctionGenerator).CommandType; SetExpectedTypes(commandTree, cmd); EdmFunction function = null; if (commandTree is DbFunctionCommandTree) function = (commandTree as DbFunctionCommandTree).EdmFunction; // Now make sure we populate the command's parameters from the CQT's parameters: foreach (KeyValuePair<string, TypeUsage> queryParameter in commandTree.Parameters) { DbParameter parameter = cmd.CreateParameter(); parameter.ParameterName = queryParameter.Key; parameter.Direction = ParameterDirection.Input; parameter.DbType = Metadata.GetDbType(queryParameter.Value); FunctionParameter funcParam; if (function != null && function.Parameters.TryGetValue(queryParameter.Key, false, out funcParam)) { parameter.ParameterName = funcParam.Name; parameter.Direction = Metadata.ModeToDirection(funcParam.Mode); parameter.DbType = Metadata.GetDbType(funcParam.TypeUsage); } cmd.Parameters.Add(parameter); } // Now add parameters added as part of SQL gen foreach (DbParameter p in generator.Parameters) cmd.Parameters.Add(p); return CreateCommandDefinition(cmd); }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { var entityCommandDefinition = EntityCommandDefinition; if (entityCommandDefinition == null) { entityCommandDefinition = new Mock<EntityCommandDefinition>(MockBehavior.Loose, null, null, null).Object; } return entityCommandDefinition; }
private void InitializeProviderServices(string providerManifestToken) { Check.NotEmpty(providerManifestToken, "providerManifestToken"); using (var connection = CreateConnection()) { _providerManifest = DbProviderServices .GetProviderServices(connection) .GetProviderManifest(providerManifestToken); } }
// used by EntityStoreSchemaGenerator to start with an empty (primitive types only) StoreItemCollection and // add types discovered from the database internal StoreItemCollection(DbProviderFactory factory, DbProviderManifest manifest, string providerManifestToken) : base(DataSpace.SSpace) { Debug.Assert(factory != null, "factory is null"); Debug.Assert(manifest != null, "manifest is null"); _providerFactory = factory; _providerManifest = manifest; _providerManifestToken = providerManifestToken; _cachedCTypeFunction = new Memoizer<EdmFunction, EdmFunction>(ConvertFunctionSignatureToCType, null); LoadProviderManifest(_providerManifest); }
internal override DbCommandDefinition CreateDbCommandDefinition( DbProviderManifest providerManifest, DbCommandTree commandTree, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(providerManifest); DebugCheck.NotNull(commandTree); DebugCheck.NotNull(interceptionContext); var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); return CreateCommandDefinition(storeMetadata.StoreProviderFactory, commandTree, interceptionContext); }
public override IEnumerable<MigrationStatement> Generate(IEnumerable<MigrationOperation> migrationOperations, string providerManifestToken) { List<MigrationStatement> stmts = new List<MigrationStatement>(); MySqlConnection con = new MySqlConnection(); providerManifest = DbProviderServices.GetProviderServices(con).GetProviderManifest(providerManifestToken); foreach (MigrationOperation op in migrationOperations) { OpDispatcher opdis = dispatcher[op.GetType().Name]; stmts.Add(opdis(op)); } return stmts; }
public static DbProviderInfo GetProviderInfo( this DbConnection connection, out DbProviderManifest providerManifest) { Contract.Requires(connection != null); var providerServices = DbProviderServices.GetProviderServices(connection); var providerManifestToken = providerServices.GetProviderManifestTokenChecked(connection); var providerInfo = new DbProviderInfo(connection.GetProviderInvariantName(), providerManifestToken); providerManifest = providerServices.GetProviderManifest(providerManifestToken); return providerInfo; }
// used by EntityStoreSchemaGenerator to start with an empty (primitive types only) StoreItemCollection and // add types discovered from the database internal StoreItemCollection( DbProviderFactory factory, DbProviderManifest manifest, string providerInvariantName, string providerManifestToken) : base(DataSpace.SSpace) { DebugCheck.NotNull(factory); DebugCheck.NotNull(manifest); _providerFactory = factory; _providerManifest = manifest; _providerInvariantName = providerInvariantName; _providerManifestToken = providerManifestToken; _cachedCTypeFunction = new Memoizer<EdmFunction, EdmFunction>(ConvertFunctionSignatureToCType, null); LoadProviderManifest(_providerManifest); }
public static DbProviderInfo GetProviderInfo( this DbConnection connection, out DbProviderManifest providerManifest) { DebugCheck.NotNull(connection); var providerManifestToken = DbConfiguration .GetService<IManifestTokenService>() .GetProviderManifestToken(connection); var providerInfo = new DbProviderInfo(connection.GetProviderInvariantName(), providerManifestToken); providerManifest = DbProviderServices.GetProviderServices(connection).GetProviderManifest(providerManifestToken); return providerInfo; }
/// <summary> /// Converts a set of migration operations into Microsoft SQL Server specific SQL. /// </summary> /// <param name = "migrationOperations">The operations to be converted.</param> /// <param name = "providerManifestToken">Token representing the version of SQL Server being targeted (i.e. "2005", "2008").</param> /// <returns>A list of SQL statements to be executed to perform the migration operations.</returns> public override IEnumerable<MigrationStatement> Generate( IEnumerable<MigrationOperation> migrationOperations, string providerManifestToken) { _statements = new List<MigrationStatement>(); _generatedSchemas = new HashSet<string>(); _variableCounter = 0; using (var connection = CreateConnection()) { _providerManifest = DbProviderServices.GetProviderServices(connection) .GetProviderManifest(providerManifestToken); } migrationOperations.Each<dynamic>(o => Generate(o)); return _statements; }
/// <summary> /// Create a Command Definition object given a command tree. /// </summary> /// <param name="commandTree"> command tree for the statement </param> /// <returns> an executable command definition object </returns> /// <remarks> /// This method simply delegates to the provider's implementation of CreateDbCommandDefinition. /// </remarks> public DbCommandDefinition CreateCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { Contract.Requires(providerManifest != null); Contract.Requires(commandTree != null); try { return CreateDbCommandDefinition(providerManifest, commandTree); } catch (ProviderIncompatibleException) { throw; } catch (Exception e) { if (e.IsCatchableExceptionType()) { throw new ProviderIncompatibleException(Strings.ProviderDidNotCreateACommandDefinition, e); } throw; } }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { Debug.Assert(providerManifest != null, "providerManifest != null"); Debug.Assert( providerManifest is LegacyDbProviderManifestWrapper, "providerManifest expected to be LegacyDbProviderManifestWrapper"); Debug.Assert(commandTree != null, "commandTree != null"); Debug.Assert(commandTree is DbQueryCommandTree, "Only query trees are supported"); Debug.Assert(commandTree.DataSpace == DataSpace.SSpace, "SSpace tree expected"); try { var legacyMetadata = commandTree.MetadataWorkspace.ToLegacyMetadataWorkspace(); var legacyQuery = ((DbQueryCommandTree)commandTree).Query.Accept( new LegacyDbExpressionConverter( (LegacyMetadata.StoreItemCollection) legacyMetadata.GetItemCollection(LegacyMetadata.DataSpace.SSpace))); var legacyCommandTree = (LegacyCommandTrees.DbCommandTree)LegacyDbQueryCommandTreeCtor.Invoke( new object[] { legacyMetadata, LegacyMetadata.DataSpace.SSpace, legacyQuery }); return new LegacyDbCommandDefinitionWrapper( _wrappedProviderServices.CreateCommandDefinition( ((LegacyDbProviderManifestWrapper)providerManifest).WrappedManifest, legacyCommandTree)); } catch (SystemData.ProviderIncompatibleException exception) { throw new ProviderIncompatibleException(exception.Message, exception.InnerException); } }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest manifest, DbCommandTree commandTree) { DbCommand prototype = CreateCommand(manifest, commandTree); DbCommandDefinition result = this.CreateCommandDefinition(prototype); return result; }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { if (providerManifest == null) throw new ArgumentNullException("providerManifest"); if (commandTree == null) throw new ArgumentNullException("commandTree"); List<DbParameter> parameters; CommandType commandType; string commandText = SqlGenerator.GenerateSql(commandTree, out parameters, out commandType); DbCommand command = null; if (commandType == NuoDbMultipleCommands.MultipleTexts) command = new NuoDbMultipleCommands(PrepareTypeCoercions(commandTree)); else command = new NuoDbCommand(PrepareTypeCoercions(commandTree)); command.CommandText = commandText; command.CommandType = commandType; // Get the function (if any) implemented by the command tree since this influences our interpretation of parameters EdmFunction function = null; if (commandTree is DbFunctionCommandTree) { function = ((DbFunctionCommandTree)commandTree).EdmFunction; } foreach (KeyValuePair<string, TypeUsage> queryParameter in commandTree.Parameters) { NuoDbParameter parameter; // Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and // type trump user-defined facets and type in the EntityCommand). FunctionParameter functionParameter; if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter)) { parameter = CreateSqlParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value); } else { parameter = CreateSqlParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value); } command.Parameters.Add(parameter); } // Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which // does not support user parameters, where there is no risk of name collision) if (null != parameters && 0 < parameters.Count) { if (!(commandTree is DbInsertCommandTree) && !(commandTree is DbUpdateCommandTree) && !(commandTree is DbDeleteCommandTree)) { throw new InvalidOperationException("SqlGenParametersNotPermitted"); } foreach (DbParameter parameter in parameters) { command.Parameters.Add(parameter); } } return CreateCommandDefinition(command); }
public override IEnumerable<MigrationStatement> Generate(IEnumerable<MigrationOperation> migrationOperations, string providerManifestToken) { MySqlConnection con = new MySqlConnection(); List<MigrationStatement> stmts = new List<MigrationStatement>(); _providerManifestToken = providerManifestToken; _providerManifest = DbProviderServices.GetProviderServices(con).GetProviderManifest(providerManifestToken); //verify if there is one or more add/alter column operation, if there is then look for primary key operations. Alter in case that the user wants to change the current PK column if ((from cols in migrationOperations.OfType<AddColumnOperation>() select cols).Count() > 0 || (from cols in migrationOperations.OfType<AlterColumnOperation>() select cols).Count() > 0) _pkOperations = (from pks in migrationOperations.OfType<AddPrimaryKeyOperation>() select pks).ToList(); foreach (MigrationOperation op in migrationOperations) { if (!_dispatcher.ContainsKey(op.GetType().Name)) throw new NotImplementedException(op.GetType().Name); OpDispatcher opdis = _dispatcher[op.GetType().Name]; stmts.Add(opdis(op)); } if (_specialStmts.Count > 0) { foreach (var item in _specialStmts) stmts.Add(item); } return stmts; }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return new Mock<EntityCommandDefinition>(MockBehavior.Loose, null, null).Object; }
protected override DbCommandDefinition CreateDbCommandDefinition( DbProviderManifest providerManifest, DbCommandTree commandTree);
/// <summary>Creates command definition from specified manifest and command tree.</summary> /// <returns>The created command definition.</returns> /// <param name="providerManifest">The manifest.</param> /// <param name="commandTree">The command tree.</param> public DbCommandDefinition CreateCommandDefinition( DbProviderManifest providerManifest, DbCommandTree commandTree) { Check.NotNull(providerManifest, "providerManifest"); Check.NotNull(commandTree, "commandTree"); try { return CreateDbCommandDefinition(providerManifest, commandTree); } catch (ProviderIncompatibleException) { throw; } catch (Exception e) { if (e.IsCatchableExceptionType()) { throw new ProviderIncompatibleException(Strings.ProviderDidNotCreateACommandDefinition, e); } throw; } }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { var command = CreateCommand(providerManifest, commandTree); return(CreateCommandDefinition(command)); }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return(CreateCommandDefinition(CreateDbCommand(((NpgsqlProviderManifest)providerManifest).Version, commandTree))); }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { throw new NotImplementedException(); }
internal static DbCommand CreateCommand(DbProviderManifest manifest, DbCommandTree commandTree) { ArgumentUtility.CheckNotNull("manifest", manifest); ArgumentUtility.CheckNotNull("commandTree", commandTree); var vfpManifest = manifest as VfpProviderManifest; if (vfpManifest == null) { throw new ArgumentException("The provider manifest given is not of type 'VfpProviderManifest'."); } var command = new VfpCommand(); List <DbParameter> parameters; CommandType commandType; command.CommandText = SqlGenerator.GenerateSql(vfpManifest, commandTree, out parameters, out commandType); command.CommandType = commandType; //if (command.CommandType == CommandType.Text) { // command.CommandText += Environment.NewLine + Environment.NewLine; //} // Get the function (if any) implemented by the command tree since this influences our interpretation of parameters EdmFunction function = null; if (commandTree is DbFunctionCommandTree) { function = ((DbFunctionCommandTree)commandTree).EdmFunction; } var parameterHelper = new VfpParameterHelper(); // Now make sure we populate the command's parameters from the CQT's parameters: foreach (var queryParameter in commandTree.Parameters) { VfpClient.VfpParameter parameter; // Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and // type trump user-defined facets and type in the EntityCommand). FunctionParameter functionParameter; if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter)) { parameter = parameterHelper.CreateVfpParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value); } else { parameter = parameterHelper.CreateVfpParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value); } command.Parameters.Add(parameter); } foreach (var parameter in parameters) { command.Parameters.Add(parameter); } return(command); }
public void Configure( DbDatabaseMapping databaseMapping, ICollection <EntitySet> entitySets, DbProviderManifest providerManifest, EntityType entityType, ref EntityTypeMapping entityTypeMapping, bool isMappingAnyInheritedProperty, int configurationIndex, int configurationCount, IDictionary <string, object> commonAnnotations) { EntityType baseType = (EntityType)entityType.BaseType; bool flag = baseType == null && configurationIndex == 0; MappingFragment typeMappingFragment1 = this.FindOrCreateTypeMappingFragment(databaseMapping, ref entityTypeMapping, configurationIndex, entityType, providerManifest); EntityType table = typeMappingFragment1.Table; bool isTableSharing; EntityType createTargetTable = this.FindOrCreateTargetTable(databaseMapping, typeMappingFragment1, entityType, table, out isTableSharing); bool isSharingTableWithBase = this.DiscoverIsSharingWithBase(databaseMapping, entityType, createTargetTable); HashSet <EdmPropertyPath> contain = this.DiscoverAllMappingsToContain(databaseMapping, entityType, createTargetTable, isSharingTableWithBase); List <ColumnMappingBuilder> list = typeMappingFragment1.ColumnMappings.ToList <ColumnMappingBuilder>(); foreach (EdmPropertyPath edmPropertyPath in contain) { EdmPropertyPath propertyPath = edmPropertyPath; ColumnMappingBuilder columnMappingBuilder = typeMappingFragment1.ColumnMappings.SingleOrDefault <ColumnMappingBuilder>((Func <ColumnMappingBuilder, bool>)(pm => pm.PropertyPath.SequenceEqual <EdmProperty>((IEnumerable <EdmProperty>)propertyPath))); if (columnMappingBuilder == null) { throw Error.EntityMappingConfiguration_DuplicateMappedProperty((object)entityType.Name, (object)propertyPath.ToString()); } list.Remove(columnMappingBuilder); } if (!flag) { bool isSplitting; EntityType parentTable = EntityMappingConfiguration.FindParentTable(databaseMapping, table, entityTypeMapping, createTargetTable, isMappingAnyInheritedProperty, configurationIndex, configurationCount, out isSplitting); if (parentTable != null) { DatabaseOperations.AddTypeConstraint(databaseMapping.Database, entityType, parentTable, createTargetTable, isSplitting); } } if (table != createTargetTable) { if (this.Properties == null) { AssociationMappingOperations.MoveAllDeclaredAssociationSetMappings(databaseMapping, entityType, table, createTargetTable, !isTableSharing); ForeignKeyPrimitiveOperations.MoveAllDeclaredForeignKeyConstraintsForPrimaryKeyColumns(entityType, table, createTargetTable); } if (isMappingAnyInheritedProperty) { IEnumerable <EntityType> baseTables = databaseMapping.GetEntityTypeMappings(baseType).SelectMany <EntityTypeMapping, MappingFragment>((Func <EntityTypeMapping, IEnumerable <MappingFragment> >)(etm => (IEnumerable <MappingFragment>)etm.MappingFragments)).Select <MappingFragment, EntityType>((Func <MappingFragment, EntityType>)(mf => mf.Table)); AssociationSetMapping associationSetMapping = databaseMapping.EntityContainerMappings.SelectMany <EntityContainerMapping, AssociationSetMapping>((Func <EntityContainerMapping, IEnumerable <AssociationSetMapping> >)(asm => asm.AssociationSetMappings)).FirstOrDefault <AssociationSetMapping>((Func <AssociationSetMapping, bool>)(a => { if (!baseTables.Contains <EntityType>(a.Table)) { return(false); } if (baseType != a.AssociationSet.ElementType.SourceEnd.GetEntityType()) { return(baseType == a.AssociationSet.ElementType.TargetEnd.GetEntityType()); } return(true); })); if (associationSetMapping != null) { AssociationType elementType = associationSetMapping.AssociationSet.ElementType; throw Error.EntityMappingConfiguration_TPCWithIAsOnNonLeafType((object)elementType.Name, (object)elementType.SourceEnd.GetEntityType().Name, (object)elementType.TargetEnd.GetEntityType().Name); } ForeignKeyPrimitiveOperations.CopyAllForeignKeyConstraintsForPrimaryKeyColumns(databaseMapping.Database, table, createTargetTable); } } if (list.Any <ColumnMappingBuilder>()) { EntityType extraTable = (EntityType)null; if (configurationIndex < configurationCount - 1) { ColumnMappingBuilder pm = list.First <ColumnMappingBuilder>(); extraTable = EntityMappingConfiguration.FindTableForTemporaryExtraPropertyMapping(databaseMapping, entityType, table, createTargetTable, pm); MappingFragment typeMappingFragment2 = EntityMappingOperations.CreateTypeMappingFragment(entityTypeMapping, typeMappingFragment1, databaseMapping.Database.GetEntitySet(extraTable)); bool requiresUpdate = extraTable != table; foreach (ColumnMappingBuilder propertyMappingBuilder in list) { EntityMappingOperations.MovePropertyMapping(databaseMapping, (IEnumerable <EntitySet>)entitySets, typeMappingFragment1, typeMappingFragment2, propertyMappingBuilder, requiresUpdate, true); } } else { EntityType unmappedTable = (EntityType)null; foreach (ColumnMappingBuilder columnMappingBuilder in list) { extraTable = EntityMappingConfiguration.FindTableForExtraPropertyMapping(databaseMapping, entityType, table, createTargetTable, ref unmappedTable, columnMappingBuilder); MappingFragment mappingFragment = entityTypeMapping.MappingFragments.SingleOrDefault <MappingFragment>((Func <MappingFragment, bool>)(tmf => tmf.Table == extraTable)); if (mappingFragment == null) { mappingFragment = EntityMappingOperations.CreateTypeMappingFragment(entityTypeMapping, typeMappingFragment1, databaseMapping.Database.GetEntitySet(extraTable)); mappingFragment.SetIsUnmappedPropertiesFragment(true); } if (extraTable == table) { EntityMappingConfiguration.CopyDefaultDiscriminator(typeMappingFragment1, mappingFragment); } bool requiresUpdate = extraTable != table; EntityMappingOperations.MovePropertyMapping(databaseMapping, (IEnumerable <EntitySet>)entitySets, typeMappingFragment1, mappingFragment, columnMappingBuilder, requiresUpdate, true); } } } EntityMappingOperations.UpdatePropertyMappings(databaseMapping, (IEnumerable <EntitySet>)entitySets, table, typeMappingFragment1, !isTableSharing); this.ConfigureDefaultDiscriminator(entityType, typeMappingFragment1); this.ConfigureConditions(databaseMapping, entityType, typeMappingFragment1, providerManifest); EntityMappingOperations.UpdateConditions(databaseMapping.Database, table, typeMappingFragment1); ForeignKeyPrimitiveOperations.UpdatePrincipalTables(databaseMapping, entityType, table, createTargetTable, isMappingAnyInheritedProperty); EntityMappingConfiguration.CleanupUnmappedArtifacts(databaseMapping, table); EntityMappingConfiguration.CleanupUnmappedArtifacts(databaseMapping, createTargetTable); EntityMappingConfiguration.ConfigureAnnotations((EdmType)createTargetTable, commonAnnotations); EntityMappingConfiguration.ConfigureAnnotations((EdmType)createTargetTable, this._annotations); createTargetTable.SetConfiguration((object)this); }
protected virtual void Visit(DbProviderManifest providerManifest) { }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return(new GlimpseDbCommandDefinition(InnerProviderServices.CreateCommandDefinition(commandTree))); }
/** <inheritDoc /> */ protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return(new DbCommandDefinitionProxy(_services.CreateCommandDefinition(providerManifest, commandTree), new DbCommandInfo(commandTree, _cache, _policy, _txHandler))); }
//protected override bool ShouldValidateEntity(DbEntityEntry entityEntry) //{ // return base.ShouldValidateEntity(entityEntry); //} protected override void OnModelCreating(DbModelBuilder modelBuilder) { //modelBuilder.Entity<BlogPost>().ToTable("tbl_blog_post"); var typesToRegister = Assembly.GetExecutingAssembly().GetTypes() .Where(type => !String.IsNullOrEmpty(type.Namespace)) .Where(type => type.BaseType != null && type.BaseType.IsGenericType && type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration <>)); foreach (var type in typesToRegister) { dynamic configInstance = Activator.CreateInstance(type); modelBuilder.Configurations.Add(configInstance); } //modelBuilder.ComplexType<BillingAddress>() // .Property(p => p.CreditCardNumber) // .HasColumnName("CardNumber"); //modelBuilder.ComplexType<Address>() // .Property(p => p.StreetAddress) // .HasColumnName("StreetAddress"); //var count = this.Database.SqlQuery<int>("SELECT COUNT(*) FROM Customers"); //These are all to find out the EF objects ConfigurationRegistrar registrar = modelBuilder.Configurations; ConventionsConfiguration conventions = modelBuilder.Conventions; DbModel dbModel = modelBuilder.Build(this.Database.Connection); EdmModel edmModel = dbModel.ConceptualModel; EntityContainerMapping containerMapping = dbModel.ConceptualToStoreMapping; DbProviderInfo dbProviderInfo = dbModel.ProviderInfo; DbProviderManifest dbProviderManifest = dbModel.ProviderManifest; EdmModel dbModelStoreModel = dbModel.StoreModel; DbCompiledModel dbCompiledModel = dbModel.Compile(); PropertyConventionConfiguration propertyConvention = modelBuilder.Properties(); TypeConventionConfiguration typeConvention = modelBuilder.Types(); //modelBuilder.RegisterEntityType(); //registrar.AddFromAssembly() //conventions.AddFromAssembly(); //propertyConvention // .Where(info => info.GetType() is typeof(string)) // .Configure(cfg => cfg.HasMaxLength(200)); //typeConvention.Configure(cfg => cfg.MapToStoredProcedures()); //All Configurations //System.Data.Entity.ModelConfiguration.Configuration //All Conventions //System.Data.Entity.ModelConfiguration.Conventions //modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>(); base.OnModelCreating(modelBuilder); }
private static void ConfigureDependentKeys(DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest) { DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(providerManifest); // PERF: this code written this way since it's part of a hotpath, consider its performance when refactoring. See codeplex #2298. var entityTypesList = databaseMapping.Database.EntityTypes as IList <EntityType> ?? databaseMapping.Database.EntityTypes.ToList(); // ReSharper disable ForCanBeConvertedToForeach for (var entityTypesListIterator = 0; entityTypesListIterator < entityTypesList.Count; ++entityTypesListIterator) { var entityType = entityTypesList[entityTypesListIterator]; var foreignKeyBuilders = entityType.ForeignKeyBuilders as IList <ForeignKeyBuilder> ?? entityType.ForeignKeyBuilders.ToList(); for (var foreignKeyBuildersIterator = 0; foreignKeyBuildersIterator < foreignKeyBuilders.Count; ++foreignKeyBuildersIterator) { var foreignKeyConstraint = foreignKeyBuilders[foreignKeyBuildersIterator]; var dependentColumns = foreignKeyConstraint.DependentColumns; var dependentColumnsList = dependentColumns as IList <EdmProperty> ?? dependentColumns.ToList(); for (var i = 0; i < dependentColumnsList.Count; ++i) { var c = dependentColumnsList[i]; var primitivePropertyConfiguration = c.GetConfiguration() as PrimitivePropertyConfiguration; if ((primitivePropertyConfiguration != null) && (primitivePropertyConfiguration.ColumnType != null)) { continue; } var principalColumn = foreignKeyConstraint.PrincipalTable.KeyProperties.ElementAt(i); c.PrimitiveType = providerManifest.GetStoreTypeFromName(principalColumn.TypeName); c.CopyFrom(principalColumn); } } } // ReSharper restore ForCanBeConvertedToForeach }
private static void ConfigureDependentKeys(DbDatabaseMapping databaseMapping, DbProviderManifest providerManifest) { DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(providerManifest); foreach (var foreignKeyConstraint in databaseMapping.Database.EntityTypes.SelectMany(t => t.ForeignKeyBuilders)) { foreignKeyConstraint .DependentColumns .Each( (c, i) => { var primitivePropertyConfiguration = c.GetConfiguration() as PrimitivePropertyConfiguration; if ((primitivePropertyConfiguration != null) && (primitivePropertyConfiguration.ColumnType != null)) { return; } var principalColumn = foreignKeyConstraint.PrincipalTable.KeyProperties.ElementAt(i); c.PrimitiveType = providerManifest.GetStoreTypeFromName(principalColumn.TypeName); c.CopyFrom(principalColumn); }); } }
/// <summary> /// Initializes a new instance of the DbProviderManifestWrapper class. /// </summary> /// <param name="wrapperProviderInvariantName">Wrapper provider invariant name.</param> /// <param name="providerInvariantName">Provider invariant name.</param> /// <param name="wrappedProviderManifest">The wrapped provider manifest.</param> public DbProviderManifestWrapper(string wrapperProviderInvariantName, string providerInvariantName, DbProviderManifest wrappedProviderManifest) { this.wrapperProviderInvariantName = wrapperProviderInvariantName; this.providerInvariantName = providerInvariantName; this.wrappedProviderManifest = wrappedProviderManifest; }
/// <summary> /// Creates the provider manifest wrapper. /// </summary> /// <param name="providerInvariantName">Provider invariant name.</param> /// <param name="providerManifest">The provider manifest to be wrapped.</param> /// <returns><see cref="DbProviderManifest"/> wrapper for given provider invariant name wrapping given provider manifest.</returns> public virtual DbProviderManifest CreateProviderManifest(string providerInvariantName, DbProviderManifest providerManifest) { return(new DbProviderManifestWrapper( this.ProviderInvariantName, providerInvariantName, providerManifest)); }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return new GlimpseDbCommandDefinition(InnerProviderServices.CreateCommandDefinition(commandTree)); }
protected override void Visit(DbProviderManifest providerManifest) { // the provider manifest will be checked by all the other types lining up. // no need to store more info. }
/// <summary>Creates a command definition object for the specified provider manifest and command tree.</summary> /// <returns>An executable command definition object.</returns> /// <param name="providerManifest">Provider manifest previously retrieved from the store provider.</param> /// <param name="commandTree">Command tree for the statement.</param> protected abstract DbCommandDefinition CreateDbCommandDefinition( DbProviderManifest providerManifest, DbCommandTree commandTree);
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return(new WrappingCommandDefinition <TAdoNetBase>(_baseServices.CreateCommandDefinition(providerManifest, commandTree))); }
public override string GenerateProcedureBody(ICollection<DbModificationCommandTree> commandTrees, string rowsAffectedParameter, string providerManifestToken) { MySqlConnection con = new MySqlConnection(); MigrationStatement stmt = new MigrationStatement(); _providerManifest = DbProviderServices.GetProviderServices(con).GetProviderManifest(providerManifestToken); var cmdStr = ""; SqlGenerator generator = new SelectGenerator(); foreach (var commandTree in commandTrees) { switch (commandTree.CommandTreeKind) { case DbCommandTreeKind.Insert: generator = new InsertGenerator(); cmdStr = generator.GenerateSQL(commandTree); break; case DbCommandTreeKind.Delete: generator = new DeleteGenerator(); cmdStr = generator.GenerateSQL(commandTree); break; case DbCommandTreeKind.Update: generator = new UpdateGenerator(); cmdStr = generator.GenerateSQL(commandTree); break; case DbCommandTreeKind.Query: generator = new SelectGenerator(); cmdStr = generator.GenerateSQL(commandTree); break; case DbCommandTreeKind.Function: generator = new FunctionGenerator(); cmdStr = generator.GenerateSQL(commandTree); break; } stmt.Sql += cmdStr.Replace("dbo.", "") + ";"; } return stmt.Sql; }
private DbCommand CreateCommand(DbProviderManifest manifest, DbCommandTree commandTree) { if (manifest == null) { throw new ArgumentNullException("manifest"); } if (commandTree == null) { throw new ArgumentNullException("commandTree"); } var expectedTypes = PrepareTypeCoercions(commandTree); FbCommand command = FbCommand.CreateWithTypeCoercions(expectedTypes); List <DbParameter> parameters; CommandType commandType; command.CommandText = SqlGenerator.GenerateSql(commandTree, out parameters, out commandType); command.CommandType = commandType; // Get the function (if any) implemented by the command tree since this influences our interpretation of parameters EdmFunction function = null; if (commandTree is DbFunctionCommandTree) { function = ((DbFunctionCommandTree)commandTree).EdmFunction; } // Now make sure we populate the command's parameters from the CQT's parameters: foreach (KeyValuePair <string, TypeUsage> queryParameter in commandTree.Parameters) { FbParameter parameter; // Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and // type trump user-defined facets and type in the EntityCommand). FunctionParameter functionParameter; if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter)) { parameter = CreateSqlParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value); } else { parameter = CreateSqlParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value); } command.Parameters.Add(parameter); } // Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which // does not support user parameters, where there is no risk of name collision) if (null != parameters && 0 < parameters.Count) { if (!(commandTree is DbInsertCommandTree) && !(commandTree is DbUpdateCommandTree) && !(commandTree is DbDeleteCommandTree)) { throw new InvalidOperationException("SqlGenParametersNotPermitted"); } foreach (DbParameter parameter in parameters) { command.Parameters.Add(parameter); } } return(command); }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return CreateCommandDefinition(CreateDbCommand(commandTree)); }
protected override DbCommandDefinition CreateDbCommandDefinition( DbProviderManifest providerManifest, DbCommandTree commandTree) { if (commandTree == null) { throw new ArgumentNullException("commandTree"); } SqlGenerator generator = null; if (commandTree is DbQueryCommandTree) { generator = new SelectGenerator(); } else if (commandTree is DbInsertCommandTree) { generator = new InsertGenerator(); } else if (commandTree is DbUpdateCommandTree) { generator = new UpdateGenerator(); } else if (commandTree is DbDeleteCommandTree) { generator = new DeleteGenerator(); } else if (commandTree is DbFunctionCommandTree) { generator = new FunctionGenerator(); } string sql = generator.GenerateSQL(commandTree); EFMySqlCommand cmd = new EFMySqlCommand(); cmd.CommandText = sql; if (generator is FunctionGenerator) { cmd.CommandType = (generator as FunctionGenerator).CommandType; } SetExpectedTypes(commandTree, cmd); EdmFunction function = null; if (commandTree is DbFunctionCommandTree) { function = (commandTree as DbFunctionCommandTree).EdmFunction; } // Now make sure we populate the command's parameters from the CQT's parameters: foreach (KeyValuePair <string, TypeUsage> queryParameter in commandTree.Parameters) { DbParameter parameter = cmd.CreateParameter(); parameter.ParameterName = queryParameter.Key; parameter.Direction = ParameterDirection.Input; parameter.DbType = Metadata.GetDbType(queryParameter.Value); #if NET_45_OR_GREATER if (queryParameter.Value.EdmType is PrimitiveType && ((PrimitiveType)queryParameter.Value.EdmType).PrimitiveTypeKind == PrimitiveTypeKind.Geometry) { ((MySqlParameter)parameter).MySqlDbType = MySqlDbType.Geometry; } #endif FunctionParameter funcParam; if (function != null && function.Parameters.TryGetValue(queryParameter.Key, false, out funcParam)) { parameter.ParameterName = funcParam.Name; parameter.Direction = Metadata.ModeToDirection(funcParam.Mode); parameter.DbType = Metadata.GetDbType(funcParam.TypeUsage); } cmd.Parameters.Add(parameter); } // Now add parameters added as part of SQL gen foreach (DbParameter p in generator.Parameters) { cmd.Parameters.Add(p); } return(CreateCommandDefinition(cmd)); }
private DbCommand CreateCommand(DbProviderManifest manifest, DbCommandTree commandTree) { if (manifest == null) throw new ArgumentNullException("manifest"); if (commandTree == null) throw new ArgumentNullException("commandTree"); SQLiteCommand command = new SQLiteCommand(); try { List<DbParameter> parameters; CommandType commandType; command.CommandText = SqlGenerator.GenerateSql((SQLiteProviderManifest)manifest, commandTree, out parameters, out commandType); command.CommandType = commandType; // Get the function (if any) implemented by the command tree since this influences our interpretation of parameters EdmFunction function = null; if (commandTree is DbFunctionCommandTree) { function = ((DbFunctionCommandTree)commandTree).EdmFunction; } // Now make sure we populate the command's parameters from the CQT's parameters: foreach (KeyValuePair<string, TypeUsage> queryParameter in commandTree.Parameters) { SQLiteParameter parameter; // Use the corresponding function parameter TypeUsage where available (currently, the SSDL facets and // type trump user-defined facets and type in the EntityCommand). FunctionParameter functionParameter; if (null != function && function.Parameters.TryGetValue(queryParameter.Key, false, out functionParameter)) { parameter = CreateSqlParameter(functionParameter.Name, functionParameter.TypeUsage, functionParameter.Mode, DBNull.Value); } else { parameter = CreateSqlParameter(queryParameter.Key, queryParameter.Value, ParameterMode.In, DBNull.Value); } command.Parameters.Add(parameter); } // Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which // does not support user parameters, where there is no risk of name collision) if (null != parameters && 0 < parameters.Count) { if (!(commandTree is DbInsertCommandTree) && !(commandTree is DbUpdateCommandTree) && !(commandTree is DbDeleteCommandTree)) { throw new InvalidOperationException("SqlGenParametersNotPermitted"); } foreach (DbParameter parameter in parameters) { command.Parameters.Add(parameter); } } return command; } catch { command.Dispose(); throw; } }
public AssociationTypeMappingGenerator(DbProviderManifest providerManifest) : base(providerManifest) { }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return CreateCommandDefinition(CreateDbCommand(((NpgsqlProviderManifest)providerManifest).Version, commandTree)); }
protected override void ConfigureColumn(EdmProperty column, EntityType table, DbProviderManifest providerManifest) { if (IsRowVersion != null && IsRowVersion.Value) { ColumnType = ColumnType ?? "rowversion"; } base.ConfigureColumn(column, table, providerManifest); if (IsRowVersion != null && IsRowVersion.Value) { column.MaxLength = null; } }
private DbCommand CreateCommand(DbProviderManifest providerManifest, DbCommandTree commandTree) { // DEVNOTE/CAUTION: This method could be called either from Remote or Local Provider. // Ensure that the code works well with the both provider types. // The methods called from the below code also need to be capable // of handling both provider types. // // NOTE: Remote Provider is loaded at runtime, if available. // This is done to remove hard dependency on Remote Provider and // it might not be present in all scenarios. All Remote Provider // type checks need to be done using RemoteProviderHelper class. // Check.NotNull(providerManifest, "providerManifest"); Check.NotNull(commandTree, "commandTree"); if (commandTree is DbFunctionCommandTree) { throw ADP1.NotSupported(EntityRes.GetString(EntityRes.StoredProceduresNotSupported)); } var command = _isLocalProvider ? new SqlCeMultiCommand() : (DbCommand)RemoteProviderHelper.CreateRemoteProviderType(RemoteProvider.SqlCeCommand); command.Connection = null; // don't hold on to the connection when we're going to cache this forever; List <DbParameter> parameters; CommandType commandType; var commandTexts = SqlGenerator.GenerateSql(commandTree, out parameters, out commandType, _isLocalProvider); if (_isLocalProvider) { Debug.Assert(command is SqlCeMultiCommand, "SqlCeMultiCommand expected"); // Set the multiple command texts for the command object ((SqlCeMultiCommand)command).CommandTexts = commandTexts; } else { // Set the command text for the RDP case. Debug.Assert(commandTexts.Length == 1, "BatchQueries are not supported in designer scenarios"); command.CommandText = commandTexts[0]; } command.CommandType = commandType; // Now make sure we populate the command's parameters from the CQT's parameters: // foreach (var queryParameter in commandTree.Parameters) { DbParameter parameter; const bool ignoreMaxLengthFacet = false; parameter = CreateSqlCeParameter( queryParameter.Key, queryParameter.Value, DBNull.Value, ignoreMaxLengthFacet, _isLocalProvider); command.Parameters.Add(parameter); } // Now add parameters added as part of SQL gen (note: this feature is only safe for DML SQL gen which // does not support user parameters, where there is no risk of name collision) // if (null != parameters && 0 < parameters.Count) { if (!(commandTree is DbDeleteCommandTree || commandTree is DbInsertCommandTree || commandTree is DbUpdateCommandTree)) { throw ADP1.InternalError(ADP1.InternalErrorCode.SqlGenParametersNotPermitted); } foreach (var parameter in parameters) { command.Parameters.Add(parameter); } } return(command); }
protected override DbCommandDefinition CreateDbCommandDefinition(DbProviderManifest providerManifest, DbCommandTree commandTree) { return(new CmdDefinition(_inner.CreateCommandDefinition(providerManifest, commandTree))); }