public async Task BulkUpdateDataInTableWithCompositeAndIdentityPrimaryKey()
        {
            List <BulkUpdateItemComposite> actualData = null;

            using (var helper = CreateHelper(new[] { CompositeWithIdentity_CreateTable, CompositeWithIdentity_InsertData }))
                using (var bulkUpdate = new SqlServerBulkUpdate(helper.Connection))
                {
                    var dataToUpdate = new EnumerableDataReader <BulkUpdateItemComposite>(
                        new[] {
                        new BulkUpdateItemComposite()
                        {
                            Id1 = 1, Id2 = 2, Value = "lorem ipsum 2"
                        },
                        new BulkUpdateItemComposite()
                        {
                            Id1 = 2, Id2 = 3, Value = "lorem ipsum 3"
                        },
                        new BulkUpdateItemComposite()
                        {
                            Id1 = 3, Id2 = 6, Value = "lorem ipsum 6"
                        }
                    },
                        new[] { nameof(BulkUpdateItemComposite.Id1), nameof(BulkUpdateItemComposite.Id2), nameof(BulkUpdateItemIdentity.Value) });

                    bulkUpdate.DestinationTableName = CompositeWithIdentity_TableName;
                    bulkUpdate.PrimaryKeyColumn     = nameof(BulkUpdateItemComposite.Id1) + ", " + nameof(BulkUpdateItemComposite.Id2);
                    await bulkUpdate.UpdateAsync(dataToUpdate);

                    helper.Connection.Open();
                    actualData = LoadDataForTableWithCompositePk(helper.Connection, CompositeWithIdentity_TableName);
                }

            actualData.Should().Equal(new List <BulkUpdateItemComposite>(new[]
            {
                new BulkUpdateItemComposite()
                {
                    Id1 = 1, Id2 = 1, Value = "1 - 1"
                },
                new BulkUpdateItemComposite()
                {
                    Id1 = 1, Id2 = 2, Value = "lorem ipsum 2"
                },
                new BulkUpdateItemComposite()
                {
                    Id1 = 2, Id2 = 3, Value = "lorem ipsum 3"
                },
                new BulkUpdateItemComposite()
                {
                    Id1 = 2, Id2 = 4, Value = "2 - 4"
                },
                new BulkUpdateItemComposite()
                {
                    Id1 = 3, Id2 = 5, Value = "3 - 5"
                },
                new BulkUpdateItemComposite()
                {
                    Id1 = 3, Id2 = 6, Value = "lorem ipsum 6"
                },
            }));
        }
        public void UpdateManyItems()
        {
            IEnumerable <BulkUpdateItem> data = GetItems();

            using (var reader = new EnumerableDataReader <BulkUpdateItem>(data, new string[] { "Id", "Name" }))
            {
                using (var bulkUpdate = new SqlServerBulkUpdate("connection string"))
                {
                    bulkUpdate.DestinationTableName = "TableName";
                    bulkUpdate.PrimaryKeyColumn     = "Id";
                    bulkUpdate.Update(reader);
                }
            }
        }
        public void ThrowExceptionWhenPrimaryKeyIsNotSet()
        {
            Action action = () =>
            {
                using (var helper = CreateHelper(null))
                    using (var bulkUpdate = new SqlServerBulkUpdate(helper.Connection))
                    {
                        bulkUpdate.DestinationTableName = TableName;
                        bulkUpdate.Update(new DataTable());
                    }
            };

            action.Should().Throw <InvalidOperationException>();
        }
        public async Task BulkUpdateDataFromDataTableAsynchronously()
        {
            DataTable expectedData = CreateExpectedData();

            using (var bulkUpdate = new SqlServerBulkUpdate(ServerHelper.Connection))
            {
                bulkUpdate.DestinationTableName = TableName;
                bulkUpdate.PrimaryKeyColumn     = PrimaryKeyColumn;
                await bulkUpdate.UpdateAsync(expectedData);
            }

            DataTable actualData = LoadData(ServerHelper.Connection);

            SqlServerBulkHelper.CompareTables(actualData, expectedData);
        }
        public void ThrowExceptionWhenInputDataIsNull()
        {
            Action action = () =>
            {
                using (var helper = CreateHelper(null))
                    using (var bulkUpdate = new SqlServerBulkUpdate(helper.Connection))
                    {
                        bulkUpdate.DestinationTableName = TableName;
                        bulkUpdate.PrimaryKeyColumn     = PrimaryKeyColumn;
                        bulkUpdate.Update((IDataReader)null);
                    }
            };

            action.Should().Throw <ArgumentNullException>();
        }
        public void BulkUpdateDataFromDataTable()
        {
            DataTable expectedData = CreateExpectedData();
            DataTable actualData   = null;

            using (var bulkUpdate = new SqlServerBulkUpdate(ServerHelper.Connection))
            {
                bulkUpdate.DestinationTableName = TABLE_NAME;
                bulkUpdate.PrimaryKeyColumn     = PRIMARY_KEY_COLUMN;
                bulkUpdate.Update(expectedData);
            }

            actualData = LoadData(ServerHelper.Connection);

            SqlServerBulkHelper.CompareTables(actualData, expectedData);
        }
        public void BulkUpdateDataFromIBulkInsertDataReader()
        {
            DataTable expectedData = CreateExpectedData();

            using (IBulkActionDataReader reader = CreateDataReaderForUpdate())
                using (var bulkUpdate = new SqlServerBulkUpdate(ServerHelper.Connection))
                {
                    bulkUpdate.DestinationTableName = TableName;
                    bulkUpdate.PrimaryKeyColumn     = PrimaryKeyColumn;
                    bulkUpdate.Update(reader);
                }

            DataTable actualData = LoadData(ServerHelper.Connection);

            SqlServerBulkHelper.CompareTables(actualData, expectedData);
        }
        public async Task BulkUpdateDataFromIBulkInsertDataReaderAsynchronously()
        {
            DataTable expectedData = CreateExpectedData();
            DataTable actualData   = null;

            using (IBulkActionDataReader reader = CreateDataReaderForUpdate())
                using (var bulkUpdate = new SqlServerBulkUpdate(ServerHelper.Connection))
                {
                    bulkUpdate.DestinationTableName = TABLE_NAME;
                    bulkUpdate.PrimaryKeyColumn     = PRIMARY_KEY_COLUMN;
                    await bulkUpdate.UpdateAsync(reader);
                }

            actualData = LoadData(ServerHelper.Connection);

            SqlServerBulkHelper.CompareTables(actualData, expectedData);
        }
        public void BulkUpdateDataFromIDataReaderWithAction()
        {
            DataTable expectedData = CreateExpectedDataWithAction();
            DataTable actualData   = null;

            using (IBulkActionDataReader reader = CreateDataReaderForUpdate())
                using (var bulkUpdate = new SqlServerBulkUpdate(ServerHelper.Connection))
                {
                    bulkUpdate.DestinationTableName = TABLE_NAME;
                    bulkUpdate.PrimaryKeyColumn     = PRIMARY_KEY_COLUMN;
                    bulkUpdate.TempTableAction      = UpdateTempItems;
                    bulkUpdate.Update(reader);
                }

            actualData = LoadData(ServerHelper.Connection);

            SqlServerBulkHelper.CompareTables(actualData, expectedData);
        }
        public void BulkUpdateDataFromIDataReaderSynchronouslyWithoutDeadLock()
        {
            AsyncContext.Run(() =>
            {
                DataTable expectedData = CreateExpectedData();
                DataTable actualData   = null;

                using (IDataReader reader = expectedData.CreateDataReader())
                    using (var bulkUpdate = new SqlServerBulkUpdate(ServerHelper.Connection))
                    {
                        bulkUpdate.DestinationTableName = TableName;
                        bulkUpdate.PrimaryKeyColumn     = PrimaryKeyColumn;
                        bulkUpdate.Update(reader);
                    }

                actualData = LoadData(ServerHelper.Connection);

                SqlServerBulkHelper.CompareTables(actualData, expectedData);
            });
        }
        public async Task BulkUpdateDataInTableWithIdentityPrimaryKey()
        {
            List <BulkUpdateItemIdentity> actualData = null;

            using (var helper = CreateHelper(new[] { Identity_CreateTable, Identity_InsertData }))
                using (var bulkUpdate = new SqlServerBulkUpdate(helper.Connection))
                {
                    var dataToUpdate = new EnumerableDataReader <BulkUpdateItemIdentity>(
                        new[] { new BulkUpdateItemIdentity()
                                {
                                    Id = 2, Value = "lorem ipsum"
                                } },
                        new[] { nameof(BulkUpdateItemIdentity.Id), nameof(BulkUpdateItemIdentity.Value) });

                    bulkUpdate.DestinationTableName = Identity_TableName;
                    bulkUpdate.PrimaryKeyColumn     = nameof(BulkUpdateItemIdentity.Id);
                    await bulkUpdate.UpdateAsync(dataToUpdate);

                    helper.Connection.Open();
                    actualData = LoadDataForTableWithIdentity(helper.Connection);
                }

            actualData.Should().Equal(new List <BulkUpdateItemIdentity>(new[]
            {
                new BulkUpdateItemIdentity()
                {
                    Id = 1, Value = "one"
                },
                new BulkUpdateItemIdentity()
                {
                    Id = 2, Value = "lorem ipsum"
                },
                new BulkUpdateItemIdentity()
                {
                    Id = 3, Value = "three"
                }
            }));
        }