/// <summary>
/// Converts an object to a BSON document byte array.
/// </summary>
/// <typeparam name="T">The nominal type of the object.</typeparam>
/// <param name="obj">The object.</param>
/// <param name="settings">The BsonBinaryWriter settings.</param>
/// <returns>A byte array.</returns>
public static byte[] ToBson <T>(
this T obj,
BsonBinaryWriterSettings settings
)
{
return(ToBson(obj, null, settings));
}
public void Serialize_should_throw_when_effectiveGuidRepresentation_is_Unspecified(
GuidRepresentationMode defaultGuidRepresentationMode,
GuidRepresentation defaultGuidRepresentation,
GuidRepresentation serializerGuidRepresentation,
GuidRepresentation?writerGuidRepresentation)
{
GuidMode.Set(defaultGuidRepresentationMode, defaultGuidRepresentation);
var subject = new GuidSerializer(serializerGuidRepresentation);
var memoryStream = new MemoryStream();
var writerSettings = new BsonBinaryWriterSettings();
if (defaultGuidRepresentationMode == GuidRepresentationMode.V2 && writerGuidRepresentation.HasValue)
{
#pragma warning disable 618
writerSettings.GuidRepresentation = writerGuidRepresentation.Value;
#pragma warning restore 618
}
var writer = new BsonBinaryWriter(memoryStream, writerSettings);
var context = BsonSerializationContext.CreateRoot(writer);
var args = new BsonSerializationArgs();
var value = new Guid("01020304-0506-0708-090a-0b0c0d0e0f10");
writer.WriteStartDocument();
writer.WriteName("x");
var exception = Record.Exception(() => subject.Serialize(context, args, value));
exception.Should().BeOfType <BsonSerializationException>();
}
public void DeserializeBatch_should_return_expected_result_when_GuidRepresentation_is_Standard()
{
var document = BsonDocument.Parse("{ batch : [ { a : HexData(4, \"0102030405060708090a0b0c0d0e0f10\") } ] }");
#pragma warning disable 618
var writerSettings = new BsonBinaryWriterSettings();
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
writerSettings.GuidRepresentation = GuidRepresentation.Standard;
}
#pragma warning restore 618
var bson = document.ToBson(writerSettings: writerSettings);
var rawDocument = new RawBsonDocument(bson);
var batch = (RawBsonArray)rawDocument["batch"];
var documentSerializer = BsonDocumentSerializer.Instance;
var messageEncoderSettings = new MessageEncoderSettings {
{ "GuidRepresentation", GuidRepresentation.Standard }
};
var result = CursorBatchDeserializationHelper.DeserializeBatch <BsonDocument>(batch, documentSerializer, messageEncoderSettings);
result.Count.Should().Be(1);
result[0].Should().BeOfType <BsonDocument>();
result[0].Should().Be("{ a : HexData(4, \"0102030405060708090a0b0c0d0e0f10\") }");
}
// constructors
internal MongoDeleteMessage(BsonBinaryWriterSettings writerSettings, string collectionFullName, RemoveFlags flags, IMongoQuery query)
: base(MessageOpcode.Delete, null, writerSettings)
{
this.collectionFullName = collectionFullName;
this.flags = flags;
this.query = query;
}
/// <summary>
/// Converts an object to a BSON document byte array.
/// </summary>
/// <typeparam name="TNominalType">The nominal type of the object.</typeparam>
/// <param name="obj">The object.</param>
/// <param name="options">The serialization options.</param>
/// <param name="settings">The BsonBinaryWriter settings.</param>
/// <returns>A byte array.</returns>
public static byte[] ToBson <TNominalType>(
this TNominalType obj,
IBsonSerializationOptions options,
BsonBinaryWriterSettings settings)
{
return(ToBson(obj, typeof(TNominalType), options, settings));
}
// constructors
public BulkMixedWriteOperation(
Action <InsertRequest> assignId,
bool checkElementNames,
string collectionName,
string databaseName,
int maxBatchCount,
int maxBatchLength,
bool isOrdered,
BsonBinaryReaderSettings readerSettings,
IEnumerable <WriteRequest> requests,
WriteConcern writeConcern,
BsonBinaryWriterSettings writerSettings)
{
_assignId = assignId;
_checkElementNames = checkElementNames;
_collectionName = collectionName;
_databaseName = databaseName;
_maxBatchCount = maxBatchCount;
_maxBatchLength = maxBatchLength;
_isOrdered = isOrdered;
_readerSettings = readerSettings;
_requests = requests;
_writeConcern = writeConcern;
_writerSettings = writerSettings;
}
// constructors
public BulkInsertOperationArgs(
Action <InsertRequest> assignId,
bool checkElementNames,
string collectionName,
string databaseName,
int maxBatchCount,
int maxBatchLength,
int maxDocumentSize,
int maxWireDocumentSize,
bool isOrdered,
BsonBinaryReaderSettings readerSettings,
IEnumerable <InsertRequest> requests,
WriteConcern writeConcern,
BsonBinaryWriterSettings writerSettings)
: base(
collectionName,
databaseName,
maxBatchCount,
maxBatchLength,
maxDocumentSize,
maxWireDocumentSize,
isOrdered,
readerSettings,
requests.Cast <WriteRequest>(),
writeConcern,
writerSettings)
{
_assignId = assignId;
_checkElementNames = checkElementNames;
}
/// <summary>
/// Serializes an object to a BSON byte array.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="nominalType">The nominal type of the object..</param>
/// <param name="writerSettings">The writer settings.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="configurator">The serialization context configurator.</param>
/// <param name="args">The serialization args.</param>
/// <returns>A BSON byte array.</returns>
/// <exception cref="System.ArgumentNullException">nominalType</exception>
/// <exception cref="System.ArgumentException">serializer</exception>
public static byte[] ToBson(
this object obj,
Type nominalType,
BsonBinaryWriterSettings writerSettings = null,
IBsonSerializer serializer = null,
Action <BsonSerializationContext.Builder> configurator = null,
BsonSerializationArgs args = default(BsonSerializationArgs))
{
if (nominalType == null)
{
throw new ArgumentNullException("nominalType");
}
if (serializer == null)
{
serializer = BsonSerializer.LookupSerializer(nominalType);
}
if (serializer.ValueType != nominalType)
{
var message = string.Format("Serializer type {0} value type does not match document types {1}.", serializer.GetType().FullName, nominalType.FullName);
throw new ArgumentException(message, "serializer");
}
using (var memoryStream = new MemoryStream())
{
using (var bsonWriter = new BsonBinaryWriter(memoryStream, writerSettings ?? BsonBinaryWriterSettings.Defaults))
{
var context = BsonSerializationContext.CreateRoot(bsonWriter, configurator);
args.NominalType = nominalType;
serializer.Serialize(context, args, obj);
}
return(memoryStream.ToArray());
}
}
// constructors
public BulkDeleteOperationArgs(
string collectionName,
string databaseName,
int maxBatchCount,
int maxBatchLength,
int maxDocumentSize,
int maxWireDocumentSize,
bool isOrdered,
BsonBinaryReaderSettings readerSettings,
IEnumerable <DeleteRequest> requests,
WriteConcern writeConcern,
BsonBinaryWriterSettings writerSettings)
: base(
collectionName,
databaseName,
maxBatchCount,
maxBatchLength,
maxDocumentSize,
maxWireDocumentSize,
isOrdered,
readerSettings,
requests.Cast <WriteRequest>(),
writeConcern,
writerSettings)
{
}
// constructors
internal MongoInsertMessage(BsonBinaryWriterSettings writerSettings, string collectionFullName, bool checkElementNames, InsertFlags flags)
: base(MessageOpcode.Insert, null, writerSettings)
{
this.collectionFullName = collectionFullName;
this.checkElementNames = checkElementNames;
this.flags = flags;
}
// constructors
protected BulkWriteOperationArgs(
string collectionName,
string databaseName,
int maxBatchCount,
int maxBatchLength,
int maxDocumentSize,
int maxWireDocumentSize,
bool isOrdered,
BsonBinaryReaderSettings readerSettings,
IEnumerable <WriteRequest> requests,
WriteConcern writeConcern,
BsonBinaryWriterSettings writerSettings)
{
_collectionName = collectionName;
_databaseName = databaseName;
_maxBatchCount = maxBatchCount;
_maxBatchLength = maxBatchLength;
_maxDocumentSize = maxDocumentSize;
_maxWireDocumentSize = maxWireDocumentSize;
_isOrdered = isOrdered;
_readerSettings = readerSettings;
_requests = requests;
_writeConcern = writeConcern;
_writerSettings = writerSettings;
}
public QueryOperation(
string databaseName,
string collectionName,
BsonBinaryReaderSettings readerSettings,
BsonBinaryWriterSettings writerSettings,
int batchSize,
IMongoFields fields,
QueryFlags flags,
int limit,
BsonDocument options,
IMongoQuery query,
ReadPreference readPreference,
IBsonSerializationOptions serializationOptions,
IBsonSerializer serializer,
int skip)
: base(databaseName, collectionName, readerSettings, writerSettings)
{
_batchSize = batchSize;
_fields = fields;
_flags = flags;
_limit = limit;
_options = options;
_query = query;
_readPreference = readPreference;
_serializationOptions = serializationOptions;
_serializer = serializer;
_skip = skip;
// since we're going to block anyway when a tailable cursor is temporarily out of data
// we might as well do it as efficiently as possible
if ((_flags & QueryFlags.TailableCursor) != 0)
{
_flags |= QueryFlags.AwaitData;
}
}
/// <summary>
/// Converts an object to a BSON document byte array.
/// </summary>
/// <typeparam name="TNominalType">The nominal type of the object.</typeparam>
/// <param name="obj">The object.</param>
/// <param name="settings">The BsonBinaryWriter settings.</param>
/// <returns>A byte array.</returns>
public static byte[] ToBson <TNominalType>(
this TNominalType obj,
BsonBinaryWriterSettings settings
)
{
return(ToBson(obj, typeof(TNominalType), settings));
}
protected ReadOperationBase(
string databaseName,
string collectionName,
BsonBinaryReaderSettings readerSettings,
BsonBinaryWriterSettings writerSettings)
: base(databaseName, collectionName, readerSettings, writerSettings)
{
}
internal MongoInsertMessage(
BsonBinaryWriterSettings writerSettings,
string collectionFullName
)
: base(MessageOpcode.Insert, null, writerSettings)
{
this.collectionFullName = collectionFullName;
}
protected BsonWriter CreateBsonWriter()
{
var settings = new BsonBinaryWriterSettings {
MaxDocumentSize = server.MaxDocumentSize
};
return(BsonWriter.Create(buffer, settings));
}
/// <summary>
/// Converts an object to a BSON document byte array.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="settings">The BsonBinaryWriter settings.</param>
/// <returns>A byte array.</returns>
public static byte[] ToBson(
this object obj,
Type nominalType,
BsonBinaryWriterSettings settings
)
{
return(ToBson(obj, nominalType, null, settings));
}
private int _messageStartPosition = -1; // start position in buffer for backpatching messageLength
// constructors
protected MongoRequestMessage(
MessageOpcode opcode,
BsonBinaryWriterSettings writerSettings)
: base(opcode)
{
_writerSettings = writerSettings;
RequestId = Interlocked.Increment(ref __lastRequestId);
}
protected BsonWriter CreateBsonWriter()
{
var settings = new BsonBinaryWriterSettings {
MaxDocumentSize = connection.ServerInstance.MaxDocumentSize
};
return(BsonWriter.Create(buffer, settings));
}
protected byte[] ToBson(string json, GuidRepresentation guidRepresentation = GuidRepresentation.Unspecified)
{
var writerSettings = new BsonBinaryWriterSettings {
GuidRepresentation = guidRepresentation
};
return(UnquoteExtendedJson(BsonDocument.Parse(json)).ToBson(writerSettings: writerSettings));
}
/// <summary>
/// Serializes an object to a BSON byte array.
/// </summary>
/// <typeparam name="TNominalType">The nominal type of the object.</typeparam>
/// <param name="obj">The object.</param>
/// <param name="serializer">The serializer.</param>
/// <param name="writerSettings">The writer settings.</param>
/// <param name="configurator">The serialization context configurator.</param>
/// <returns>A BSON byte array.</returns>
public static byte[] ToBson <TNominalType>(
this TNominalType obj,
IBsonSerializer <TNominalType> serializer = null,
BsonBinaryWriterSettings writerSettings = null,
Action <BsonSerializationContext.Builder> configurator = null
)
{
return(ToBson(obj, typeof(TNominalType), writerSettings, serializer, configurator));
}
// constructors
internal MongoUpdateMessage(BsonBinaryWriterSettings writerSettings, string collectionFullName, bool checkUpdateDocument, UpdateFlags flags, IMongoQuery query, IMongoUpdate update)
: base(MessageOpcode.Update, null, writerSettings)
{
this.collectionFullName = collectionFullName;
this.checkUpdateDocument = checkUpdateDocument;
this.flags = flags;
this.query = query;
this.update = update;
}
internal MongoQueryMessage(BsonBuffer buffer, BsonBinaryWriterSettings writerSettings, string collectionFullName, QueryFlags flags, int numberToSkip, int numberToReturn, IMongoQuery query, IMongoFields fields)
: base(MessageOpcode.Query, buffer, writerSettings)
{
this.collectionFullName = collectionFullName;
this.flags = flags;
this.numberToSkip = numberToSkip;
this.numberToReturn = numberToReturn;
this.query = query;
this.fields = fields;
}
public static byte[] ToBytes(BsonDocument doc)
{
BsonBinaryWriterSettings settings = new BsonBinaryWriterSettings()
{
// C# driver "magically" changes UUIDs underneath by default so tell it not to
GuidRepresentation = GuidRepresentation.Standard
};
return(doc.ToBson(null, settings));
}
protected WriteOpcodeOperationBase(
string databaseName,
string collectionName,
BsonBinaryReaderSettings readerSettings,
BsonBinaryWriterSettings writerSettings,
WriteConcern writeConcern)
: base(databaseName, collectionName, readerSettings, writerSettings)
{
_writeConcern = writeConcern;
}
// protected methods
protected void FeedResult(CryptContext context, BsonDocument document)
{
var writerSettings = new BsonBinaryWriterSettings {
GuidRepresentation = GuidRepresentation.Unspecified
};
var documentBytes = document.ToBson(writerSettings: writerSettings);
context.Feed(documentBytes);
context.MarkDone();
}
protected WriteConcernResult SendMessageWithWriteConcern(
MongoConnection connection,
BsonBuffer buffer,
int requestId,
BsonBinaryReaderSettings readerSettings,
BsonBinaryWriterSettings writerSettings,
WriteConcern writeConcern)
{
CommandDocument getLastErrorCommand = null;
if (writeConcern.Enabled)
{
var fsync = (writeConcern.FSync == null) ? null : (BsonValue)writeConcern.FSync;
var journal = (writeConcern.Journal == null) ? null : (BsonValue)writeConcern.Journal;
var w = (writeConcern.W == null) ? null : writeConcern.W.ToGetLastErrorWValue();
var wTimeout = (writeConcern.WTimeout == null) ? null : (BsonValue)(int)writeConcern.WTimeout.Value.TotalMilliseconds;
getLastErrorCommand = new CommandDocument
{
{ "getlasterror", 1 }, // use all lowercase for backward compatibility
{ "fsync", fsync, fsync != null },
{ "j", journal, journal != null },
{ "w", w, w != null },
{ "wtimeout", wTimeout, wTimeout != null }
};
// piggy back on network transmission for message
var getLastErrorMessage = new MongoQueryMessage(writerSettings, DatabaseName + ".$cmd", QueryFlags.None, 0, 1, getLastErrorCommand, null);
getLastErrorMessage.WriteToBuffer(buffer);
}
connection.SendMessage(buffer, requestId);
WriteConcernResult writeConcernResult = null;
if (writeConcern.Enabled)
{
var writeConcernResultSerializer = BsonSerializer.LookupSerializer(typeof(WriteConcernResult));
var replyMessage = connection.ReceiveMessage <WriteConcernResult>(readerSettings, writeConcernResultSerializer, null);
if (replyMessage.NumberReturned == 0)
{
throw new MongoCommandException("Command 'getLastError' failed. No response returned");
}
writeConcernResult = replyMessage.Documents[0];
writeConcernResult.Command = getLastErrorCommand;
var mappedException = ExceptionMapper.Map(writeConcernResult);
if (mappedException != null)
{
throw mappedException;
}
}
return(writeConcernResult);
}
public SQLiteCollectionManager(SQLiteConnection connection, ICollectionImageHandler imageHandler)
{
this.connection = connection;
this.ImageHandler = imageHandler;
this.bsonWriterSettings = new BsonBinaryWriterSettings()
{
MaxDocumentSize = 24 * 1024 * 1024
};
this.bsonReaderSettings = new BsonBinaryReaderSettings()
{
MaxDocumentSize = this.bsonWriterSettings.MaxDocumentSize
};
this.Operations = new CollectionManagerOperations(this);
this.loadSettings = this.connection.CreateCommand();
this.loadSettings.CommandText = "SELECT * FROM settings;";
this.saveSettings = this.connection.CreateCommand();
this.saveSettings.CommandText = "DELETE FROM settings; INSERT INTO settings (bson) VALUES (@bson);";
this.saveSettings.Parameters.Add("bson", DbType.Binary);
this.loadTrackCaches = this.connection.CreateCommand();
this.loadTrackCaches.CommandText = "SELECT * FROM track_info_caches;";
this.saveTrackCache = this.connection.CreateCommand();
this.saveTrackCache.CommandText = "INSERT INTO track_info_caches (bson) VALUES (@bson);";
this.saveTrackCache.Parameters.Add("bson", DbType.Binary);
this.loadReleases = this.connection.CreateCommand();
this.loadReleases.CommandText = "SELECT * FROM releases;";
this.countReleases = this.connection.CreateCommand();
this.countReleases.CommandText = "SELECT COUNT(*) FROM releases;";
this.loadReleaseById = this.connection.CreateCommand();
this.loadReleaseById.CommandText = "SELECT * FROM releases WHERE id = @id;";
this.loadReleaseById.Parameters.Add("id", DbType.Int64);
this.saveRelease = this.connection.CreateCommand();
this.saveRelease.CommandText = "INSERT INTO releases (bson) VALUES (@bson);";
this.saveRelease.Parameters.Add("bson", DbType.Binary);
this.updateRelease = this.connection.CreateCommand();
this.updateRelease.CommandText = "UPDATE releases SET bson = @bson WHERE id = @id;";
this.updateRelease.Parameters.Add("id", DbType.Int64);
this.updateRelease.Parameters.Add("bson", DbType.Binary);
this.deleteRelease = this.connection.CreateCommand();
this.deleteRelease.CommandText = "DELETE FROM releases WHERE id = @id;";
this.deleteRelease.Parameters.Add("id", DbType.Int64);
this.ReloadSettings();
}
// constructors
internal MongoQueryMessage(
BsonBinaryWriterSettings writerSettings,
string collectionFullName,
QueryFlags flags,
int numberToSkip,
int numberToReturn,
IMongoQuery query,
IMongoFields fields)
: this(null, writerSettings, collectionFullName, flags, numberToSkip, numberToReturn, query, fields)
{
}
protected DatabaseOperation(
string databaseName,
string collectionName,
BsonBinaryReaderSettings readerSettings,
BsonBinaryWriterSettings writerSettings)
{
_databaseName = databaseName;
_collectionName = collectionName;
_readerSettings = (BsonBinaryReaderSettings)readerSettings.FrozenCopy();
_writerSettings = (BsonBinaryWriterSettings)writerSettings.FrozenCopy();
}
