Esempio n. 1
0
 public void Setup()
 {
     Connection = new SqlConnection(IntegrationTestOptions.SqlServer2008.ConnectionString);
     Processor = new SqlServerProcessor(Connection, new SqlServer2008Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions(), new SqlServerDbFactory());
     SchemaDumper = new SqlServerSchemaDumper(Processor, new TextWriterAnnouncer(System.Console.Out));
     Connection.Open();
 }
        static void Main(string[] args)
        {
            const string usage = @"Fluent Migrator Schema Dumper
  Usage:
    SchemaDumper.exe --connection CONNECTION [--file FILE] [--verbose] [--show] [--open]
    SchemaDumper.exe --version
    SchemaDumper.exe --help

  Options:
    --connection CONNECTION -c CONNECTION    The connection string. Required.
    --file FILE -f FILE                      File to output. Optional. [default: schemaDump.cs]
    --show -s                                Show output. Optional.
    --open -o                                Open file. Optional.
    --verbose                                Verbose. Optional.
    --help -h                                Show this screen.
    --version -v                             Show version.
";

            var arguments = new Docopt().Apply(usage, args, version: Assembly.GetExecutingAssembly().GetName().Version, exit: true);
            var file = arguments["--file"].ToString();
            var verbose = arguments["--verbose"].IsTrue;
            var open = arguments["--open"].IsTrue;
            var show = arguments["--show"].IsTrue;
            if (!Path.IsPathRooted(file)) file = Path.Combine(Environment.CurrentDirectory, file);
            var connectionString = arguments["--connection"].ToString();
            if (verbose) WriteLine($"Saving to {file}.");
            try { var builder = new SqlConnectionStringBuilder(connectionString); }
            catch (ArgumentException)
            {
                WriteLine("Connection string is in incorrect format.");
                return;
            }
            using (var connection = new SqlConnection(connectionString))
            {
                try { connection.Open(); }
                catch (SqlException ex)
                {
                    WriteLine($"Connection couldn't be established:\n{ex.Message}");
                    return;
                }
                var consoleAnnouncer = new ConsoleAnnouncer();
                var dumper = new SqlServerSchemaDumper(new SqlServerProcessor(connection, new SqlServer2000Generator(), consoleAnnouncer, new ProcessorOptions(), new SqlServerDbFactory()), consoleAnnouncer);
                var tables = dumper.ReadDbSchema();
                var writer = new RCDumpWriter();
                writer.WriteToFile(tables, file);
            }
            if (show) WriteLine(File.ReadAllText(file));
            if (open) try { Process.Start(file); } catch { }
            if (verbose) WriteLine("Done.");
        }
        private FunctionDefinition CreateFunction(string sql)
        {
            var processor = ((SqlServerProcessor)new SqlServerProcessorFactory().Create(ConnectionString,
             new DebugAnnouncer(), new ProcessorOptions()));

             processor.Execute(sql);

             var dumper = new SqlServerSchemaDumper(processor, new DebugAnnouncer());
             var functions = dumper.ReadFunctions();

             processor.CommitTransaction();

             functions.Count.ShouldBe(1);

             return functions[0];
        }
Esempio n. 4
0
        public static void Main(string[] args)
        {
            var connection = new SqlConnection("data source=172.16.1.186;UID=lssuser;PWD=password1;initial catalog=lss");

            var sb = new StringBuilder();
            var textWriter = new StringWriter(sb);
            var announcer = new TextWriterAnnouncer(textWriter);

            var generator = new SqlServer2008Generator();
            var processor = new SqlServerProcessor(connection, generator, announcer, new ProcessorOptions(), new SqlServerDbFactory());

            var dumper = new SqlServerSchemaDumper(processor, announcer);

            var schema = dumper.ReadDbSchema();
            var schemaWriter = new SchemaWriter();
            schemaWriter.WriteToFile(schema, "C:\\migration.cs");
        }
        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 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 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);
        }
 public SchemaDumpTests()
 {
     Connection = new SqlConnection(IntegrationTestOptions.SqlServer.ConnectionString);
     Processor = new SqlServerProcessor(Connection, new SqlServer2000Generator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions());
     SchemaDumper = new SqlServerSchemaDumper(Processor, new TextWriterAnnouncer(System.Console.Out));
 }