/// <summary> /// Gets the index of a value in the array. /// </summary> /// <param name="value">The value to search for.</param> /// <param name="index">The zero based index at which to start the search.</param> /// <param name="count">The number of elements to search.</param> /// <returns>The zero based index of the value (or -1 if not found).</returns> public override int IndexOf(BsonValue value, int index, int count) { ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsByteBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot(bsonReader); bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (i >= index) { if (count == 0) { return(-1); } if (DeserializeBsonValue(context).Equals(value)) { return(i); } count--; } else { bsonReader.SkipValue(); } i++; } bsonReader.ReadEndDocument(); return(-1); } }
/// <summary> /// Tests whether the array contains a value. /// </summary> /// <param name="value">The value to test for.</param> /// <returns>True if the array contains the value.</returns> public override bool Contains(BsonValue value) { ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsByteBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { var context = BsonDeserializationContext.CreateRoot <RawBsonArray>(bsonReader); bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (DeserializeBsonValue(context).Equals(value)) { return(true); } } bsonReader.ReadEndDocument(); return(false); } }
public void TestBsonAwesome() { string byteString = @"1\x00\x00\x00\x04BSON\x00&\x00\x00\x00\x020\x00\x08\x00\x00\x00awesome\x00\x011\x00333333\x14@\x102\x00\xc2\x07\x00\x00\x00\x00"; byte[] bytes = DecodeByteString(byteString); var stream = new MemoryStream(bytes); using (var bsonReader = new BsonBinaryReader(stream)) { bsonReader.ReadStartDocument(); Assert.Equal(BsonType.Array, bsonReader.ReadBsonType()); Assert.Equal("BSON", bsonReader.ReadName()); bsonReader.ReadStartArray(); Assert.Equal(BsonType.String, bsonReader.ReadBsonType()); Assert.Equal("awesome", bsonReader.ReadString()); Assert.Equal(BsonType.Double, bsonReader.ReadBsonType()); Assert.Equal(5.05, bsonReader.ReadDouble()); Assert.Equal(BsonType.Int32, bsonReader.ReadBsonType()); Assert.Equal(1986, bsonReader.ReadInt32()); bsonReader.ReadEndArray(); bsonReader.ReadEndDocument(); } }
public static object Deserialize( this byte[] serializedBytes, Type type) { if (serializedBytes == null) { throw new ArgumentNullException(nameof(serializedBytes)); } using (var memoryStream = new MemoryStream(serializedBytes)) { using (var reader = new BsonBinaryReader(memoryStream)) { var result = BsonSerializer.Deserialize(reader, type); reader.Close(); memoryStream.Close(); return(result); } } }
/// <summary> /// Tries to get an element of this document. /// </summary> /// <param name="name">The name of the element.</param> /// <param name="element">The element.</param> /// <returns> /// True if an element with that name was found. /// </returns> public override bool TryGetElement(string name, out BsonElement element) { ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), true), true, _readerSettings)) { bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { if (bsonReader.ReadName() == name) { var value = DeserializeBsonValue(bsonReader); element = new BsonElement(name, value); return(true); } bsonReader.SkipValue(); } bsonReader.ReadEndDocument(); element = null; return(false); } }
// public indexers /// <summary> /// Gets or sets a value by position. /// </summary> /// <param name="index">The position.</param> /// <returns>The value.</returns> public override BsonValue this[int index] { get { if (index < 0) { throw new ArgumentOutOfRangeException("index"); } ThrowIfDisposed(); using (var stream = new ByteBufferStream(_slice, ownsBuffer: false)) using (var bsonReader = new BsonBinaryReader(stream, _readerSettings)) { bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (i == index) { var context = BsonDeserializationContext.CreateRoot(bsonReader); return(DeserializeBsonValue(context)); } bsonReader.SkipValue(); i++; } bsonReader.ReadEndDocument(); throw new ArgumentOutOfRangeException("index"); } } set { throw new NotSupportedException("RawBsonArray instances are immutable."); } }
private void Open(String path) { // TODO - test for file/directory if (!File.Exists(path)) { throw new FTDCException($"Cannot load ${path}"); } using var sourceStream = new FileStream(path, FileMode.Open); using var reader = new BsonBinaryReader(sourceStream); while (!reader.IsAtEndOfFile()) { var result = BsonSerializer.Deserialize <FTDCFileContents>(reader); // FIXME - we should only decompress the data we actually want to use, but this will // have to wait until we have timeseries parsing in place result.DecompressData(); Contents.Add(result); } MetricsStart = Contents.Min(d => d._id); MetricsEnd = Contents.Max(d => d._id); }
private BsonDocument JObjectToBson(JObject _JsonObject) { // https://stackoverflow.com/a/62104268 //Write JObject to MemoryStream using var stream = new MemoryStream(); using (var writer = new BsonDataWriter(stream) { CloseOutput = false }) { _JsonObject.WriteTo(writer); } stream.Position = 0; //for reading the steam immediately //Read the object from MemoryStream BsonDocument bsonData; using (var reader = new BsonBinaryReader(stream)) { var context = BsonDeserializationContext.CreateRoot(reader); bsonData = BsonDocumentSerializer.Instance.Deserialize(context); } return(bsonData); }
public void Test20KDocument() { // manufacture an approximately 20K document using 200 strings each 100 characters long // it's enough to cause the document to straddle a chunk boundary var document = new BsonDocument(); var value = new string('x', 100); for (int i = 0; i < 200; i++) { var name = i.ToString(); document.Add(name, value); } // round trip tests var bson = document.ToBson(); var rehydrated = BsonSerializer.Deserialize <BsonDocument>(bson); Assert.IsTrue(bson.SequenceEqual(rehydrated.ToBson())); // test failure mode when 20 bytes are truncated from the buffer using (var byteBuffer = new MultiChunkBuffer(BsonChunkPool.Default)) using (var byteBufferStream = new ByteBufferStream(byteBuffer, ownsBuffer: true)) { using (var memoryStream = new MemoryStream(bson)) { memoryStream.CopyTo(byteBufferStream); } byteBufferStream.SetLength(byteBufferStream.Length - 20); byteBufferStream.Position = 0; using (var bsonReader = new BsonBinaryReader(byteBufferStream)) { Assert.Throws <EndOfStreamException>(() => BsonSerializer.Deserialize <BsonDocument>(bsonReader)); } } }
/// <summary> /// Gets the index of a value in the array. /// </summary> /// <param name="value">The value to search for.</param> /// <param name="index">The zero based index at which to start the search.</param> /// <param name="count">The number of elements to search.</param> /// <returns>The zero based index of the value (or -1 if not found).</returns> public override int IndexOf(BsonValue value, int index, int count) { ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), false), true, _readerSettings)) { bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (i >= index) { if (count == 0) { return(-1); } if (DeserializeBsonValue(bsonReader).Equals(value)) { return(i); } count--; } else { bsonReader.SkipValue(); } i++; } bsonReader.ReadEndDocument(); return(-1); } }
private long FindWPosition() { var type0SectionPosition = FindType0SectionPosition(); _stream.Position = type0SectionPosition + 1; using (var reader = new BsonBinaryReader(_stream)) { reader.ReadStartDocument(); while (reader.ReadBsonType() != 0) { if (reader.ReadName() == "writeConcern") { reader.ReadStartDocument(); while (reader.ReadBsonType() != 0) { if (reader.ReadName() == "w") { if (reader.CurrentBsonType == BsonType.Int32) { return(_stream.Position); } goto notFound; } reader.SkipValue(); } goto notFound; } reader.SkipValue(); } } notFound: throw new InvalidOperationException("{ w : <Int32> } not found."); }
private Type1CommandMessageSection <RawBsonDocument> ReadType1Section(BsonBinaryReader reader) { var stream = reader.BsonStream; var payloadStartPosition = stream.Position; var payloadLength = stream.ReadInt32(); EnsureType1PayloadLengthIsValid(payloadLength); var payloadEndPosition = payloadStartPosition + payloadLength; var identifier = stream.ReadCString(Utf8Encodings.Strict); var serializer = RawBsonDocumentSerializer.Instance; var context = BsonDeserializationContext.CreateRoot(reader); var documents = new List <RawBsonDocument>(); while (stream.Position < payloadEndPosition) { var document = serializer.Deserialize(context); documents.Add(document); } EnsurePayloadEndedAtEndPosition(stream, payloadEndPosition); var batch = new BatchableSource <RawBsonDocument>(documents, canBeSplit: false); return(new Type1CommandMessageSection <RawBsonDocument>(identifier, batch, serializer)); }
/// <summary> /// Tests whether the document contains an element with the specified name. /// </summary> /// <param name="name">The name of the element to look for.</param> /// <returns> /// True if the document contains an element with the specified name. /// </returns> public override bool Contains(string name) { if (name == null) { throw new ArgumentNullException("name"); } ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), true), true, _readerSettings)) { bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { if (bsonReader.ReadName() == name) { return(true); } bsonReader.SkipValue(); } bsonReader.ReadEndDocument(); return(false); } }
// constructors public BinaryMessageEncoderFactory(BsonBinaryReader binaryReader) : this(Ensure.IsNotNull(binaryReader, "binaryReader"), null) { }
/***************************************************/ /**** Test Functions ****/ /***************************************************/ public static void TestBson() { List <BHoMObject> nodes = new List <BHoMObject> { new Node { Point = new Point(1, 2, 3), Name = "A" }, new Node { Point = new Point(4, 5, 6), Name = "B" }, new Node { Point = new Point(7, 8, 9), Name = "C" } }; List <object> items = new List <object> { new A(-6, -7) { a = 1, publicField = -4 }, new B { a = 2, b = 45 }, new C { a = 3, c = 56 }, new D { a = 4, b = 67, d = 123 }, new E { a = 5, c = 78, e = 456 }, new Node { Point = new Point(1, 2, 3), Name = "A" }, nodes, new Dictionary <string, A> { { "A", new A { a = 1 } }, { "C", new C { a = 3, c = 56 } }, { "E", new E { a = 5, c = 78, e = 456 } } } }; List <BsonDocument> docs = items.Select(x => x.ToBsonDocument()).ToList(); List <object> items2 = docs.Select(x => BsonSerializer.Deserialize(x, typeof(object))).ToList(); foreach (BsonDocument doc in docs) { Console.WriteLine(doc.ToJson()); Console.WriteLine(); } string outputFileRoot = @"C:\Users\adecler\Documents\"; // initialize to the file to write to. File.WriteAllLines(@"C:\Users\adecler\Documents\json_Save.txt", docs.Select(x => x.ToJson())); FileStream mongoStream = new FileStream(outputFileRoot + "bsonSave_Mongo.txt", FileMode.Create); var writer = new BsonBinaryWriter(mongoStream); BsonSerializer.Serialize(writer, typeof(object), docs); mongoStream.Flush(); mongoStream.Close(); FileStream csharpStream = new FileStream(outputFileRoot + "bsonSave_CSharp.txt", FileMode.Create); BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(csharpStream, docs); csharpStream.Close(); FileStream mongoReadStream = File.OpenRead(outputFileRoot + "bsonSave_Mongo.txt"); var reader = new BsonBinaryReader(mongoReadStream); List <BsonDocument> readBson = BsonSerializer.Deserialize(reader, typeof(object)) as List <BsonDocument>; List <object> items3 = readBson.Select(x => BsonSerializer.Deserialize(x, typeof(object))).ToList(); // Directly writing and reading objects to the stream using Bson serializer seems to have a problem when reading back //FileStream objectStream = new FileStream(outputFileRoot + "objectSave_Mongo.txt", FileMode.Create); //var objectWriter = new BsonBinaryWriter(objectStream); //BsonSerializer.Serialize(objectWriter, typeof(List<object>), items); //objectStream.Flush(); //objectStream.Close(); //FileStream objectReadStream = File.OpenRead(outputFileRoot + "objectSave_Mongo.txt"); //var objectReader = new BsonBinaryReader(objectReadStream); //var readObject = BsonSerializer.Deserialize(reader, typeof(object)); Console.WriteLine("Done!"); }
/// <summary> /// Writes a raw BSON document. /// </summary> /// <param name="slice">The byte buffer containing the raw BSON document.</param> public virtual void WriteRawBsonDocument(IByteBuffer slice) { // overridden in BsonBinaryWriter using (var bsonReader = new BsonBinaryReader(new BsonBuffer(slice, false), true, BsonBinaryReaderSettings.Defaults)) { var document = BsonSerializer.Deserialize<BsonDocument>(bsonReader); BsonDocumentSerializer.Instance.Serialize(this, typeof(BsonDocument), document, null); } }
/// <summary> /// Tries to get the value of an element of this document. /// </summary> /// <param name="name">The name of the element.</param> /// <param name="value">The value of the element.</param> /// <returns> /// True if an element with that name was found. /// </returns> public override bool TryGetValue(string name, out BsonValue value) { ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), true), true, _readerSettings)) { bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { if (bsonReader.ReadName() == name) { value = DeserializeBsonValue(bsonReader); return true; } bsonReader.SkipValue(); } bsonReader.ReadEndDocument(); value = null; return false; } }
private TCommandResult ProcessResponse(ConnectionId connectionId, CommandMessage responseMessage) { using (new CommandMessageDisposer(responseMessage)) { var rawDocument = responseMessage.Sections.OfType <Type0CommandMessageSection <RawBsonDocument> >().Single().Document; var binaryReaderSettings = new BsonBinaryReaderSettings(); if (_messageEncoderSettings != null) { binaryReaderSettings.Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict); binaryReaderSettings.GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy); } ; BsonValue clusterTime; if (rawDocument.TryGetValue("$clusterTime", out clusterTime)) { // note: we are assuming that _session is an instance of ClusterClockAdvancingClusterTime // and that calling _session.AdvanceClusterTime will have the side effect of advancing the cluster's ClusterTime also var materializedClusterTime = ((RawBsonDocument)clusterTime).Materialize(binaryReaderSettings); _session.AdvanceClusterTime(materializedClusterTime); } BsonValue operationTime; if (rawDocument.TryGetValue("operationTime", out operationTime)) { _session.AdvanceOperationTime(operationTime.AsBsonTimestamp); } if (!rawDocument.GetValue("ok", false).ToBoolean()) { var materializedDocument = rawDocument.Materialize(binaryReaderSettings); var commandName = _command.GetElement(0).Name; if (commandName == "$query") { commandName = _command["$query"].AsBsonDocument.GetElement(0).Name; } var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, materializedDocument, "errmsg"); if (notPrimaryOrNodeIsRecoveringException != null) { throw notPrimaryOrNodeIsRecoveringException; } var mappedException = ExceptionMapper.Map(connectionId, materializedDocument); if (mappedException != null) { throw mappedException; } string message; BsonValue errmsgBsonValue; if (materializedDocument.TryGetValue("errmsg", out errmsgBsonValue) && errmsgBsonValue.IsString) { var errmsg = errmsgBsonValue.ToString(); message = string.Format("Command {0} failed: {1}.", commandName, errmsg); } else { message = string.Format("Command {0} failed.", commandName); } throw new MongoCommandException(connectionId, message, _command, materializedDocument); } using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false)) { using (var reader = new BsonBinaryReader(stream, binaryReaderSettings)) { var context = BsonDeserializationContext.CreateRoot(reader); return(_resultSerializer.Deserialize(context)); } } } }
/// <summary> /// Writes a raw BSON array. /// </summary> /// <param name="slice">The byte buffer containing the raw BSON array.</param> public virtual void WriteRawBsonArray(IByteBuffer slice) { // overridden in BsonBinaryWriter using (var bsonBuffer = new BsonBuffer()) { BsonArray array; // wrap the array in a fake document so we can deserialize it var arrayLength = slice.Length; var documentLength = arrayLength + 8; bsonBuffer.WriteInt32(documentLength); bsonBuffer.WriteByte((byte)BsonType.Array); bsonBuffer.WriteByte((byte)'x'); bsonBuffer.WriteByte((byte)0); bsonBuffer.ByteBuffer.WriteBytes(slice); bsonBuffer.WriteByte((byte)0); bsonBuffer.Position = 0; using (var bsonReader = new BsonBinaryReader(bsonBuffer, true, BsonBinaryReaderSettings.Defaults)) { bsonReader.ReadStartDocument(); bsonReader.ReadName("x"); array = (BsonArray)BsonArraySerializer.Instance.Deserialize(bsonReader, typeof(BsonArray), null); bsonReader.ReadEndDocument(); } BsonArraySerializer.Instance.Serialize(this, typeof(BsonArray), array, null); } }
public static string ConvertToJson(string bsonString) { StringBuilder jsonString = new StringBuilder(); string nameStr; string valueStr; Stack <string> stack = new Stack <string>(); string stackTop; Stack <bool> stackFirst = new Stack <bool>(); byte[] buffer = Convert.FromBase64String(bsonString); string text = Encoding.UTF8.GetString(buffer); using (var stream = new MemoryStream(buffer)) using (var reader = new BsonBinaryReader(stream)) { bool exit = false; bool firstElem = true; reader.ReadStartDocument(); jsonString.Append("{ "); while (!reader.IsAtEndOfFile() && !exit) { var bsonType = reader.ReadBsonType(); //.CurrentBsonType; switch (bsonType) { case MongoDB.Bson.BsonType.Array: nameStr = reader.ReadName(); reader.ReadStartArray(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : [ "); stack.Push("Array"); stackFirst.Push(firstElem); firstElem = true; break; case MongoDB.Bson.BsonType.Binary: break; case MongoDB.Bson.BsonType.Boolean: nameStr = reader.ReadName(); valueStr = reader.ReadBoolean().ToString(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.DateTime: nameStr = reader.ReadName(); valueStr = reader.ReadString(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.Decimal128: nameStr = reader.ReadName(); valueStr = reader.ReadDecimal128().ToString(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.Document: nameStr = reader.ReadName(); reader.ReadStartDocument(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : {{ "); stack.Push("Document"); stackFirst.Push(firstElem); firstElem = true; break; case MongoDB.Bson.BsonType.Double: nameStr = reader.ReadName(); valueStr = reader.ReadDouble().ToString(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.EndOfDocument: if (stack.Count == 0) { jsonString.Append("} "); exit = true; } else { stackTop = stack.Pop(); firstElem = stackFirst.Pop(); switch (stackTop) { case "Array": jsonString.Append("]"); reader.ReadEndArray(); break; case "Document": jsonString.Append("}"); reader.ReadEndDocument(); break; default: break; } } break; case MongoDB.Bson.BsonType.Int32: nameStr = reader.ReadName(); valueStr = reader.ReadInt32().ToString(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.Int64: nameStr = reader.ReadName(); valueStr = reader.ReadInt64().ToString(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.JavaScript: break; case MongoDB.Bson.BsonType.JavaScriptWithScope: break; case MongoDB.Bson.BsonType.MaxKey: nameStr = reader.ReadName(); reader.ReadMaxKey(); valueStr = ""; jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.MinKey: nameStr = reader.ReadName(); reader.ReadMinKey(); valueStr = ""; jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.Null: nameStr = reader.ReadName(); reader.ReadNull(); valueStr = "null"; if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.ObjectId: nameStr = reader.ReadName(); valueStr = reader.ReadObjectId().ToString(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.RegularExpression: break; case MongoDB.Bson.BsonType.String: if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } if (reader.State == BsonReaderState.Name) { nameStr = reader.ReadName(); jsonString.Append($"\"{nameStr}\" : "); } valueStr = reader.ReadString(); jsonString.Append($"\"{valueStr}\""); break; case MongoDB.Bson.BsonType.Symbol: nameStr = reader.ReadName(); valueStr = reader.ReadSymbol(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.Timestamp: nameStr = reader.ReadName(); valueStr = reader.ReadTimestamp().ToString(); if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; case MongoDB.Bson.BsonType.Undefined: nameStr = reader.ReadName(); reader.ReadUndefined(); valueStr = "undefined"; if (firstElem) { firstElem = false; } else { jsonString.Append(", "); } jsonString.Append($"\"{nameStr}\" : \"{valueStr}\""); break; default: break; } } reader.ReadEndDocument(); } return(jsonString.ToString());; }
public override void CopyTo(object[] array, int arrayIndex) { ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), false), true, _readerSettings)) { bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); array[arrayIndex++] = DeserializeBsonValue(bsonReader).RawValue; } bsonReader.ReadEndDocument(); } }
/// <summary> /// Tests whether the array contains a value. /// </summary> /// <param name="value">The value to test for.</param> /// <returns>True if the array contains the value.</returns> public override bool Contains(BsonValue value) { ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), false), true, _readerSettings)) { bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (DeserializeBsonValue(bsonReader).Equals(value)) { return true; } } bsonReader.ReadEndDocument(); return false; } }
// public indexers /// <summary> /// Gets or sets a value by position. /// </summary> /// <param name="index">The position.</param> /// <returns>The value.</returns> public override BsonValue this[int index] { get { if (index < 0) { throw new ArgumentOutOfRangeException("index"); } ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), false), true, _readerSettings)) { bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (i == index) { return DeserializeBsonValue(bsonReader); } bsonReader.SkipValue(); i++; } bsonReader.ReadEndDocument(); throw new ArgumentOutOfRangeException("index"); } } set { throw new NotSupportedException("RawBsonArray instances are immutable."); } }
private void BsonToSql(string tableName, string input, CancellationToken token) { const string PARAM_FILENAME = "@fileName"; const string PARAM_DOCUMENT = "@document"; const string PARAM_PROCESSID = "@processId"; const string QUERY = @"insert {0} (fileName,document,processId) values (@fileName,@document,@processId);"; using (var cn = new SqlConnection(_attributes[CONNECTION_STRING])) { cn.Open(); try { using (SqlCommand cmd = new SqlCommand(String.Format(QUERY, tableName), cn)) { cmd.Parameters.Add(PARAM_FILENAME, SqlDbType.NVarChar, 500); cmd.Parameters.Add(PARAM_DOCUMENT, SqlDbType.NVarChar, -1); var param = cmd.Parameters.Add(PARAM_PROCESSID, SqlDbType.Int); param.Value = Int32.Parse(_attributes[RUNID]); cmd.Prepare(); using (token.Register(cmd.Cancel)) { string[] files = Directory.GetFiles(Path.GetDirectoryName(input), Path.GetFileName(input), SearchOption.TopDirectoryOnly); foreach (string file in files) { token.ThrowIfCancellationRequested(); CheckTable(tableName, token); cmd.Parameters[PARAM_FILENAME].Value = file; FileInfo fileToLoad = new FileInfo(file); using (FileStream originalFileStream = fileToLoad.OpenRead()) { if ((File.GetAttributes(fileToLoad.FullName) & FileAttributes.Hidden) != FileAttributes.Hidden & fileToLoad.Extension != ".json") { using (var reader = new BsonBinaryReader(originalFileStream)) { while (!reader.IsAtEndOfFile()) { token.ThrowIfCancellationRequested(); var bson = BsonSerializer.Deserialize <BsonDocument>(reader); string json = bson.ToJson(new JsonWriterSettings() { OutputMode = JsonOutputMode.CanonicalExtendedJson }); cmd.Parameters[PARAM_DOCUMENT].Value = json; cmd.ExecuteNonQuery(); } } } _logger.Information("Loaded {From} => {To}", fileToLoad.Name, tableName); } } } } } catch (SqlException ex) { throw ex; //_logger.Write(String.Format("SqlServer exception: {0}", ex.Message)); //result = WfResult.Create(WfStatus.Failed, ex.Message, ex.ErrorCode); } finally { if (cn.State != ConnectionState.Closed) { cn.Close(); } } } }
/// <summary> /// Tests whether the document contains an element with the specified name. /// </summary> /// <param name="name">The name of the element to look for.</param> /// <returns> /// True if the document contains an element with the specified name. /// </returns> public override bool Contains(string name) { if (name == null) { throw new ArgumentNullException("name"); } ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), true), true, _readerSettings)) { bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { if (bsonReader.ReadName() == name) { return true; } bsonReader.SkipValue(); } bsonReader.ReadEndDocument(); return false; } }
public BinaryMessageEncoderFactory(BsonBinaryReader binaryReader, BsonBinaryWriter binaryWriter) { Ensure.That(binaryReader != null || binaryWriter != null, "bsonReader and bsonWriter cannot both be null."); _binaryReader = binaryReader; _binaryWriter = binaryWriter; }
private TCommandResult ProcessResponse(ConnectionId connectionId, CommandMessage responseMessage) { using (new CommandMessageDisposer(responseMessage)) { var rawDocument = responseMessage.Sections.OfType <Type0CommandMessageSection <RawBsonDocument> >().Single().Document; var binaryReaderSettings = new BsonBinaryReaderSettings(); if (_messageEncoderSettings != null) { binaryReaderSettings.Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict); #pragma warning disable 618 if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2) { binaryReaderSettings.GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy); } #pragma warning restore 618 } ; BsonValue clusterTime; if (rawDocument.TryGetValue("$clusterTime", out clusterTime)) { // note: we are assuming that _session is an instance of ClusterClockAdvancingClusterTime // and that calling _session.AdvanceClusterTime will have the side effect of advancing the cluster's ClusterTime also var materializedClusterTime = ((RawBsonDocument)clusterTime).Materialize(binaryReaderSettings); _session.AdvanceClusterTime(materializedClusterTime); } BsonValue operationTime; if (rawDocument.TryGetValue("operationTime", out operationTime)) { _session.AdvanceOperationTime(operationTime.AsBsonTimestamp); } if (rawDocument.GetValue("ok", false).ToBoolean()) { if (rawDocument.TryGetValue("recoveryToken", out var rawRecoveryToken)) { var recoveryToken = ((RawBsonDocument)rawRecoveryToken).Materialize(binaryReaderSettings); _session.CurrentTransaction.RecoveryToken = recoveryToken; } } else { var materializedDocument = rawDocument.Materialize(binaryReaderSettings); var commandName = _command.GetElement(0).Name; if (commandName == "$query") { commandName = _command["$query"].AsBsonDocument.GetElement(0).Name; } var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, _command, materializedDocument, "errmsg"); if (notPrimaryOrNodeIsRecoveringException != null) { throw notPrimaryOrNodeIsRecoveringException; } var mappedException = ExceptionMapper.Map(connectionId, materializedDocument); if (mappedException != null) { throw mappedException; } string message; BsonValue errmsgBsonValue; if (materializedDocument.TryGetValue("errmsg", out errmsgBsonValue) && errmsgBsonValue.IsString) { var errmsg = errmsgBsonValue.ToString(); message = string.Format("Command {0} failed: {1}.", commandName, errmsg); } else { message = string.Format("Command {0} failed.", commandName); } var exception = new MongoCommandException(connectionId, message, _command, materializedDocument); // https://jira.mongodb.org/browse/CSHARP-2678 if (IsRetryableWriteExceptionAndDeploymentDoesNotSupportRetryableWrites(exception)) { throw WrapNotSupportedRetryableWriteException(exception); } else { throw exception; } } if (rawDocument.Contains("writeConcernError")) { var materializedDocument = rawDocument.Materialize(binaryReaderSettings); var writeConcernError = materializedDocument["writeConcernError"].AsBsonDocument; var message = writeConcernError.AsBsonDocument.GetValue("errmsg", null)?.AsString; var writeConcernResult = new WriteConcernResult(materializedDocument); throw new MongoWriteConcernException(connectionId, message, writeConcernResult); } using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false)) { using (var reader = new BsonBinaryReader(stream, binaryReaderSettings)) { var context = BsonDeserializationContext.CreateRoot(reader); return(_resultSerializer.Deserialize(context)); } } } }
// constructors public QueryMessageBinaryEncoder(BsonBinaryReader binaryReader, BsonBinaryWriter binaryWriter) { Ensure.That(binaryReader != null || binaryWriter != null, "binaryReader and binaryWriter cannot both be null."); _binaryReader = binaryReader; _binaryWriter = binaryWriter; }
private RawBsonArray DeserializeRawBsonArray(BsonBinaryReader bsonReader) { var slice = bsonReader.ReadRawBsonArray(); var nestedArray = new RawBsonArray(slice); _disposableItems.Add(nestedArray); return nestedArray; }
private IEnumerable<BsonElement> MaterializeThisLevel() { var elements = new List<BsonElement>(); var readerSettings = _readerSettings.Clone(); readerSettings.MaxDocumentSize = _slice.Length; using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), true), true, readerSettings)) { bsonReader.ReadStartDocument(); BsonType bsonType; while ((bsonType = bsonReader.ReadBsonType()) != BsonType.EndOfDocument) { var name = bsonReader.ReadName(); BsonValue value; switch (bsonType) { case BsonType.Array: value = DeserializeLazyBsonArray(bsonReader); break; case BsonType.Document: value = DeserializeLazyBsonDocument(bsonReader); break; default: value = (BsonValue)BsonValueSerializer.Instance.Deserialize(bsonReader, typeof(BsonValue), null); break; } elements.Add(new BsonElement(name, value)); } bsonReader.ReadEndDocument(); } return elements; }
private RawBsonDocument DeserializeRawBsonDocument(BsonBinaryReader bsonReader) { var slice = bsonReader.ReadRawBsonDocument(); var nestedDocument = new RawBsonDocument(slice); _disposableItems.Add(nestedDocument); return nestedDocument; }
private BsonValue DeserializeBsonValue(BsonBinaryReader bsonReader) { switch (bsonReader.GetCurrentBsonType()) { case BsonType.Array: return DeserializeRawBsonArray(bsonReader); case BsonType.Document: return DeserializeRawBsonDocument(bsonReader); default: return (BsonValue)BsonValueSerializer.Instance.Deserialize(bsonReader, typeof(BsonValue), null); } }
/// <summary> /// Gets an enumerator that can enumerate the elements of the array. /// </summary> /// <returns>An enumerator.</returns> public override IEnumerator<BsonValue> GetEnumerator() { ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), false), true, _readerSettings)) { bsonReader.ReadStartDocument(); while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); yield return DeserializeBsonValue(bsonReader); } bsonReader.ReadEndDocument(); } }
/// <summary> /// Gets the value of an element. /// </summary> /// <param name="index">The zero based index of the element.</param> /// <returns> /// The value of the element. /// </returns> public override BsonValue GetValue(int index) { if (index < 0) { throw new ArgumentOutOfRangeException("index"); } ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), true), true, _readerSettings)) { bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (i == index) { return DeserializeBsonValue(bsonReader); } bsonReader.SkipValue(); i++; } bsonReader.ReadEndDocument(); throw new ArgumentOutOfRangeException("index"); } }
// internal methods internal void ReadFrom(BsonBuffer buffer, IBsonSerializationOptions serializationOptions) { if (serializationOptions == null && typeof(TDocument) == typeof(BsonDocument)) { serializationOptions = DocumentSerializationOptions.AllowDuplicateNamesInstance; } var messageStartPosition = buffer.Position; ReadMessageHeaderFrom(buffer); _responseFlags = (ResponseFlags)buffer.ReadInt32(); _cursorId = buffer.ReadInt64(); _startingFrom = buffer.ReadInt32(); _numberReturned = buffer.ReadInt32(); if ((_responseFlags & ResponseFlags.CursorNotFound) != 0) { throw new MongoQueryException("Cursor not found."); } if ((_responseFlags & ResponseFlags.QueryFailure) != 0) { BsonDocument document; using (BsonReader bsonReader = new BsonBinaryReader(buffer, false, _readerSettings)) { document = (BsonDocument)BsonDocumentSerializer.Instance.Deserialize(bsonReader, typeof(BsonDocument), null); } var mappedException = ExceptionMapper.Map(document); if (mappedException != null) { throw mappedException; } var err = document.GetValue("$err", "Unknown error."); var message = string.Format("QueryFailure flag was {0} (response was {1}).", err, document.ToJson()); throw new MongoQueryException(message, document); } _documents = new List <TDocument>(_numberReturned); for (int i = 0; i < _numberReturned; i++) { BsonBuffer sliceBuffer; if (buffer.ByteBuffer is MultiChunkBuffer) { // we can use slightly faster SingleChunkBuffers for all documents that don't span chunk boundaries var position = buffer.Position; var length = buffer.ReadInt32(); var slice = buffer.ByteBuffer.GetSlice(position, length); buffer.Position = position + length; sliceBuffer = new BsonBuffer(slice, true); } else { sliceBuffer = new BsonBuffer(buffer.ByteBuffer, false); } using (var bsonReader = new BsonBinaryReader(sliceBuffer, true, _readerSettings)) { var document = (TDocument)_serializer.Deserialize(bsonReader, typeof(TDocument), serializationOptions); _documents.Add(document); } } }
/// <summary> /// Gets the index of a value in the array. /// </summary> /// <param name="value">The value to search for.</param> /// <param name="index">The zero based index at which to start the search.</param> /// <param name="count">The number of elements to search.</param> /// <returns>The zero based index of the value (or -1 if not found).</returns> public override int IndexOf(BsonValue value, int index, int count) { ThrowIfDisposed(); using (var bsonReader = new BsonBinaryReader(new BsonBuffer(CloneSlice(), false), true, _readerSettings)) { bsonReader.ReadStartDocument(); var i = 0; while (bsonReader.ReadBsonType() != BsonType.EndOfDocument) { bsonReader.SkipName(); if (i >= index) { if (count == 0) { return -1; } if (DeserializeBsonValue(bsonReader).Equals(value)) { return i; } count--; } else { bsonReader.SkipValue(); } i++; } bsonReader.ReadEndDocument(); return -1; } }