// 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 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); }
// 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"); }