// methods
public async Task <BulkWriteOperationResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout, CancellationToken cancellationToken)
{
var slidingTimeout = new SlidingTimeout(timeout);
var batchResults = new List <BulkWriteBatchResult>();
var remainingRequests = Enumerable.Empty <WriteRequest>();
var hasWriteErrors = false;
var runCount = 0;
foreach (var run in FindRuns())
{
runCount++;
if (hasWriteErrors && _isOrdered)
{
remainingRequests = remainingRequests.Concat(run.Requests);
continue;
}
var batchResult = await ExecuteBatchAsync(connection, run, slidingTimeout, cancellationToken);
batchResults.Add(batchResult);
hasWriteErrors |= batchResult.HasWriteErrors;
}
if (runCount == 0)
{
throw new InvalidOperationException("Bulk write operation is empty.");
}
var combiner = new BulkWriteBatchResultCombiner(batchResults, _writeConcern.IsAcknowledged);
return(combiner.CreateResultOrThrowIfHasErrors(remainingRequests.ToList()));
}
public Either <RfcErrorInfo, Unit> AllowStartOfPrograms(IConnectionHandle connectionHandle,
StartProgramDelegate callback)
{
Logger.IfSome(l => l.LogTrace("Setting allow start of programs callback"));
Api.AllowStartOfPrograms(connectionHandle as ConnectionHandle, callback, out var errorInfo);
return(ResultOrError(Unit.Default, errorInfo.Code, errorInfo));
}
public Either <RfcErrorInfo, bool> IsConnectionHandleValid(IConnectionHandle connectionHandle)
{
Logger.IfSome(l => l.LogTrace("checking connection state", new { connectionHandle }));
var rc = Api.IsConnectionHandleValid(connectionHandle as ConnectionHandle, out var isValid, out var errorInfo);
return(ResultOrError(isValid, rc, errorInfo));
}
public static DataTable MetaTableColumns(IConnectionHandle handle, string tablename)
{
ConnectionHandle connection;
connection = (ConnectionHandle)handle;
return(connection.Connection.GetSchema("Columns", new string[] { null, null, tablename, null }));
}
public static void Close(IConnectionHandle handle)
{
ConnectionHandle connection;
connection = (ConnectionHandle)handle;
connection.Close();
}
public static void Open(IConnectionHandle handle)
{
ConnectionHandle connection;
connection = (ConnectionHandle)handle;
connection.Open();
}
public static void Close(IConnectionHandle handle)
{
ConnectionHandle connection;
connection = (ConnectionHandle)handle;
connection.Close();
}
public async Task <BulkWriteOperationResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout, CancellationToken cancellationToken)
{
var slidingTimeout = new SlidingTimeout(timeout);
var batchResults = new List <BulkWriteBatchResult>();
var remainingRequests = new List <WriteRequest>();
var hasWriteErrors = false;
var originalIndex = 0;
foreach (WriteRequest request in _requests)
{
if (hasWriteErrors && _isOrdered)
{
remainingRequests.Add(request);
continue;
}
var batchResult = await EmulateSingleRequestAsync(connection, request, originalIndex, slidingTimeout, cancellationToken);
batchResults.Add(batchResult);
hasWriteErrors |= batchResult.HasWriteErrors;
originalIndex++;
}
var combiner = new BulkWriteBatchResultCombiner(batchResults, _writeConcern.IsAcknowledged);
return(combiner.CreateResultOrThrowIfHasErrors(remainingRequests));
}
public Either <RfcErrorInfo, Unit> Invoke(IConnectionHandle connectionHandle, IFunctionHandle functionHandle)
{
Logger.IfSome(l => l.LogTrace("Invoking function", new { connectionHandle, functionHandle }));
var rc = Api.Invoke(connectionHandle as ConnectionHandle, functionHandle as FunctionHandle, out var errorInfo);
return(ResultOrError(Unit.Default, rc, errorInfo));
}
public Either <RfcErrorInfo, Unit> CancelConnection(IConnectionHandle connectionHandle)
{
Logger.IfSome(l => l.LogTrace("cancelling function", new { connectionHandle }));
var rc = Api.CancelConnection(connectionHandle as ConnectionHandle, out var errorInfo);
return(ResultOrError(Unit.Default, rc, errorInfo));
}
public static long ExecuteScalarL(IConnectionHandle handle, string query, params object[] parameterValues)
{
long result;
result = Convert.ToInt64(
ExecuteScalar(handle, query, parameterValues));
return(result);
}
public static decimal ExecuteScalarD(IConnectionHandle handle, string query, params object[] parameterValues)
{
decimal result;
result = Convert.ToDecimal(
ExecuteScalar(handle, query, parameterValues));
return(result);
}
public static int ExecuteScalarI(IConnectionHandle handle, string query, params object[] parameterValues)
{
int result;
result = Convert.ToInt32(
ExecuteScalar(handle, query, parameterValues));
return(result);
}
public static int ExecuteNonQuery(IConnectionHandle handle, string query, object[] parameterValues, IParameterHandle[] extraParameters)
{
ConnectionHandle connection;
DbTransaction transaction;
DbCommand command;
DbParameter parameter;
int numberOfRows;
connection = (ConnectionHandle)handle;
transaction = ((TransactionHandle)connection.TransactionHandle).Transaction;
command = connection.Factory.CreateCommand();
command.CommandText = query;
command.Connection = connection.Connection;
command.Transaction = transaction;
if (parameterValues != null)
{
for (int i = 0; i < parameterValues.Length; i++)
{
object paramValue = parameterValues[i];
//Datetime mapping
if (paramValue is DateTime && DateTime.MinValue.Equals((DateTime)paramValue))
{
paramValue = DBNull.Value;
}
//null mapping
if (paramValue == null)
{
paramValue = DBNull.Value;
}
parameter = connection.Factory.CreateParameter();
parameter.ParameterName = "prm" + i;
parameter.Value = paramValue;
command.Parameters.Add(parameter);
}
}
if (extraParameters != null)
{
foreach (ParameterHandle p in extraParameters)
{
if (p == null)
{
continue;
}
command.Parameters.Add(p.Parameter);
}
}
numberOfRows = command.ExecuteNonQuery();
return(numberOfRows);
}
public static ITransactionHandle BeginTransaction(IConnectionHandle handle)
{
ConnectionHandle connection;
ITransactionHandle transaction;
connection = (ConnectionHandle)handle;
transaction = connection.BeginTransaction();
return(transaction);
}
public static ITransactionHandle BeginTransaction(IConnectionHandle handle)
{
ConnectionHandle connection;
ITransactionHandle transaction;
connection = (ConnectionHandle)handle;
transaction = connection.BeginTransaction();
return transaction;
}
// methods
protected override IWireProtocol<WriteConcernResult> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var deleteRequest = (DeleteRequest)request;
return new DeleteWireProtocol(
CollectionNamespace,
deleteRequest.Criteria,
false, // isMulti
MessageEncoderSettings,
WriteConcern);
}
// methods
protected override IWireProtocol<BsonDocument> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var deleteRequest = (DeleteRequest)request;
return new DeleteWireProtocol(
DatabaseName,
CollectionName,
WriteConcern,
deleteRequest.Query,
isMulti: false);
}
private Task <BulkWriteOperationResult> ExecuteDeletesAsync(IConnectionHandle connection, IEnumerable <DeleteRequest> requests, TimeSpan timeout, CancellationToken cancellationToken)
{
var operation = new BulkDeleteOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
MaxBatchCount = _maxBatchCount,
MaxBatchLength = _maxBatchLength,
WriteConcern = _writeConcern
};
return(operation.ExecuteAsync(connection, timeout, cancellationToken));
}
// methods
public async Task <WriteConcernResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(connection, "connection");
var requests = _documentSource.GetRemainingItems().Select(d =>
{
if (d == null)
{
throw new ArgumentException("Batch contains one or more null documents.");
}
return(new InsertRequest(new BsonDocumentWrapper(d, _serializer)));
});
var operation = new BulkInsertOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
IsOrdered = !_continueOnError,
MaxBatchCount = _maxBatchCount,
MaxBatchLength = _maxMessageSize,
// ReaderSettings = ?
WriteConcern = _writeConcern,
// WriteSettings = ?
};
BulkWriteOperationResult bulkWriteResult;
BulkWriteOperationException bulkWriteException = null;
try
{
bulkWriteResult = await operation.ExecuteAsync(connection, timeout, cancellationToken).ConfigureAwait(false);
}
catch (BulkWriteOperationException ex)
{
bulkWriteResult = ex.Result;
bulkWriteException = ex;
}
var converter = new BulkWriteOperationResultConverter();
if (bulkWriteException != null)
{
throw converter.ToWriteConcernException(bulkWriteException);
}
else
{
if (_writeConcern.IsAcknowledged)
{
return(converter.ToWriteConcernResult(bulkWriteResult));
}
else
{
return(null);
}
}
}
// methods
protected override IWireProtocol <BsonDocument> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var deleteRequest = (DeleteRequest)request;
return(new DeleteWireProtocol(
DatabaseName,
CollectionName,
WriteConcern,
deleteRequest.Query,
isMulti: false));
}
public async Task <BulkWriteOperationResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout, CancellationToken cancellationToken)
{
if (connection.Description.ServerVersion >= new SemanticVersion(2, 6, 0))
{
return(await ExecuteBatchesAsync(connection, timeout, cancellationToken).ConfigureAwait(false));
}
else
{
var emulator = CreateEmulator();
return(await emulator.ExecuteAsync(connection, timeout, cancellationToken).ConfigureAwait(false));
}
}
// methods
protected override IWireProtocol<BsonDocument> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var updateRequest = (UpdateRequest)request;
return new UpdateWireProtocol(
DatabaseName,
CollectionName,
WriteConcern,
updateRequest.Query,
updateRequest.Update,
updateRequest.IsMultiUpdate ?? false,
updateRequest.IsUpsert ?? false);
}
// methods
protected override IWireProtocol <WriteConcernResult> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var deleteRequest = (DeleteRequest)request;
var isMulti = deleteRequest.Limit == 0;
return(new DeleteWireProtocol(
CollectionNamespace,
deleteRequest.Criteria,
isMulti,
MessageEncoderSettings,
WriteConcern));
}
public Connection(
IConnectionHandle connectionHandle,
IRfcRuntime rfcRuntime)
{
_stateAgent = Agent.Start <IConnectionHandle, AgentMessage, Either <RfcErrorInfo, object> >(
connectionHandle, (handle, msg) =>
{
if (handle == null)
{
return(null,
new RfcErrorInfo(RfcRc.RFC_INVALID_HANDLE, RfcErrorGroup.EXTERNAL_RUNTIME_FAILURE,
"Connection already destroyed", "", "", "", "", "", "", "", ""));
}
// methods
protected override IWireProtocol <BsonDocument> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var updateRequest = (UpdateRequest)request;
return(new UpdateWireProtocol(
DatabaseName,
CollectionName,
WriteConcern,
updateRequest.Query,
updateRequest.Update,
updateRequest.IsMultiUpdate ?? false,
updateRequest.IsUpsert ?? false));
}
public static bool ShouldInvalidateServer(this Server server,
IConnectionHandle connection,
Exception exception,
ServerDescription description,
out TopologyVersion responseTopologyVersion)
{
var methodInfo = typeof(Server).GetMethod(nameof(ShouldInvalidateServer), BindingFlags.NonPublic | BindingFlags.Instance);
var parameters = new object[] { connection, exception, description, null };
int outParameterIndex = Array.IndexOf(parameters, null);
var shouldInvalidate = (bool)methodInfo.Invoke(server, parameters);
responseTopologyVersion = (TopologyVersion)parameters[outParameterIndex];
return(shouldInvalidate);
}
// methods
protected override IWireProtocol <WriteConcernResult> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var updateRequest = (UpdateRequest)request;
return(new UpdateWireProtocol(
CollectionNamespace,
MessageEncoderSettings,
WriteConcern,
updateRequest.Criteria,
updateRequest.Update,
ElementNameValidatorFactory.ForUpdateType(updateRequest.UpdateType),
updateRequest.IsMulti,
updateRequest.IsUpsert));
}
// methods
protected override IWireProtocol<WriteConcernResult> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var updateRequest = (UpdateRequest)request;
return new UpdateWireProtocol(
CollectionNamespace,
MessageEncoderSettings,
WriteConcern,
updateRequest.Criteria,
updateRequest.Update,
ElementNameValidatorFactory.ForUpdateType(updateRequest.UpdateType),
updateRequest.IsMulti,
updateRequest.IsUpsert);
}
// methods
protected override IWireProtocol<WriteConcernResult> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var updateRequest = (UpdateRequest)request;
var updateValidator = new UpdateOrReplacementElementNameValidator();
return new UpdateWireProtocol(
CollectionNamespace,
MessageEncoderSettings,
WriteConcern,
updateRequest.Criteria,
updateRequest.Update,
updateValidator,
updateRequest.IsMultiUpdate ?? false,
updateRequest.IsUpsert ?? false);
}
// methods
protected override IWireProtocol <WriteConcernResult> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var updateRequest = (UpdateRequest)request;
var updateValidator = new UpdateOrReplacementElementNameValidator();
return(new UpdateWireProtocol(
CollectionNamespace,
MessageEncoderSettings,
WriteConcern,
updateRequest.Criteria,
updateRequest.Update,
updateValidator,
updateRequest.IsMultiUpdate ?? false,
updateRequest.IsUpsert ?? false));
}
// methods
protected override IWireProtocol<WriteConcernResult> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var insertRequest = (InsertRequest)request;
var documentSource = new BatchableSource<BsonDocument>(new[] { insertRequest.Document });
return new InsertWireProtocol<BsonDocument>(
CollectionNamespace,
WriteConcern,
BsonDocumentSerializer.Instance,
MessageEncoderSettings,
documentSource,
connection.Description.MaxBatchCount,
connection.Description.MaxMessageSize,
continueOnError: false);
}
private Task <BulkWriteResult> ExecuteUpdatesAsync(IConnectionHandle connection, IEnumerable <UpdateRequest> requests, TimeSpan timeout, CancellationToken cancellationToken)
{
var operation = new BulkUpdateOperation(_databaseName, _collectionName, requests)
{
CheckElementNames = _checkElementNames,
MaxBatchCount = _maxBatchCount,
MaxBatchLength = _maxBatchLength,
IsOrdered = _isOrdered,
ReaderSettings = _readerSettings,
WriteConcern = _writeConcern,
WriterSettings = _writerSettings
};
return(operation.ExecuteAsync(connection, timeout, cancellationToken));
}
// methods
protected override IWireProtocol<BsonDocument> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var insertRequest = (InsertRequest)request;
var wrapper = new BsonDocumentWrapper(insertRequest.Document, insertRequest.Serializer);
var documentSource = new BatchableSource<BsonDocument>(new[] { wrapper });
return new InsertWireProtocol<BsonDocument>(
DatabaseName,
CollectionName,
WriteConcern,
BsonDocumentSerializer.Instance,
documentSource,
connection.Description.MaxBatchCount,
connection.Description.MaxMessageSize,
continueOnError: false);
}
// methods
protected override IWireProtocol <WriteConcernResult> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var insertRequest = (InsertRequest)request;
var documentSource = new BatchableSource <BsonDocument>(new[] { insertRequest.Document });
return(new InsertWireProtocol <BsonDocument>(
CollectionNamespace,
WriteConcern,
BsonDocumentSerializer.Instance,
MessageEncoderSettings,
documentSource,
connection.Description.MaxBatchCount,
connection.Description.MaxMessageSize,
continueOnError: false));
}
public Either <RfcErrorInfo, IConnectionHandle> OpenConnection(IDictionary <string, string> connectionParams)
{
var loggedParams = new Dictionary <string, string>(connectionParams);
// ReSharper disable StringLiteralTypo
if (loggedParams.ContainsKey("passwd"))
{
loggedParams["passwd"] = "XXXX";
}
// ReSharper restore StringLiteralTypo
Logger.IfSome(l => l.LogTrace("Opening connection", loggedParams));
IConnectionHandle handle = Api.OpenConnection(connectionParams, out var errorInfo);
return(ResultOrError(handle, errorInfo, true));
}
// methods
protected override IWireProtocol <BsonDocument> CreateProtocol(IConnectionHandle connection, WriteRequest request)
{
var insertRequest = (InsertRequest)request;
var wrapper = new BsonDocumentWrapper(insertRequest.Document, insertRequest.Serializer);
var documentSource = new BatchableSource <BsonDocument>(new[] { wrapper });
return(new InsertWireProtocol <BsonDocument>(
DatabaseName,
CollectionName,
WriteConcern,
BsonDocumentSerializer.Instance,
documentSource,
connection.Description.MaxBatchCount,
connection.Description.MaxMessageSize,
continueOnError: false));
}
// methods
public async Task <WriteConcernResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(connection, "connection");
var limit = _isMulti ? 0 : 1;
var requests = new[] { new DeleteRequest(_criteria)
{
Limit = limit
} };
var operation = new BulkDeleteOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
WriteConcern = _writeConcern
};
BulkWriteOperationResult bulkWriteResult;
BulkWriteOperationException bulkWriteException = null;
try
{
bulkWriteResult = await operation.ExecuteAsync(connection, timeout, cancellationToken);
}
catch (BulkWriteOperationException ex)
{
bulkWriteResult = ex.Result;
bulkWriteException = ex;
}
var converter = new BulkWriteOperationResultConverter();
if (bulkWriteException != null)
{
throw converter.ToWriteConcernException(bulkWriteException);
}
else
{
if (_writeConcern.IsAcknowledged)
{
return(converter.ToWriteConcernResult(bulkWriteResult));
}
else
{
return(null);
}
}
}
public static int ExecuteNonQuery(IConnectionHandle handle, string query, object[] parameterValues, IParameterHandle[] extraParameters)
{
ConnectionHandle connection;
DbTransaction transaction;
DbCommand command;
DbParameter parameter;
int numberOfRows;
connection = (ConnectionHandle)handle;
transaction = ((TransactionHandle)connection.TransactionHandle).Transaction;
command = connection.Factory.CreateCommand();
command.CommandText = query;
command.Connection = connection.Connection;
command.Transaction = transaction;
if (parameterValues != null)
{
for (int i = 0; i < parameterValues.Length; i++)
{
object paramValue = parameterValues[i];
//Datetime mapping
if (paramValue is DateTime && DateTime.MinValue.Equals((DateTime)paramValue)) paramValue = DBNull.Value;
//null mapping
if (paramValue == null) paramValue = DBNull.Value;
parameter = connection.Factory.CreateParameter();
parameter.ParameterName = "prm" + i;
parameter.Value = paramValue;
command.Parameters.Add(parameter);
}
}
if(extraParameters!=null)
foreach (ParameterHandle p in extraParameters)
{
if (p == null) continue;
command.Parameters.Add(p.Parameter);
}
numberOfRows = command.ExecuteNonQuery();
return numberOfRows;
}
public async Task <WriteConcernResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(connection, "connection");
if (connection.Description.BuildInfoResult.ServerVersion >= new SemanticVersion(2, 6, 0) && _writeConcern.IsAcknowledged)
{
var emulator = new DeleteOpcodeOperationEmulator(_collectionNamespace, _request, _messageEncoderSettings)
{
WriteConcern = _writeConcern
};
return(await emulator.ExecuteAsync(connection, timeout, cancellationToken).ConfigureAwait(false));
}
else
{
var protocol = CreateProtocol();
return(await protocol.ExecuteAsync(connection, timeout, cancellationToken).ConfigureAwait(false));
}
}
// methods
public async Task<WriteConcernResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.IsNotNull(connection, "connection");
var requests = new[] { _request };
var operation = new BulkUpdateOperation(_collectionNamespace, requests, _messageEncoderSettings)
{
IsOrdered = true,
WriteConcern = _writeConcern
};
BulkWriteOperationResult bulkWriteResult;
BulkWriteOperationException bulkWriteException = null;
try
{
bulkWriteResult = await operation.ExecuteAsync(connection, timeout, cancellationToken);
}
catch (BulkWriteOperationException ex)
{
bulkWriteResult = ex.Result;
bulkWriteException = ex;
}
var converter = new BulkWriteOperationResultConverter();
if (bulkWriteException != null)
{
throw converter.ToWriteConcernException(bulkWriteException);
}
else
{
if (_writeConcern.IsAcknowledged)
{
return converter.ToWriteConcernResult(bulkWriteResult);
}
else
{
return null;
}
}
}
protected virtual async Task<BulkWriteBatchResult> EmulateSingleRequestAsync(IConnectionHandle connection, WriteRequest request, int originalIndex, TimeSpan timeout, CancellationToken cancellationToken)
{
var protocol = CreateProtocol(connection, request);
WriteConcernResult writeConcernResult = null;
WriteConcernException writeConcernException = null;
try
{
var protocolResult = await protocol.ExecuteAsync(connection, timeout, cancellationToken);
if (protocolResult != null)
{
writeConcernResult = new WriteConcernResult(protocolResult);
}
}
catch (WriteException ex)
{
writeConcernResult = new WriteConcernResult(ex.Result);
writeConcernException = new WriteConcernException(ex.Message, writeConcernResult);
}
var indexMap = new IndexMap.RangeBased(0, originalIndex, 1);
return BulkWriteBatchResult.Create(
request,
writeConcernResult,
writeConcernException,
indexMap);
}
// methods protected abstract IWireProtocol<BsonDocument> CreateProtocol(IConnectionHandle connection, WriteRequest request);
public static object ExecuteScalar(IConnectionHandle handle, string query, params object[] parameterValues)
{
ConnectionHandle connection;
DbTransaction transaction;
DbCommand command;
object result;
connection = (ConnectionHandle)handle;
transaction = ((TransactionHandle)connection.TransactionHandle).Transaction;
command = connection.Factory.CreateCommand();
command.CommandText = query;
command.Connection = connection.Connection;
command.Transaction = transaction;
command.Parameters.AddRange(CreateParameters(connection, parameterValues));
result = command.ExecuteScalar();
return result;
}
public static DataTable MetaTableColumns(IConnectionHandle handle, string tablename)
{
ConnectionHandle connection;
connection = (ConnectionHandle)handle;
return connection.Connection.GetSchema("Columns", new string[] { null, null, tablename, null });
}
// methods protected abstract IWireProtocol<WriteConcernResult> CreateProtocol(IConnectionHandle connection, WriteRequest request);
// constructors
public ConnectionReadBinding(IServer server, IConnectionHandle connection, ReadPreference readPreference)
{
_server = Ensure.IsNotNull(server, "server");
_connection = Ensure.IsNotNull(connection, "connection");
_readPreference = Ensure.IsNotNull(readPreference, "readPreference");
}
public static DataTable ExecuteSql(IConnectionHandle handle, string query, params object[] parameterValues)
{
ConnectionHandle connection;
DbCommand command;
DbParameter parameter;
DbTransaction transaction = null;
DataTable table = null;
connection = (ConnectionHandle)handle;
//Transaction kullanmadan sql çalýþtýrmak gerekebiliyor, bildiðim tek örnek "create database..." ihtiyacý...
//Böyle bir ihtiyaç için direkt .DAL katmanýndaki metodlarý kullanmak gerekiyor.
if (connection.TransactionHandle != null)
transaction = ((TransactionHandle)connection.TransactionHandle).Transaction;
using (DbDataAdapter adapter = connection.Factory.CreateDataAdapter())
{
table = new DataTable();
command = connection.Factory.CreateCommand();
command.CommandText = query;
command.Connection = connection.Connection;
command.Transaction = transaction;
for (int i = 0; i < parameterValues.Length; i++)
{
parameter = connection.Factory.CreateParameter();
parameter.ParameterName = "prm" + i;
parameter.Value = parameterValues[i];
command.Parameters.Add(parameter);
}
adapter.SelectCommand = command;
adapter.Fill(table);
}
return table;
}
public static long ExecuteScalarL(IConnectionHandle handle, string query, params object[] parameterValues)
{
long result;
result = Convert.ToInt64(
ExecuteScalar(handle, query, parameterValues));
return result;
}
public static int ExecuteScalarI(IConnectionHandle handle, string query, params object[] parameterValues)
{
int result;
result = Convert.ToInt32(
ExecuteScalar(handle, query, parameterValues));
return result;
}
public static decimal ExecuteScalarD(IConnectionHandle handle, string query, params object[] parameterValues)
{
decimal result;
result = Convert.ToDecimal(
ExecuteScalar(handle, query, parameterValues));
return result;
}
public async Task<BulkWriteResult> ExecuteAsync(IConnectionHandle connection, TimeSpan timeout, CancellationToken cancellationToken)
{
var slidingTimeout = new SlidingTimeout(timeout);
var batchResults = new List<BulkWriteBatchResult>();
var remainingRequests = new List<WriteRequest>();
var hasWriteErrors = false;
var originalIndex = 0;
foreach (WriteRequest request in _requests)
{
if (hasWriteErrors && _isOrdered)
{
remainingRequests.Add(request);
continue;
}
var batchResult = await EmulateSingleRequestAsync(connection, request, originalIndex, slidingTimeout, cancellationToken);
batchResults.Add(batchResult);
hasWriteErrors |= batchResult.HasWriteErrors;
originalIndex++;
}
var combiner = new BulkWriteBatchResultCombiner(batchResults, !_writeConcern.Equals(WriteConcern.Unacknowledged));
return combiner.CreateResultOrThrowIfHasErrors(remainingRequests);
}
public static void Open(IConnectionHandle handle)
{
ConnectionHandle connection;
connection = (ConnectionHandle)handle;
connection.Open();
}
// constructors
public ConnectionConnectionSource(IServer server, IConnectionHandle connection)
{
_server = Ensure.IsNotNull(server, "server");
_connection = Ensure.IsNotNull(connection, "connection");
}
// constructors
public ConnectionReadWriteBinding(IServer server, IConnectionHandle connection)
{
_server = Ensure.IsNotNull(server, "server");
_connection = Ensure.IsNotNull(connection, "connection");
}
