public int UpdateMany(string tableName, IEnumerable<IDictionary<string, object>> data,
                       IAdapterTransaction transaction, IList<string> keyFields)
 {
     IBulkUpdater bulkUpdater = ProviderHelper.GetCustomProvider<IBulkUpdater>(ConnectionProvider) ??
                                new BulkUpdater();
     return bulkUpdater.Update(this, tableName, data.ToList(), ((AdoAdapterTransaction)transaction).DbTransaction);
 }

 public IEnumerable<IDictionary<string, object>> InsertMany(string tableName,
                                                            IEnumerable<IDictionary<string, object>> data,
                                                            IAdapterTransaction transaction,
                                                            Func<IDictionary<string, object>, Exception, bool> onError, bool resultRequired)
 {
     return new AdoAdapterInserter(this, ((AdoAdapterTransaction)transaction).DbTransaction).InsertMany(
         tableName, data, onError, resultRequired);
 }

 private IEnumerable<IEnumerable<IEnumerable<KeyValuePair<string, object>>>> ExecuteFunction(string functionName,
     IDictionary<string, object> parameters, IAdapterTransaction transaction)
 {
     return new[]
            {
                Utils.ExecuteAndUnwrap(() => 
                    GetODataClient(transaction).ExecuteFunctionAsync(functionName, parameters))
            };
 }

 internal int Execute(ICommandBuilder commandBuilder, IAdapterTransaction transaction)
 {
     IDbTransaction dbTransaction = ((AdoAdapterTransaction) transaction).DbTransaction;
     return Execute(commandBuilder, dbTransaction);
 }

 public int Update(string tableName, IDictionary<string, object> data, IAdapterTransaction adapterTransaction)
 {
     var keyFieldNames = GetKeyFieldNames(tableName).ToArray();
     if (keyFieldNames.Length == 0) throw new AdoAdapterException("No Primary Key found for implicit update");
     return Update(tableName, data, GetCriteria(tableName, keyFieldNames, data), adapterTransaction);
 }

 public int Update(string tableName, IDictionary<string, object> data, IAdapterTransaction adapterTransaction)
 {
     string[] keyFieldNames = GetKeyNames(tableName).ToArray();
     if (keyFieldNames.Length == 0) throw new AdoAdapterException(string.Format("No primary key found for implicit update of table '{0}'.", tableName));
     return Update(tableName, data, GetCriteria(tableName, keyFieldNames, data), adapterTransaction);
 }

 public override IDictionary<string, object> Upsert(string tableName, IDictionary<string, object> data, SimpleExpression criteria, bool resultRequired, IAdapterTransaction adapterTransaction)
 {
     var transaction = ((AdoAdapterTransaction) adapterTransaction).DbTransaction;
     return new AdoAdapterUpserter(this, transaction).Upsert(tableName, data, criteria, resultRequired);
 }

 public int Delete(string tableName, SimpleExpression criteria, IAdapterTransaction transaction)
 {
     return Delete(tableName, criteria);
 }

 public int Update(string tableName, IDictionary<string, object> data, SimpleExpression criteria, IAdapterTransaction transaction)
 {
     return Update(tableName, data, criteria);
 }

 public IDictionary<string, object> Insert(string tableName, IDictionary<string, object> data, IAdapterTransaction transaction, bool resultRequired)
 {
     return Insert(tableName, data, resultRequired);
 }

 public IEnumerable<IDictionary<string, object>> Find(string tableName, SimpleExpression criteria, IAdapterTransaction transaction)
 {
     return Find(tableName, criteria);
 }

 public IDictionary<string, object> Insert(string tableName, IDictionary<string, object> data, IAdapterTransaction transaction)
 {
     return new AdoAdapterInserter(this, ((AdoAdapterTransaction)transaction).Transaction).Insert(tableName, data);
 }

 private static int Execute(ICommandBuilder commandBuilder, IAdapterTransaction transaction)
 {
     var dbTransaction = ((AdoAdapterTransaction) transaction).Transaction;
     using (var command = commandBuilder.GetCommand(dbTransaction.Connection))
     {
         command.Transaction = dbTransaction;
         return TryExecute(command);
     }
 }

 public IEnumerable<IDictionary<string, object>> Find(string tableName, SimpleExpression criteria,
                                                      IAdapterTransaction transaction)
 {
     return new AdoAdapterFinder(this, ((AdoAdapterTransaction)transaction).DbTransaction).Find(tableName,
                                                                                               criteria);
 }

 public IDictionary<string, object> Insert(string tableName, IDictionary<string, object> data,
                                           IAdapterTransaction transaction, bool resultRequired)
 {
     return new AdoAdapterInserter(this, ((AdoAdapterTransaction)transaction).DbTransaction).Insert(tableName,
                                                                                                   data, resultRequired);
 }

 public int UpdateMany(string tableName, IEnumerable<IDictionary<string, object>> dataList, IAdapterTransaction adapterTransaction, IList<string> keyFields)
 {
     return UpdateMany(tableName, dataList, keyFields);
 }

 public int Delete(string tableName, SimpleExpression criteria, IAdapterTransaction transaction)
 {
     ICommandBuilder commandBuilder = new DeleteHelper(_schema).GetDeleteCommand(tableName, criteria);
     return Execute(commandBuilder, transaction);
 }

 public override IEnumerable<IDictionary<string, object>> UpsertMany(string tableName, IList<IDictionary<string, object>> list, IEnumerable<string> keyFieldNames, IAdapterTransaction adapterTransaction, bool isResultRequired, Func<IDictionary<string, object>, Exception, bool> errorCallback)
 {
     var transaction = ((AdoAdapterTransaction) adapterTransaction).DbTransaction;
     return new AdoAdapterUpserter(this, transaction).UpsertMany(tableName, list, keyFieldNames.ToArray(), isResultRequired, errorCallback);
 }

        //public IAdapterTransaction BeginTransaction()
        //{
        //    IDbConnection connection = CreateConnection();
        //    connection.OpenIfClosed();
        //    IDbTransaction transaction = connection.BeginTransaction();
        //    return new AdoAdapterTransaction(transaction, _sharedConnection != null);
        //}

        //public IAdapterTransaction BeginTransaction(string name)
        //{
        //    IDbConnection connection = CreateConnection();
        //    connection.OpenIfClosed();
        //    var sqlConnection = connection as SqlConnection;
        //    IDbTransaction transaction = sqlConnection != null
        //                                     ? sqlConnection.BeginTransaction(name)
        //                                     : connection.BeginTransaction();

        //    return new AdoAdapterTransaction(transaction, name, _sharedConnection != null);
        //}

        public IDictionary<string,object> Get(string tableName, IAdapterTransaction transaction, params object[] parameterValues)
        {
            return new AdoAdapterGetter(this, ((AdoAdapterTransaction) transaction).DbTransaction).Get(tableName,
                                                                                                     parameterValues);
        }

 public IEnumerable<IEnumerable<IEnumerable<KeyValuePair<string, object>>>> Execute(string functionName,
     IDictionary<string, object> parameters, IAdapterTransaction transaction)
 {
     return ExecuteFunction(functionName, parameters, transaction);
 }