C# SqlServerProcessor.TableExists方法代码示例

        public void CanApplyIndexConvention()
        {
            var connection = new SqlConnection(sqlServerConnectionString);
             connection.Open();
             var processor = new SqlServerProcessor(connection, new SqlServerGenerator());

             var conventions = new MigrationConventions();
             var runner = new MigrationRunner(conventions, processor);

             runner.Up(new TestIndexNamingConvention());
             processor.TableExists("Users").ShouldBeTrue();

             runner.Down(new TestIndexNamingConvention());
             processor.TableExists("Users").ShouldBeFalse();
        }

        public void CanApplyForeignKeyConvention()
        {
            var connection = new SqlConnection(sqlServerConnectionString);
            connection.Open();
            var processor = new SqlServerProcessor(connection, new SqlServerGenerator());

             var conventions = new MigrationConventions();
             var runner = new MigrationRunner(conventions, processor);

             runner.Up(new TestForeignKeyNamingConvention());
             processor.TableExists("Users").ShouldBeTrue();
             processor.ConstraintExists( "Users", "FK_Users_GroupId_Groups_GroupId").ShouldBeTrue();

             runner.Down(new TestForeignKeyNamingConvention());
             processor.TableExists("Users").ShouldBeFalse();
        }

        public void CanReadLongViewDefinition()
        {
            // Arrange
             var create = new CreateTableExpression
             {
            TableName = "Foo",
            Columns =
               new List<ColumnDefinition> { new ColumnDefinition { Name = "Id", Type = DbType.Int32 } }
             };

             IList<ViewDefinition> views;

             var createSql = new StringBuilder();
             createSql.Append("CREATE VIEW FooView As SELECT Id,");
             createSql.Append("'");
             createSql.Append(new string('A', 3000));
             createSql.Append("'");
             createSql.Append(" As LongText1,");
             createSql.Append("'");
             createSql.Append(new string('B', 3000));
             createSql.Append("'");
             createSql.Append(" As LongText2");
             createSql.Append(" FROM Foo");

             // Act
             using (var connection = new SqlConnection(ConnectionString))
             {
            var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());

            processor.Process(create);

            Assert.IsTrue(processor.TableExists(string.Empty, create.TableName), "SqlServer");

            processor.Execute(createSql.ToString());

            var dumper = new SqlServerSchemaDumper(processor, new DebugAnnouncer());
            views = dumper.ReadViewSchema();

            processor.CommitTransaction();
             }

             // Assert

             Assert.AreEqual(1, views.Count);
        }

        /// <summary>
        /// Creates tables in source oracle database and asserts that they exist
        /// </summary>
        /// <param name="expressions">The tables to be created</param>
        private void ExecuteMigrations(params IMigrationExpression[] expressions)
        {
            if (expressions == null)
            return;

             using (var connection = new SqlConnection(_source.ConnectionString))
             {
            var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());

            foreach (var expression in expressions)
            {
                if (expression is CreateTableExpression)
                {
                    var create = (CreateTableExpression)expression;
                    processor.Process(create);
                    Assert.IsTrue(processor.TableExists(string.Empty, create.TableName), "Source " + create.TableName);
                }

                if (expression is CreateForeignKeyExpression)
                {
                    processor.Process((CreateForeignKeyExpression)expression);
                }

                if (expression is InsertDataExpression)
                {
                    processor.Process((InsertDataExpression)expression);
                }
            }

            processor.CommitTransaction();
             }
        }

        public void SqlServerMigrationsAreTransactional()
        {
            var connection = new SqlConnection(sqlServerConnectionString);
            connection.Open();
            var processor = new SqlServerProcessor(connection, new SqlServerGenerator());
            var runner = new MigrationVersionRunner(_conventions, processor, new MigrationLoader(_conventions), typeof(MigrationVersionRunnerTests).Assembly, typeof(InvalidMigration).Namespace);

            try
            {
                runner.MigrateUp();
            }
            catch
            {
            }

            processor.TableExists("Users").ShouldBeFalse();
        }

        /// <summary>
        /// Creates a single column table using the spplied type and retruns its <see cref="ColumnDefinition"/>
        /// </summary>
        /// <param name="type">The Sql Server data type to apply to the column</param>
        /// <returns>The translated <see cref="ColumnDefinition"/></returns>
        private TableDefinition GetTableColumnColumns(string createSql, string name, params IMigrationExpression[] expresions)
        {
            IList<TableDefinition> tables;

              // Act
              using (var connection = new SqlConnection(ConnectionString))
              {
              var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());

              if (!string.IsNullOrEmpty(createSql))
                  processor.Execute(createSql);

              foreach (var expresion in expresions)
              {
                  if (expresion is CreateTableExpression)
                      processor.Process((CreateTableExpression)expresion);
                  if (expresion is CreateIndexExpression)
                      processor.Process((CreateIndexExpression)expresion);
                  if (expresion is CreateForeignKeyExpression)
                      processor.Process((CreateForeignKeyExpression)expresion);
              }

              Assert.IsTrue(processor.TableExists(string.Empty, name), "SqlServer");

              var dumper = new SqlServerSchemaDumper(processor, new DebugAnnouncer());
              tables = dumper.ReadDbSchema();

              processor.CommitTransaction();
              }

              if (!string.IsNullOrEmpty(createSql))
              tables.Count.ShouldBe(1);

              return tables.Where(t => t.Name == name).FirstOrDefault();
        }

        public void CallingProcessWithPerformDBOperationExpressionWhenInPreviewOnlyModeWillNotMakeDbChanges()
        {
            var output = new StringWriter();

            var connection = new SqlConnection(IntegrationTestOptions.SqlServer2012.ConnectionString);

            var processor = new SqlServerProcessor(
                connection,
                new SqlServer2012Generator(),
                new TextWriterAnnouncer(output),
                new ProcessorOptions { PreviewOnly = true },
                new SqlServerDbFactory());

            bool tableExists;

            try
            {
                var expression =
                    new PerformDBOperationExpression
                    {
                        Operation = (con, trans) =>
                        {
                            var command = con.CreateCommand();
                            command.CommandText = "CREATE TABLE ProcessTestTable (test int NULL) ";
                            command.Transaction = trans;

                            command.ExecuteNonQuery();
                        }
                    };

                processor.Process(expression);

                tableExists = processor.TableExists("", "ProcessTestTable");
            }
            finally
            {
                processor.RollbackTransaction();

            }

            tableExists.ShouldBeFalse();

            string fmOutput = output.ToString();
            Assert.That(fmOutput, Is.StringContaining("/* Beginning Transaction */"));
            Assert.That(fmOutput, Is.StringContaining("/* Performing DB Operation */"));
            Assert.That(fmOutput, Is.StringContaining("/* Rolling back transaction */"));
        }

        /// <summary>
        /// Creates tables in SQL Server and asserts that they exist
        /// </summary>
        /// <param name="createTables">The tables to be created</param>
        private void CreateTables(params CreateTableExpression[] createTables)
        {
            if (createTables == null)
            return;

             using (var connection = new SqlConnection(_sqlContext.ConnectionString))
             {
            var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());

            foreach (var create in createTables)
            {
               processor.Process(create);
               Assert.IsTrue(processor.TableExists(string.Empty, create.TableName), "SqlServer " + create.TableName);
            }

            processor.CommitTransaction();
             }
        }

        /// <summary>
        /// Migrates tables from SQL Server to Oracle and queries the data in the new Oracle table
        /// </summary>
        /// <param name="expressions">The expressions to execute as part of the migration</param>
        /// <param name="expectedMigrations">The number of migrations that should be created</param>
        /// <param name="contextAction">Delegates that alter the context before the migration is executed</param>
        /// <returns>The data in the new Oracle table</returns>
        private DataSet MigrateToOracleWithData(IEnumerable<IMigrationExpression> expressions, int expectedMigrations, params Action<SchemaMigrationContext>[] contextAction)
        {
            var context = GetDefaultContext();
             context.GenerateAlternateMigrationsFor.Add(DatabaseType.Oracle);
             context.Type = context.Type | MigrationType.Data;

             if (contextAction != null)
             {
            foreach (var action in contextAction)
            {
               action(context);
            }
             }

             CreateTableExpression create = null;

             using (var connection = new SqlConnection(_sqlContext.ConnectionString))
             {
            var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());

            foreach (var action in expressions)
            {
               if (action is CreateTableExpression)
               {
                  create = (CreateTableExpression) action;
                  processor.Process(create);
                  Assert.IsTrue(processor.TableExists(string.Empty, create.TableName), "SqlServer " + create.TableName);
                  continue;
               }

               if (action is InsertDataExpression)
               {
                  var insert = (InsertDataExpression)action;
                  processor.Process(insert);
                  continue;
               }

               if (action is CreateIndexExpression)
               {
                  var index = (CreateIndexExpression)action;
                  processor.Process(index);
                  continue;
               }

               if (action is CreateForeignKeyExpression)
               {
                   var index = (CreateForeignKeyExpression)action;
                   processor.Process(index);
                   continue;
               }
            }

            processor.CommitTransaction();
             }

             MigrateTable(context);

             if (create != null)
            AssertOracleTablesExist(create);

             context.MigrationIndex.ShouldBe(expectedMigrations);

             return create != null ? GetOracleTableData(create.TableName) : null;
        }

        public void SqlServerMigrationsAreTransactional()
        {
            var connection = new SqlConnection(IntegrationTestOptions.SqlServer.ConnectionString);
            connection.Open();
            var processor = new SqlServerProcessor(connection, new SqlServer2000Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions());
            var runner = new MigrationVersionRunner(_conventions, processor, new MigrationLoader(_conventions), typeof(MigrationVersionRunnerTests).Assembly, typeof(InvalidMigration).Namespace, new TextWriterAnnouncer(System.Console.Out));

            try
            {
                runner.MigrateUp();
            }
            catch
            {
            }

            processor.TableExists("Users").ShouldBeFalse();
        }

        public void CanReadMultipleViews()
        {
            // Arrange
             var create = new CreateTableExpression
             {
            TableName = "Foo",
            Columns =
               new List<ColumnDefinition> { new ColumnDefinition { Name = "Id", Type = DbType.Int32 } }
             };

             IList<ViewDefinition> views;

             // Act
             using (var connection = new SqlConnection(ConnectionString))
             {
            var processor = new SqlServerProcessor(connection, new SqlServer2005Generator(), new DebugAnnouncer(), new ProcessorOptions());

            processor.Process(create);

            Assert.IsTrue(processor.TableExists(string.Empty, create.TableName), "SqlServer");

            processor.Execute("CREATE VIEW FooViewC AS SELECT Id FROM Foo");
            processor.Execute("CREATE VIEW FooViewB AS SELECT Id FROM Foo");
            processor.Execute("CREATE VIEW FooViewA AS SELECT Id FROM Foo");

            var dumper = new SqlServerSchemaDumper(processor, new DebugAnnouncer());
            views = dumper.ReadViewSchema();

            processor.CommitTransaction();
             }

             // Assert

             Assert.AreEqual(3, views.Count);

             Assert.AreEqual("FooViewA", views[0].Name);
             Assert.AreEqual("FooViewB", views[1].Name);
             Assert.AreEqual("FooViewC", views[2].Name);
        }