private static Dictionary <Column, object> BuildDataDictionary(AdoAdapter adapter, IDictionary <string, object> data, Table table)
{
Func <string, bool> columnFilter;
if (adapter.AdoOptions != null && adapter.AdoOptions.IdentityInsert)
{
columnFilter =
key =>
{
Column column;
if (table.TryFindColumn(key, out column))
{
return(column.IsWriteable || column.IsIdentity);
}
return(false);
};
}
else
{
columnFilter = key => table.HasColumn(key) && table.FindColumn(key).IsWriteable;
}
var dataDictionary = data.Where(kvp => columnFilter(kvp.Key))
.ToDictionary(kvp => table.FindColumn(kvp.Key), kvp => kvp.Value);
return(dataDictionary);
}
public void ModifiesConnection()
{
var adapter = new AdoAdapter(new StubConnectionProvider());
adapter.SetConnectionModifier(c => new FooConnection(c));
Assert.IsInstanceOf <FooConnection>(adapter.CreateConnection());
}
private DataTable CreateDataTable(AdoAdapter adapter, string tableName, ICollection<string> keys, SABulkCopy bulkCopy)
{
var table = adapter.GetSchema().FindTable(tableName);
var dataTable = new DataTable(table.ActualName);
foreach (var key in keys)
{
if (table.HasColumn(key))
{
var column = (SqlAnywhereColumn)table.FindColumn(key);
dataTable.Columns.Add(column.ActualName, DbTypeLookup.GetClrType(column.SADbType));
if (!column.IsIdentity)
{
bulkCopy.ColumnMappings.Add(column.ActualName, column.ActualName);
}
}
else
{
// For non-matching columns, add a dummy DataColumn to make inserting rows easier.
dataTable.Columns.Add(Guid.NewGuid().ToString("N"));
}
}
return dataTable;
}
public IDictionary <string, object> Insert(AdoAdapter adapter, string tableName, IDictionary <string, object> data, IDbTransaction transaction = null,
bool resultRequired = false)
{
var table = adapter.GetSchema().FindTable(tableName);
var dataDictionary = BuildDataDictionary(adapter, data, table);
string columnList = dataDictionary.Keys.Select(c => c.QuotedName).Aggregate((agg, next) => agg + "," + next);
string valueList = dataDictionary.Keys.Select(s => "?").Aggregate((agg, next) => agg + "," + next);
var insertSql = new StringBuilder();
insertSql.AppendFormat("INSERT INTO {0} ({1}) VALUES ({2});", table.QualifiedName, columnList, valueList);
if (resultRequired)
{
var identityColumn = table.Columns.FirstOrDefault(c => c.IsIdentity);
if (identityColumn != null)
{
insertSql.AppendFormat(" SELECT * FROM {0} WHERE {1} = LAST_INSERT_ID();", table.QualifiedName,
identityColumn.QuotedName);
return(ExecuteSingletonQuery(adapter, insertSql.ToString(), dataDictionary.Keys,
dataDictionary.Values, transaction));
}
}
Execute(adapter, insertSql.ToString(), dataDictionary.Keys, dataDictionary.Values, transaction);
return(null);
}
public IDictionary <string, object> Insert(AdoAdapter adapter, string tableName, IDictionary <string, object> data, IDbTransaction transaction = null,
bool resultRequired = false)
{
var table = adapter.GetSchema().FindTable(tableName);
var insertData = data.Where(p => table.HasColumn(p.Key)).Select((kv, idx) => new InsertColumn
{
Name = kv.Key,
ParameterName = "@p" + idx,
Value = kv.Value,
Column = (FbColumn)table.FindColumn(kv.Key)
}).ToArray();
if (transaction == null)
{
using (var connection = adapter.ConnectionProvider.CreateConnection())
{
connection.Open();
return(CreateAndExecuteInsertCommand(connection, table, insertData, resultRequired));
}
}
else
{
return(CreateAndExecuteInsertCommand(transaction.Connection, table, insertData, resultRequired, transaction));
}
}
public void ClearsConnection()
{
var adapter = new AdoAdapter(new StubConnectionProvider());
adapter.SetConnectionModifier(c => new FooConnection(c));
Assert.IsInstanceOf<FooConnection>(adapter.CreateConnection());
adapter.ClearConnectionModifier();
Assert.IsNotInstanceOf<FooConnection>(adapter.CreateConnection());
}
static void Main(string[] args)
{
//var ador = new AdoReader();
var adoa = new AdoAdapter();
//ador.GetCustomers();
adoa.GetCustomers();
}
public void ConnectionCreatedCanOverrideConnection()
{
EventHandler<ConnectionCreatedEventArgs> handler = (o, e) => e.OverrideConnection(new BarConnection(e.Connection));
AdoAdapter.ConnectionCreated += handler;
var adapter = new AdoAdapter(new StubConnectionProvider());
var connection = adapter.CreateConnection();
Assert.IsInstanceOf<BarConnection>(connection);
AdoAdapter.ConnectionCreated -= handler;
}
public IEnumerable<IDictionary<string, object>> Insert(AdoAdapter adapter, string tableName, IEnumerable<IDictionary<string, object>> data, IDbTransaction transaction, Func<IDictionary<string, object>, Exception, bool> onError, bool resultRequired)
{
if (resultRequired)
{
return new BulkInserter().Insert(adapter, tableName, data, transaction, onError, resultRequired);
}
int count = 0;
DataTable dataTable = null;
SqlConnection connection;
SqlBulkCopy bulkCopy;
var sqlBulkCopyOptions = BuildBulkCopyOptions(adapter);
if (transaction != null)
{
connection = (SqlConnection) transaction.Connection;
bulkCopy = new SqlBulkCopy(connection, sqlBulkCopyOptions, (SqlTransaction)transaction);
}
else
{
connection = (SqlConnection) adapter.CreateConnection();
bulkCopy = new SqlBulkCopy(connection, sqlBulkCopyOptions, null);
}
bulkCopy.DestinationTableName = adapter.GetSchema().FindTable(tableName).QualifiedName;
using (connection.MaybeDisposable())
using (bulkCopy)
{
connection.OpenIfClosed();
var dataList = data.ToList();
foreach (var record in dataList)
{
if (count == 0)
{
dataTable = CreateDataTable(adapter, tableName, dataList.SelectMany(r => r.Keys).Distinct(), bulkCopy);
}
AddRow(dataTable, record);
if (++count%5000 == 0)
{
bulkCopy.WriteToServer(dataTable);
dataTable.Clear();
}
}
if (dataTable.Rows.Count > 0)
{
bulkCopy.WriteToServer(dataTable);
}
}
return null;
}
public IEnumerable <IDictionary <string, object> > Insert(AdoAdapter adapter, string tableName, IEnumerable <IDictionary <string, object> > data, IDbTransaction transaction, Func <IDictionary <string, object>, Exception, bool> onError, bool resultRequired)
{
if (resultRequired)
{
return(new BulkInserter().Insert(adapter, tableName, data, transaction, onError, resultRequired));
}
int count = 0;
DataTable dataTable = null;
SqlConnection connection;
SqlBulkCopy bulkCopy;
var sqlBulkCopyOptions = BuildBulkCopyOptions(adapter);
if (transaction != null)
{
connection = (SqlConnection)transaction.Connection;
bulkCopy = new SqlBulkCopy(connection, sqlBulkCopyOptions, (SqlTransaction)transaction);
}
else
{
connection = (SqlConnection)adapter.CreateConnection();
bulkCopy = new SqlBulkCopy(connection, sqlBulkCopyOptions, null);
}
bulkCopy.DestinationTableName = adapter.GetSchema().FindTable(tableName).QualifiedName;
using (connection.MaybeDisposable())
using (bulkCopy)
{
connection.OpenIfClosed();
var dataList = data.ToList();
foreach (var record in dataList)
{
if (count == 0)
{
dataTable = CreateDataTable(adapter, tableName, dataList.SelectMany(r => r.Keys).Distinct(), bulkCopy);
}
AddRow(dataTable, record);
if (++count % 5000 == 0)
{
bulkCopy.WriteToServer(dataTable);
dataTable.Clear();
}
}
if (dataTable.Rows.Count > 0)
{
bulkCopy.WriteToServer(dataTable);
}
}
return(null);
}
public void ConnectionCreatedEventFires()
{
bool fired = false;
EventHandler<ConnectionCreatedEventArgs> handler = (o, e) => { fired = true; };
AdoAdapter.ConnectionCreated += handler;
var adapter = new AdoAdapter(new StubConnectionProvider());
var connection = adapter.CreateConnection();
AdoAdapter.ConnectionCreated -= handler;
Assert.True(fired);
}
public void ConnectionCreatedCanOverrideConnection()
{
EventHandler <ConnectionCreatedEventArgs> handler = (o, e) => e.OverrideConnection(new BarConnection(e.Connection));
AdoAdapter.ConnectionCreated += handler;
var adapter = new AdoAdapter(new StubConnectionProvider());
var connection = adapter.CreateConnection();
Assert.IsInstanceOf <BarConnection>(connection);
AdoAdapter.ConnectionCreated -= handler;
}
public IEnumerable <IDictionary <string, object> > Insert(AdoAdapter adapter, string tableName, IEnumerable <IDictionary <string, object> > data, IDbTransaction transaction, Func <IDictionary <string, object>, Exception, bool> onError, bool resultRequired)
{
var table = DatabaseSchema.Get(adapter.ConnectionProvider, adapter.ProviderHelper).FindTable(tableName);
if (table == null)
{
throw new SimpleDataException(String.Format("Table '{0}' not found", tableName));
}
var insertData = data.Select(row => row.Where(p => table.HasColumn(p.Key) && !table.FindColumn(p.Key).IsIdentity).ToDictionary());
var insertColumns = insertData.First().Keys.Select(table.FindColumn).ToArray();
var columnsSql = insertColumns.Select(s => s.QuotedName).Aggregate((agg, next) => String.Concat(agg, ",", next));
var valuesSql = insertColumns.Select((val, idx) => ":p" + idx.ToString()).Aggregate((agg, next) => String.Concat(agg, ",", next));
var insertSql = string.Format("INSERT INTO {0} ({1}) VALUES({2}){3};", table.QualifiedName, columnsSql, valuesSql, resultRequired ? " RETURNING *" : "");
if (transaction != null)
{
using (var cmd = transaction.Connection.CreateCommand())
{
cmd.Transaction = transaction;
cmd.CommandText = insertSql;
if (resultRequired)
{
return(insertData.Select(row => ExecuteInsert(cmd, insertColumns, row, onError)).ToList());
}
else
{
insertData.Select(row => ExecuteInsert(cmd, insertColumns, row, onError));
return(null);
}
}
}
using (var conn = adapter.ConnectionProvider.CreateConnection())
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = insertSql;
if (resultRequired)
{
return(insertData.Select(row => ExecuteInsert(cmd, insertColumns, row, onError)).ToList());
}
else
{
insertData.Select(row => ExecuteInsert(cmd, insertColumns, row, onError));
return(null);
}
}
}
}
private static Dictionary <Column, object> BuildDataDictionary(AdoAdapter adapter,
IDictionary <string, object> data, Table table)
{
Func <string, bool> columnFilter = key =>
table.HasColumn(key) &&
(table.FindColumn(key).IsWriteable ||
((adapter.AdoOptions != null && adapter.AdoOptions.IdentityInsert) && table.FindColumn(key).IsIdentity));
return(data.Where(kvp => columnFilter(kvp.Key))
.ToDictionary(kvp => table.FindColumn(kvp.Key), kvp => kvp.Value));
}
public void ConnectionCreatedEventFires()
{
bool fired = false;
EventHandler <ConnectionCreatedEventArgs> handler = (o, e) => { fired = true; };
AdoAdapter.ConnectionCreated += handler;
var adapter = new AdoAdapter(new StubConnectionProvider());
var connection = adapter.CreateConnection();
AdoAdapter.ConnectionCreated -= handler;
Assert.True(fired);
}
public static IEnumerable <IEnumerable <dynamic> > ToResultSets(
this AdoAdapter adapter,
string sql,
IDictionary <string, object> parameters)
{
if (!adapter.ConnectionProvider.SupportsCompoundStatements)
{
throw new NotSupportedException(string.Format("{0} does not support compound statements",
adapter.GetType()));
}
return(adapter.GetConnection().ToResultSets(sql, parameters));
}
public IEnumerable<IDictionary<string, object>> Insert(AdoAdapter adapter, string tableName, IEnumerable<IDictionary<string, object>> data, IDbTransaction transaction, Func<IDictionary<string, object>, Exception, bool> onError, bool resultRequired)
{
if (resultRequired)
{
return new BulkInserter().Insert(adapter, tableName, data, transaction, onError, resultRequired);
}
int count = 0;
DataTable dataTable = null;
SAConnection connection;
SABulkCopy bulkCopy;
if (transaction != null)
{
connection = (SAConnection) transaction.Connection;
bulkCopy = new SABulkCopy(connection, SABulkCopyOptions.Default, (SATransaction)transaction);
}
else
{
connection = (SAConnection)adapter.CreateConnection();
bulkCopy = new SABulkCopy(connection);
}
bulkCopy.DestinationTableName = adapter.GetSchema().FindTable(tableName).ActualName;
using (connection.MaybeDisposable())
using (bulkCopy)
{
connection.OpenIfClosed();
foreach (var record in data)
{
if (count == 0)
{
dataTable = CreateDataTable(adapter, tableName, record.Keys, bulkCopy);
}
dataTable.Rows.Add(record.Values.ToArray());
if (++count%5000 == 0)
{
bulkCopy.WriteToServer(dataTable);
dataTable.Clear();
}
}
if (dataTable.Rows.Count > 0)
{
bulkCopy.WriteToServer(dataTable);
}
}
return null;
}
public IEnumerable <IDictionary <string, object> > Insert(AdoAdapter adapter, string tableName, IEnumerable <IDictionary <string, object> > data, IDbTransaction transaction, Func <IDictionary <string, object>, Exception, bool> onError, bool resultRequired)
{
if (resultRequired)
{
return(new BulkInserter().Insert(adapter, tableName, data, transaction, onError, resultRequired));
}
int count = 0;
DataTable dataTable = null;
SqlConnection connection;
SqlBulkCopy bulkCopy;
if (transaction != null)
{
connection = (SqlConnection)transaction.Connection;
bulkCopy = new SqlBulkCopy(connection, SqlBulkCopyOptions.Default, (SqlTransaction)transaction);
}
else
{
connection = (SqlConnection)adapter.CreateConnection();
bulkCopy = new SqlBulkCopy(connection);
}
bulkCopy.DestinationTableName = adapter.GetSchema().FindTable(tableName).ActualName;
using (connection.MaybeDisposable())
using (bulkCopy)
{
connection.OpenIfClosed();
foreach (var record in data)
{
if (count == 0)
{
dataTable = CreateDataTable(adapter, tableName, record.Keys, bulkCopy);
}
dataTable.Rows.Add(record.Values.ToArray());
if (++count % 5000 == 0)
{
bulkCopy.WriteToServer(dataTable);
dataTable.Clear();
}
}
if (dataTable.Rows.Count > 0)
{
bulkCopy.WriteToServer(dataTable);
}
}
return(null);
}
private SqlBulkCopyOptions BuildBulkCopyOptions(AdoAdapter adapter)
{
var options = SqlBulkCopyOptions.Default;
if (adapter.AdoOptions != null)
{
options |= (adapter.AdoOptions.FireTriggersOnBulkInserts
? SqlBulkCopyOptions.FireTriggers
: SqlBulkCopyOptions.Default);
}
return options;
}
private SqlBulkCopyOptions BuildBulkCopyOptions(AdoAdapter adapter)
{
var options = SqlBulkCopyOptions.Default;
if (adapter.AdoOptions != null)
{
options |= (adapter.AdoOptions.FireTriggersOnBulkInserts
? SqlBulkCopyOptions.FireTriggers
: SqlBulkCopyOptions.Default);
}
return(options);
}
internal int Execute(AdoAdapter adapter, string sql, IEnumerable <Column> columns, IEnumerable <Object> values, IDbTransaction transaction)
{
if (transaction != null)
{
var command = new CommandHelper(adapter).CreateInsert(transaction.Connection, sql, columns, values.ToArray());
command.Transaction = transaction;
return(command.TryExecuteNonQuery());
}
var connection = adapter.CreateConnection();
using (connection.MaybeDisposable())
{
using (var command = new CommandHelper(adapter).CreateInsert(connection, sql, columns, values.ToArray()))
{
connection.OpenIfClosed();
return(command.TryExecuteNonQuery());
}
}
}
public static void InTransaction(this AdoAdapter adapter, Action <IDbTransaction> action)
{
using (var connection = adapter.ConnectionProvider.CreateConnection())
{
connection.Open();
using (var currentTransaction = connection.BeginTransaction())
{
action(currentTransaction);
try
{
currentTransaction.Commit();
}
catch (Exception)
{
currentTransaction.Rollback();
throw;
}
}
}
}
public IDictionary <string, object> Insert(AdoAdapter adapter, string tableName, IDictionary <string, object> data, IDbTransaction transaction, bool returnRequired)
{
var s = DatabaseSchema.Get(adapter.ConnectionProvider, new ProviderHelper());
var table = s.FindTable(tableName);
var tuples = InitializeInsertion(table);
foreach (var d in data)
{
tuples[d.Key.Homogenize()].InsertedValue = d.Value;
}
Func <IDbCommand> command =
() =>
{
var c = transaction != null
? transaction.Connection.CreateCommand()
: adapter.CreateConnection().CreateCommand();
return(c);
};
IDbCommand cmd;
using (cmd = ConstructCommand(tuples, table.QualifiedName, command))
{
cmd.WriteTrace();
cmd.Connection.TryOpen();
cmd.ExecuteNonQuery();
var returnData = new DbDictionary();
foreach (var it in tuples.Values)
{
returnData.Add(it.SimpleDataColumn, NormalizeReturningValue((IDbDataParameter)cmd.Parameters[it.ReturningParameterName]));
}
data = returnData;
}
return(data);
}
private DataTable CreateDataTable(AdoAdapter adapter, string tableName, ICollection <string> keys, SqlBulkCopy bulkCopy)
{
var table = adapter.GetSchema().FindTable(tableName);
var dataTable = new DataTable(table.ActualName);
foreach (var key in keys)
{
if (table.HasColumn(key))
{
var column = (SqlColumn)table.FindColumn(key);
dataTable.Columns.Add(column.ActualName, column.SqlDbType.ToClrType());
bulkCopy.ColumnMappings.Add(column.ActualName, column.ActualName);
}
else
{
// For non-matching columns, add a dummy DataColumn to make inserting rows easier.
dataTable.Columns.Add(Guid.NewGuid().ToString("N"));
}
}
return(dataTable);
}
public IDictionary <string, object> Insert(AdoAdapter adapter, string tableName, IDictionary <string, object> data, IDbTransaction transaction)
{
var table = DatabaseSchema.Get(adapter.ConnectionProvider, adapter.ProviderHelper).FindTable(tableName);
if (table == null)
{
throw new SimpleDataException(String.Format("Table '{0}' not found", tableName));
}
var insertData = data.Where(p => table.HasColumn(p.Key) && !table.FindColumn(p.Key).IsIdentity).ToDictionary();
var insertColumns = insertData.Keys.Select(table.FindColumn).ToArray();
var columnsSql = insertColumns.Select(s => s.QuotedName).Aggregate((agg, next) => String.Concat(agg, ",", next));
var valuesSql = insertColumns.Select((val, idx) => ":p" + idx.ToString()).Aggregate((agg, next) => String.Concat(agg, ",", next));
var insertSql = string.Format("INSERT INTO {0} ({1}) VALUES({2}) RETURNING *;", table.QualifiedName, columnsSql, valuesSql);
if (transaction != null)
{
using (var cmd = transaction.Connection.CreateCommand())
{
cmd.Transaction = transaction;
cmd.CommandText = insertSql;
return(ExecuteInsert(cmd, insertColumns, insertData.Values.ToArray()));
}
}
using (var conn = adapter.ConnectionProvider.CreateConnection())
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = insertSql;
return(ExecuteInsert(cmd, insertColumns, insertData.Values.ToArray()));
}
}
}
public OracleQueryBuilder(AdoAdapter adapter, int bulkIndex, IFunctionNameConverter functionNameConverter)
: base(adapter, bulkIndex, functionNameConverter)
{
}
public IProcedureExecutor GetProcedureExecutor(AdoAdapter adapter, ObjectName procedureName)
{
throw new NotImplementedException();
}
public PgProcedureExecutor(AdoAdapter adapter, ObjectName procedureName)
{
Adapter = adapter;
ProcedureName = procedureName;
}
public SqlQueryBuilder(AdoAdapter adapter, int bulkIndex)
: base(adapter, bulkIndex)
{
}
public IEnumerable <IDictionary <string, object> > Insert(AdoAdapter adapter, string tableName, IEnumerable <IDictionary <string, object> > dataList, IDbTransaction transaction, Func <IDictionary <string, object>, Exception, bool> onError,
bool resultRequired)
{
//ToDo: support onError collection
List <IDictionary <string, object> > result = new List <IDictionary <string, object> >();
if (transaction == null)
{
adapter.InTransaction(currentTransaction =>
{
result = (List <IDictionary <string, object> >)Insert(adapter, tableName, dataList, currentTransaction, onError, resultRequired);
});
return(result);
}
var table = adapter.GetSchema().FindTable(tableName);
var tableColumns = table.Columns.Select(c => (FbColumn)c).ToArray();
var nameToFbColumns = tableColumns.ToDictionary(c => c.HomogenizedName, c => c);
var insertContext = CreateInsertSqlContext(table.QualifiedName, tableColumns);
var queryBuilder = new FbBulkInsertQueryBuilder(resultRequired, insertContext.ReturnsExecuteBlockSql);
var insertSqlProvider = new FbBulkInsertSqlProvider();
var currentColumns = new List <InsertColumn>();
foreach (var data in dataList)
{
var insertData = data.Where(p => nameToFbColumns.ContainsKey(p.Key.Homogenize())).Select(kv => new InsertColumn
{
Value = kv.Value,
Column = nameToFbColumns[kv.Key.Homogenize()]
}).ToArray();
ExecuteBlockInsertSql insertSql = insertSqlProvider.GetInsertSql(insertContext, insertData, resultRequired);
if (insertContext.SkipCommandParameters && !CanInsertInExecuteBlock(insertSql.InsertSql, queryBuilder))
{
insertSql = insertSqlProvider.GetInsertSql(insertContext, insertData, resultRequired, skipCommandParameters: false);
}
if (queryBuilder.CanAddQuery(insertSql))
{
queryBuilder.AddQuery(insertSql);
if (!insertContext.SkipCommandParameters)
{
currentColumns.AddRange(insertData);
}
}
else
{
var subResult = CreateAndExecuteInsertCommand(transaction, currentColumns, queryBuilder.GetSql(), resultRequired);
if (resultRequired)
{
result.AddRange(subResult);
}
currentColumns.Clear();
queryBuilder = new FbBulkInsertQueryBuilder(resultRequired, insertContext.ReturnsExecuteBlockSql);
queryBuilder.AddQuery(insertSql);
if (!insertContext.SkipCommandParameters)
{
currentColumns.AddRange(insertData);
}
}
}
if (queryBuilder.QueryCount > 0)
{
var subResult = CreateAndExecuteInsertCommand(transaction, currentColumns, queryBuilder.GetSql(), resultRequired);
if (resultRequired)
{
result.AddRange(subResult);
}
}
return(result);
}
public IProcedureExecutor GetProcedureExecutor(AdoAdapter adapter, ObjectName procedureName)
{
procedureName = new ObjectName(procedureName.Schema ?? UserOfConnection.ToUpperInvariant(), procedureName.Name);
return(new OracleProcedureExecutor(this, procedureName));
}
public IDictionary<string, object> Insert(AdoAdapter adapter, string tableName, IDictionary<string, object> data)
{
throw new NotImplementedException();
}
private DataTable CreateDataTable(AdoAdapter adapter, string tableName, IEnumerable<string> keys, SqlBulkCopy bulkCopy)
{
var table = adapter.GetSchema().FindTable(tableName);
var dataTable = new DataTable(table.ActualName);
foreach (var key in keys)
{
if (table.HasColumn(key))
{
var column = (SqlColumn)table.FindColumn(key);
dataTable.Columns.Add(column.ActualName, column.SqlDbType.ToClrType());
bulkCopy.ColumnMappings.Add(column.ActualName, column.ActualName);
}
else
{
// For non-matching columns, add a dummy DataColumn to make inserting rows easier.
dataTable.Columns.Add(Guid.NewGuid().ToString("N"));
}
}
return dataTable;
}
public IDictionary <string, object> Insert(AdoAdapter adapter, string tableName, IDictionary <string, object> data, IDbTransaction transaction = null)
{
throw new NotImplementedException();
}
public IProcedureExecutor GetProcedureExecutor(AdoAdapter adapter, ObjectName procedureName)
{
throw new NotImplementedException();
}
public IDictionary<string, object> Insert(AdoAdapter adapter, string tableName, IDictionary<string, object> data, IDbTransaction transaction = null, bool resultRequired = false)
{
throw new NotImplementedException();
}
public IProcedureExecutor GetProcedureExecutor(AdoAdapter adapter, ObjectName procedureName)
{
throw new NotSupportedException("SQL Server Compact Edition does not support stored procedures.");
}
public ICommandBuilder Build(AdoAdapter adapter, int bulkIndex, SimpleQuery query, out IEnumerable <SimpleQueryClauseBase> unhandledClauses)
{
return(new SqlQueryBuilder(adapter, bulkIndex).Build(query, out unhandledClauses));
}
public ICommandBuilder Build(AdoAdapter adapter, int bulkIndex, SimpleQuery query, out IEnumerable <SimpleQueryClauseBase> unhandledClauses)
{
return(new OracleQueryBuilder(adapter, bulkIndex, new OracleFunctionNameConverter()).Build(query, out unhandledClauses));
}
public AccessProcedureExectuor(AdoAdapter adapter, ObjectName procedureName)
{
_adapter = adapter;
_procedureName = procedureName;
}
public IProcedureExecutor GetProcedureExecutor(AdoAdapter adapter, ObjectName procedureName)
{
return(new PgProcedureExecutor(adapter, procedureName));
}
public IProcedureExecutor GetProcedureExecutor(AdoAdapter adapter, ObjectName procedureName)
{
return new ProcedureExecutor(adapter, procedureName);
}
