public void BootstrapDb()
        {
            Config.Global.DbConfigProvider   = new TestDbConfigProvider();
            Config.Global.DefaultSqlProvider = new DefaultSqlProvider();

            provider = Config.Global.DefaultSqlProvider;

            using (ScribeContext con = new ScribeContext())
            {
                var tableAttribute = TableAttribute.GetFor <Employee>();
                var meta           = ColumnMetadata.GetColumnMetadata <Employee>().Where(x => !x.IsNotMapped).ToList();

                bool employeeTableExists =
                    con.Connection.Query <int>("SELECT COUNT(*) FROM sys.tables where name like 'Employee'").First() == 1;

                if (!employeeTableExists)
                {
                    var employeeTable = provider.FormulateCreateTableStatement <Employee>(tableAttribute,
                                                                                          meta
                                                                                          );

                    con.Connection.Execute(employeeTable);
                    string alterStatement = @"
ALTER TABLE [dbo].[Employee]
DROP COLUMN XmlData;

ALTER TABLE [dbo].[Employee]
	ADD [XmlData] XML NOT NULL;

ALTER TABLE [dbo].[Employee]
	DROP COLUMN [Id];

ALTER TABLE [dbo].[Employee]
	ADD [Id] INT NOT NULL IDENTITY(1,1);

ALTER TABLE [dbo].[Employee]
	ADD CONSTRAINT PK_Employee PRIMARY KEY ([Id]);"    ;

                    con.Connection.Execute(alterStatement);
                }
                string truncateStatement = @"
TRUNCATE TABLE [dbo].[Employee]
";

                con.Connection.Execute(truncateStatement);



                con.Commit();
            }
        }
Ejemplo n.º 2
0
        protected virtual List <T> BulkExecuteMerge <T>(List <T> dataSource,
                                                        FormulateMerge <T> mergeStatementEngine)
        {
            if (dataSource == null)
            {
                throw new ArgumentNullException("dataSource");
            }
            if (mergeStatementEngine == null)
            {
                throw new ArgumentNullException("mergeStatementEngine");
            }
            if (dataSource.Count == 0)
            {
                throw new ArgumentException("dataSource cannot be empty");
            }

            var columns = ColumnMetadata.GetColumnMetadata <T>().Where(x => !x.IsNotMapped).ToList();

            using (SqlTransaction t = _conn.BeginTransaction(System.Data.IsolationLevel.ReadCommitted))
            {
                Guid session = Guid.NewGuid();

                TableAttribute tempIn      = new TableAttribute("temp" + session.ToString(), "dbo");
                TableAttribute tempOut     = new TableAttribute("tempOut" + session.ToString(), "dbo");
                TableAttribute destination = TableAttribute.GetFor <T>();

                String tempInTableCreate  = Config.Global.DefaultSqlProvider.FormulateCreateTableStatement <T>(tempIn, columns);
                String tempOutTableCreate = Config.Global.DefaultSqlProvider.FormulateCreateTableStatement <T>(tempOut, columns);

                var cmdTempInCreate  = NewCommand(tempInTableCreate, t);  //new SqlCommand(tempInTableCreate, _conn, t);
                var cmdTempOutCreate = NewCommand(tempOutTableCreate, t); //new SqlCommand(tempOutTableCreate, _conn, t);

                cmdTempInCreate.ExecuteNonQuery();
                cmdTempOutCreate.ExecuteNonQuery();

                SqlBulkCopy sbk = new SqlBulkCopy(_conn, SqlBulkCopyOptions.Default, t);
                sbk.BulkCopyTimeout      = Config.Global.DbConfigProvider.SqlBulkCopyTimeoutInSeconds;
                sbk.DestinationTableName = String.Format("[{0}].[{1}]", tempIn.SchemaName, tempIn.TableName);
                foreach (var c in columns)
                {
                    sbk.ColumnMappings.Add(c.AssociatedProperty.Name, c.AssociatedProperty.Name);
                }


                sbk.WriteToServer(DataTableFactory.CreateTableFromList <T>(dataSource, columns));

                String mergeStatement = mergeStatementEngine(columns, tempIn, destination, tempOut);

                var cmdMerge = NewCommand(mergeStatement, t); //new SqlCommand(mergeStatement, _conn, t);
                cmdMerge.ExecuteNonQuery();

                var outputResults = Config.Global.DefaultSqlProvider.GetOutputResults <T>(tempOut, _conn);

                if (outputResults == null || outputResults.Count != dataSource.Count)
                {
                    throw new RecordCountMismatchException(@"Merge completed suucessfully, but output record counts do not match input.  
This could indicate an issue with the primary keys or records in database not matching on update. 
Check keys and input data for operation.", dataSource.Count, outputResults != null ? outputResults.Count : 0);
                }


                var cmdDropInput = new SqlCommand(Config.Global.DefaultSqlProvider.FormulateDropTableStatement(tempIn),
                                                  _conn, t);

                var cmdDropOutput = new SqlCommand(Config.Global.DefaultSqlProvider.FormulateDropTableStatement(tempOut),
                                                   _conn, t);

                cmdDropInput.ExecuteNonQuery();
                cmdDropOutput.ExecuteNonQuery();

                t.Commit();

                return(outputResults);
            }
        }