Ejemplo n.º 1
0
        public void OneTransactionAndParallelWritingWithMARS()
        {
            //Arrange
            TwoColumnsTableFixture s2c = new TwoColumnsTableFixture(SqlConnection, "TransactionSourceParallelWrite");

            s2c.InsertTestData();
            TwoColumnsTableFixture d2c1   = new TwoColumnsTableFixture(SqlConnection, "TransactionDest1");
            TwoColumnsTableFixture d2c2   = new TwoColumnsTableFixture(SqlConnection, "TransactionDest2");
            DbSource <MySimpleRow> source = new DbSource <MySimpleRow>(SqlConnection, "TransactionSourceParallelWrite");

            string constring = $"{Config.SqlConnection.RawConnectionString("DataFlow")};MultipleActiveResultSets=True;";
            var    marscon   = new SqlConnectionManager(constring);
            DbDestination <MySimpleRow> dest1     = new DbDestination <MySimpleRow>(marscon, "TransactionDest1", batchSize: 2);
            DbDestination <MySimpleRow> dest2     = new DbDestination <MySimpleRow>(marscon, "TransactionDest2", batchSize: 2);
            Multicast <MySimpleRow>     multicast = new Multicast <MySimpleRow>();

            //Act & Assert
            marscon.BeginTransaction(System.Data.IsolationLevel.ReadCommitted);
            source.LinkTo(multicast);
            multicast.LinkTo(dest1);
            multicast.LinkTo(dest2);

            source.Execute();
            dest1.Wait();
            dest2.Wait();
            marscon.CommitTransaction();

            d2c1.AssertTestData();
            d2c1.AssertTestData();
        }
        protected override void OnSetup()
        {
            var config = new ScriptDeployerConfig
            {
                DatabaseLookup      = "select 'model' [name]",
                ProjectsTableConfig = new ProjectsTableConfig
                {
                    Database = "master", CreateTable = "print 'done'", Insert = "print 'done'",
                    Read     = "select '14.12.01.01' -- {0}"
                },
                ValidationFilterConfig = new ValidationFilterConfig()
            };

            Given.Config = config;

            Then.Logger  = new Logger();
            Then.LogSink = new StringLogSink();
            Then.Logger.AddLogSink(Then.LogSink);
            var manager = new SqlConnectionManager(Given.Config.DatabaseLookup);

            manager.OpenConnection(".", "model");
            manager.BeginTransaction();

            Then.Manager = manager;
        }
Ejemplo n.º 3
0
        public RunnerResolution Go()
        {
            var commit = false;

            using (var connectionManager = new SqlConnectionManager(_config.DatabaseLookup))
            {
                RunnerResolution resolution;

                try
                {
                    LogOptions();

                    _logger.PostEntry("opening connection to server", _settings.Server);
                    connectionManager.OpenConnection(_settings.Server, "master");

                    if (_settings.UseTransaction)
                    {
                        _logger.PostEntry("BEGINNING TRANSACTION");
                        connectionManager.BeginTransaction();
                    }

                    var checker = _settings.BypassCheck ? null : CreateChecker();
                    var project = LoadProject(CreateParser(), checker);
                    if (_settings.CheckFilesOnly)
                    {
                        return(RunnerResolution.ValidationOnly);
                    }

                    DeployScripts(_config, project, connectionManager);

                    commit = _settings.ShouldRollback == false;
                }
                catch (RunnerException rex)
                {
                    _logger.PostEntryNoTimestamp(string.Empty);
                    _logger.PostEntry("<<< ERROR >>> {0}", rex.Message);
                    return(rex.RunnerResolution);
                }
                catch (Exception ex)
                {
                    _logger.PostException(ex);
                    return(RunnerResolution.ExceptionThrown);
                }
                finally
                {
                    resolution = ResolveTransaction(commit, connectionManager);
                }

                return(resolution);
            }
        }