Esempio n. 1
0
        public void Equals_when_creating_blittable_in_different_ways()
        {
            using (var ctx = JsonOperationContext.ShortTermSingleUse())
            {
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(ctx))
                    using (var embeddedBuilder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(ctx))
                    {
                        builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                        embeddedBuilder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);

                        embeddedBuilder.StartWriteObjectDocument();
                        embeddedBuilder.StartWriteObject();

                        embeddedBuilder.WritePropertyName("Name");
                        embeddedBuilder.WriteValue("Hibernating Rhinos");
                        embeddedBuilder.WritePropertyName("Type");
                        embeddedBuilder.WriteValue("LTD");

                        embeddedBuilder.WriteObjectEnd();
                        embeddedBuilder.FinalizeDocument();
                        var embeddedCompany = embeddedBuilder.CreateReader();

                        builder.StartWriteObjectDocument();
                        builder.StartWriteObject();

                        builder.WritePropertyName("Company");
                        builder.WriteEmbeddedBlittableDocument(embeddedCompany);
                        builder.WritePropertyName("Street");
                        builder.WriteValue("Hanasi 21");
                        builder.WritePropertyName("City");
                        builder.WriteValue("Hadera");

                        builder.WriteObjectEnd();
                        builder.FinalizeDocument();
                        var blittable1 = builder.CreateReader();

                        var json2 = new DynamicJsonValue()
                        {
                            ["Company"] = new DynamicJsonValue()
                            {
                                ["Name"] = "Hibernating Rhinos",
                                ["Type"] = "LTD",
                            },
                            ["Street"] = "Hanasi 21",
                            ["City"]   = "Hadera",
                        };

                        using (var blittable2 = ctx.ReadObject(json2, "foo"))
                        {
                            Assert.Equal(blittable1, blittable2);
                            Assert.Equal(blittable1.GetHashCode(), blittable2.GetHashCode());

                            blittable1.TryGet("Company", out BlittableJsonReaderObject ob1);
                            blittable2.TryGet("Company", out BlittableJsonReaderObject ob2);

                            Assert.Equal(ob1, ob2);
                        }
                    }
            }
        }
Esempio n. 2
0
        public static BlittableJsonReaderObject Translate(JsonOperationContext context, Engine scriptEngine, ObjectInstance objectInstance, IResultModifier modifier = null, BlittableJsonDocumentBuilder.UsageMode usageMode = BlittableJsonDocumentBuilder.UsageMode.None)
        {
            if (objectInstance == null)
            {
                return(null);
            }

            if (objectInstance is BlittableObjectInstance boi && boi.Changed == false)
            {
                return(boi.Blittable.Clone(context));
            }

            using (var writer = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
            {
                writer.Reset(usageMode);
                writer.StartWriteObjectDocument();

                var blittableBridge = new JsBlittableBridge(writer, usageMode, scriptEngine);
                blittableBridge.WriteInstance(objectInstance, modifier);

                writer.FinalizeDocument();

                return(writer.CreateReader());
            }
        }
Esempio n. 3
0
        private static BlittableJsonReaderObject WriteNewCountersDocument(DocumentsOperationContext context, List <string> dbIds, IEnumerable <KeyValuePair <string, List <CounterDetail> > > batch)
        {
            var toDispose = new List <IDisposable>();

            try
            {
                BlittableJsonReaderObject data;
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    builder.StartWriteObjectDocument();

                    builder.StartWriteObject();

                    builder.WritePropertyName(CountersStorage.DbIds);

                    builder.StartWriteArray();

                    foreach (var dbId in dbIds)
                    {
                        builder.WriteValue(dbId);
                    }

                    builder.WriteArrayEnd();

                    builder.WritePropertyName(CountersStorage.Values);
                    builder.StartWriteObject();

                    foreach (var kvp in batch)
                    {
                        builder.WritePropertyName(kvp.Key);

                        var maxDbIdIndex = GetMaxDbIdIndex(context, dbIds, kvp.Value);

                        toDispose.Add(context.Allocator.Allocate((maxDbIdIndex + 1) * CountersStorage.SizeOfCounterValues, out var newVal));

                        Memory.Set(newVal.Ptr, 0, newVal.Length);

                        WriteRawBlob(context, dbIds, kvp.Value, newVal, builder);
                    }

                    builder.WriteObjectEnd();

                    builder.WriteObjectEnd();
                    builder.FinalizeDocument();

                    data = builder.CreateReader();
                }

                return(data);
            }

            finally
            {
                foreach (var scope in toDispose)
                {
                    scope.Dispose();
                }
            }
        }
        public void BasicIntNestedStructure()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4, SharedMultipleUseFlag.None))
            {
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    builder.StartWriteObjectDocument();

                    builder.StartWriteObject();
                    {
                        builder.WritePropertyName("Data");
                        {
                            builder.StartWriteObject();
                            {
                                builder.WritePropertyName("Volume");
                                {
                                    builder.WriteValue(44);
                                }
                                builder.WritePropertyName("Height");
                                {
                                    builder.WriteValue(55);
                                }
                                builder.WriteObjectEnd();
                            }
                        }
                        builder.WritePropertyName("@MetaData");
                        {
                            builder.StartWriteObject();
                            {
                                builder.WritePropertyName("Ticks");
                                {
                                    builder.WriteValue(22);
                                }
                                builder.WritePropertyName("Tacks");
                                {
                                    builder.WriteValue(11);
                                }
                                builder.WriteObjectEnd();
                            }
                        }
                        builder.WriteObjectEnd();
                    }
                    builder.FinalizeDocument();
                    var reader = builder.CreateReader();
                    var stream = new MemoryStream();


                    Assert.Equal(2, reader.Count);

                    var data = reader["Data"] as BlittableJsonReaderObject;
                    Assert.Equal(44, int.Parse(data["Volume"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(55, int.Parse(data["Height"].ToString(), CultureInfo.InvariantCulture));

                    var metadata = reader["@MetaData"] as BlittableJsonReaderObject;
                    Assert.Equal(22, int.Parse(metadata["Ticks"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(11, int.Parse(metadata["Tacks"].ToString(), CultureInfo.InvariantCulture));
                }
            }
        }
        public void BasicIntFlatStructure()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4, SharedMultipleUseFlag.None))
            {
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    builder.StartWriteObjectDocument();

                    builder.StartWriteObject();
                    {
                        builder.WritePropertyName("Volume");
                        {
                            builder.WriteValue(44);
                        }
                        builder.WritePropertyName("Height");
                        {
                            builder.WriteValue(55);
                        }
                        builder.WriteObjectEnd();
                    }
                    builder.FinalizeDocument();

                    var reader = builder.CreateReader();

                    Assert.Equal(2, reader.Count);
                    var volumeValue = reader["Volume"].ToString();
                    Assert.Equal(44, int.Parse(volumeValue, CultureInfo.InvariantCulture));
                    var heightValue = reader["Height"].ToString();
                    Assert.Equal(55, int.Parse(heightValue, CultureInfo.InvariantCulture));
                }
            }
        }
Esempio n. 6
0
        private void WriteRevisionsBlittable(DocumentsOperationContext context, IEnumerable <Document> documentsToWrite, out long numberOfResults)
        {
            numberOfResults = 0;
            HttpContext.Response.Headers["Content-Type"] = "binary/blittable-json";

            using (var streamBuffer = new UnmanagedStreamBuffer(context, ResponseBodyStream()))
                using (var writer = new ManualBlittableJsonDocumentBuilder <UnmanagedStreamBuffer>(context,
                                                                                                   null, new BlittableWriter <UnmanagedStreamBuffer>(context, streamBuffer)))
                {
                    writer.StartWriteObjectDocument();

                    writer.StartWriteObject();
                    writer.WritePropertyName(nameof(GetDocumentsResult.Results));

                    writer.StartWriteArray();
                    foreach (var document in documentsToWrite)
                    {
                        numberOfResults++;
                        writer.WriteEmbeddedBlittableDocument(document.Data);
                    }
                    writer.WriteArrayEnd();

                    writer.WriteObjectEnd();

                    writer.FinalizeDocument();
                }
        }
        private static void WriteConflictResolver(string name, ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer> documentWriter,
                                                  ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer> metadataWriter, ConflictResolverAdvisor resolver, int indent)
        {
            MergeResult result = resolver.Resolve(indent);

            if (resolver.IsMetadataResolver)
            {
                if (name != "@metadata")
                {
                    metadataWriter.WritePropertyName(name);
                    metadataWriter.StartWriteObject();
                    result.Document.AddItemsToStream(metadataWriter);
                    metadataWriter.WriteObjectEnd();
                    return;
                }
                result.Document.AddItemsToStream(metadataWriter);
            }
            else
            {
                documentWriter.WritePropertyName(name);
                documentWriter.StartWriteObject();
                result.Document.AddItemsToStream(documentWriter);
                documentWriter.WriteObjectEnd();
            }
        }
Esempio n. 8
0
        public void BigAmountOfProperties(int propertiesAmount)
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4, SharedMultipleUseFlag.None))
            {
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);

                    builder.StartWriteObjectDocument();
                    builder.StartWriteObject();

                    for (int i = 0; i < propertiesAmount; i++)
                    {
                        builder.WritePropertyName("Age" + i);
                        builder.WriteValue(i);
                    }

                    builder.WriteObjectEnd();
                    builder.FinalizeDocument();

                    using (var reader = builder.CreateReader())
                    {
                        Assert.Equal(propertiesAmount, reader.Count);
                        for (var i = 0; i < propertiesAmount; i++)
                        {
                            var val = reader["Age" + i];
                            Assert.Equal(i, int.Parse(val.ToString(), CultureInfo.InvariantCulture));
                        }
                    }
                }
            }
        }
        public void BasicNestedEmptyObject()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4, SharedMultipleUseFlag.None))
            {
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    builder.StartWriteObjectDocument();

                    builder.StartWriteObject();
                    {
                        builder.WritePropertyName("EmptyObject");
                        {
                            builder.StartWriteObject();
                            builder.WriteObjectEnd();
                        }
                        builder.WriteObjectEnd();
                    }
                    builder.FinalizeDocument();

                    using (var reader = builder.CreateReader())
                    {
                        Assert.Equal(1, reader.Count);
                        var nested = reader["EmptyObject"] as BlittableJsonReaderObject;
                        Assert.Equal(0, nested.Count);
                    }
                }
            }
        }
        public void SimpleArrayDocument()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4, SharedMultipleUseFlag.None))
            {
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    builder.StartArrayDocument();

                    builder.StartWriteArray();
                    {
                        for (var i = 0; i < 8; i++)
                        {
                            builder.WriteValue(i);
                        }
                        builder.WriteArrayEnd();
                    }
                    builder.FinalizeDocument();

                    var reader = builder.CreateArrayReader();

                    Assert.Equal(8, reader.Length);

                    for (var i = 0; i < 8; i++)
                    {
                        Assert.Equal(i, int.Parse(reader[i].ToString(), CultureInfo.InvariantCulture));
                    }
                }
            }
        }
        public void ObjectWithNestedIntArrayTest()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4, SharedMultipleUseFlag.None))
            {
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    builder.StartWriteObjectDocument();

                    builder.StartWriteObject();
                    {
                        builder.WritePropertyName("MyNestedArrayOfNumbers");
                        {
                            builder.StartWriteArray();
                            {
                                for (var i = 0; i < 8; i++)
                                {
                                    builder.StartWriteArray();
                                    {
                                        for (var j = 0; j < 8; j++)
                                        {
                                            builder.WriteValue(j);
                                        }

                                        builder.WriteArrayEnd();
                                    }
                                }

                                builder.WriteArrayEnd();
                            }
                        }
                        builder.WritePropertyName("Height");
                        {
                            builder.WriteValue(55);
                        }
                        builder.WriteObjectEnd();
                    }
                    builder.FinalizeDocument();

                    var reader = builder.CreateReader();

                    Assert.Equal(2, reader.Count);

                    var array = reader["MyNestedArrayOfNumbers"] as BlittableJsonReaderArray;
                    Assert.Equal(8, array.Length);

                    for (var i = 0; i < 8; i++)
                    {
                        var innerArray = array[i] as BlittableJsonReaderArray;

                        for (var j = 0; j < 8; j++)
                        {
                            Assert.Equal(i, int.Parse(innerArray[i].ToString(), CultureInfo.InvariantCulture));
                        }
                    }
                    Assert.Equal(55, int.Parse(reader["Height"].ToString(), CultureInfo.InvariantCulture));
                }
            }
        }
Esempio n. 12
0
 public BlittableJsonWriter(JsonOperationContext context, DocumentInfo documentInfo = null,
                            BlittableJsonDocumentBuilder.UsageMode?mode             = null, BlittableWriter <UnmanagedWriteBuffer> writer = null)
 {
     _manualBlittableJsonDocumentBuilder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context, mode ?? BlittableJsonDocumentBuilder.UsageMode.None, writer);
     _manualBlittableJsonDocumentBuilder.Reset(mode ?? BlittableJsonDocumentBuilder.UsageMode.None);
     _manualBlittableJsonDocumentBuilder.StartWriteObjectDocument();
     _documentInfo = documentInfo;
     _first        = true;
 }
Esempio n. 13
0
        public BlittableJsonWriter(JsonOperationContext context, DocumentInfo documentInfo = null,
                                   BlittableJsonDocumentBuilder.UsageMode?mode             = null, BlittableWriter <UnmanagedWriteBuffer> writer = null,
                                   LazyStringValue idField = null, LazyStringValue keyField = null, LazyStringValue collectionField = null)
        {
            _manualBlittableJsonDocumentBuilder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context, mode ?? BlittableJsonDocumentBuilder.UsageMode.None, writer);
            _manualBlittableJsonDocumentBuilder.Reset(mode ?? BlittableJsonDocumentBuilder.UsageMode.None);
            _manualBlittableJsonDocumentBuilder.StartWriteObjectDocument();
            _documentInfo = documentInfo;
            _first        = true;

            _metadataId         = idField ?? context.GetLazyStringForFieldWithCaching(Constants.Documents.Metadata.Id);
            _metadataKey        = keyField ?? context.GetLazyStringForFieldWithCaching(Constants.Documents.Metadata.Key);
            _metadataCollection = collectionField ?? context.GetLazyStringForFieldWithCaching(Constants.Documents.Metadata.Collection);
        }
Esempio n. 14
0
        private static void WriteToken(ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer> writer, string propertyName, object propertyValue)
        {
            writer.WritePropertyName(propertyName);
            if (propertyValue is BlittableJsonReaderObject.PropertyDetails)
            {
                var prop = (BlittableJsonReaderObject.PropertyDetails)propertyValue;
                writer.WriteValue(prop.Token, prop.Value);
                return;
            }

            var conflicted = propertyValue as Conflicted;

            if (conflicted != null)
            {
                writer.StartWriteArray();
                writer.WriteValue(">>>> conflict start");
                foreach (BlittableJsonReaderObject.PropertyDetails item in conflicted.Values)
                {
                    writer.WriteValue(item.Token, item.Value);
                }
                writer.WriteValue("<<<< conflict end");
                writer.WriteArrayEnd();
                return;
            }

            var arrayWithWarning = propertyValue as ArrayWithWarning;

            if (arrayWithWarning != null)
            {
                writer.StartWriteArray();
                writer.WriteValue(">>>> auto merged array start");
                arrayWithWarning.MergedArray.AddItemsToStream(writer);
                writer.WriteValue("<<<< auto merged array end");
                writer.WriteArrayEnd();
                return;
            }

            var array = propertyValue as BlittableJsonReaderArray;

            if (array != null)
            {
                writer.StartWriteArray();
                array.AddItemsToStream(writer);
                writer.WriteArrayEnd();
                return;
            }

            throw new InvalidOperationException("Could not understand how to deal with: " + propertyValue);
        }
        public void BasicObject()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4, SharedMultipleUseFlag.None))
            {
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);

                    builder.StartWriteObjectDocument();
                    builder.StartWriteObject();

                    builder.WritePropertyName("Age");

                    builder.WriteValue(1);
                    builder.WriteObjectEnd();
                    builder.FinalizeDocument();

                    using (var reader = builder.CreateReader())
                        Assert.Equal(1, reader.Count);
                }
            }
        }
Esempio n. 16
0
        private MergeResult GenerateOutput(Dictionary <string, object> result, int indent)
        {
            using (var documentWriter = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(_context))
                using (var metadataWriter = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(_context))
                {
                    documentWriter.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    metadataWriter.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    documentWriter.StartWriteObjectDocument();
                    metadataWriter.StartWriteObjectDocument();
                    documentWriter.StartWriteObject();
                    metadataWriter.StartWriteObject();

                    foreach (var o in result)
                    {
                        var resolver = o.Value as ConflictResolverAdvisor;
                        if (resolver != null)
                        {
                            WriteConflictResolver(o.Key, documentWriter, metadataWriter, resolver,
                                                  o.Key == Constants.Documents.Metadata.Key ? 0 : indent + 1);
                        }
                        else
                        {
                            WriteToken(o.Key == Constants.Documents.Metadata.Key ? metadataWriter : documentWriter, o.Key, o.Value);
                        }
                    }

                    documentWriter.WriteObjectEnd();
                    metadataWriter.WriteObjectEnd();
                    documentWriter.FinalizeDocument();
                    metadataWriter.FinalizeDocument();

                    return(new MergeResult
                    {
                        Document = documentWriter.CreateReader(),
                        Metadata = metadataWriter.CreateReader()
                    });
                }
        }
        public void FlatObjectWithEmptyArray()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4, SharedMultipleUseFlag.None))
            {
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    builder.StartWriteObjectDocument();

                    builder.StartWriteObject();
                    {
                        builder.WritePropertyName("MyEmptyArray");
                        {
                            builder.StartWriteArray();
                            {
                                builder.WriteArrayEnd();
                            }
                        }
                        builder.WritePropertyName("Height");
                        {
                            builder.WriteValue(55);
                        }
                        builder.WriteObjectEnd();
                    }
                    builder.FinalizeDocument();

                    var reader = builder.CreateReader();

                    Assert.Equal(2, reader.Count);

                    var array = reader["MyEmptyArray"] as BlittableJsonReaderArray;
                    Assert.Equal(0, array.Length);

                    Assert.Equal(55, int.Parse(reader["Height"].ToString(), CultureInfo.InvariantCulture));
                }
            }
        }
Esempio n. 18
0
 public JsBlittableBridge(ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer> writer, BlittableJsonDocumentBuilder.UsageMode usageMode, Engine scriptEngine)
 {
     _writer       = writer;
     _usageMode    = usageMode;
     _scriptEngine = scriptEngine;
 }
Esempio n. 19
0
        public void Equals_blittables_created_manually()
        {
            using (var ctx = JsonOperationContext.ShortTermSingleUse())
            {
                BlittableJsonReaderObject CreateBlittable()
                {
                    using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(ctx))
                        using (var officeBuilder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(ctx))
                            using (var companyBuilder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(ctx))
                            {
                                builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                                officeBuilder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                                companyBuilder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);

                                companyBuilder.StartWriteObjectDocument();
                                companyBuilder.StartWriteObject();

                                companyBuilder.WritePropertyName("Name");
                                companyBuilder.WriteValue("Hibernating Rhinos");
                                companyBuilder.WritePropertyName("Type");
                                companyBuilder.WriteValue("LTD");

                                companyBuilder.WriteObjectEnd();
                                companyBuilder.FinalizeDocument();
                                var embeddedCompany = companyBuilder.CreateReader();

                                officeBuilder.StartWriteObjectDocument();
                                officeBuilder.StartWriteObject();

                                officeBuilder.WritePropertyName("Company");
                                officeBuilder.WriteEmbeddedBlittableDocument(embeddedCompany);
                                officeBuilder.WritePropertyName("Street");
                                officeBuilder.WriteValue("Hanasi 21");
                                officeBuilder.WritePropertyName("City");
                                officeBuilder.WriteValue("Hadera");

                                officeBuilder.WriteObjectEnd();
                                officeBuilder.FinalizeDocument();

                                var embeddedOffice = officeBuilder.CreateReader();

                                builder.StartWriteObjectDocument();
                                builder.StartWriteObject();

                                builder.WritePropertyName("Office");
                                builder.WriteEmbeddedBlittableDocument(embeddedOffice);

                                builder.WriteObjectEnd();
                                builder.FinalizeDocument();

                                return(builder.CreateReader());
                            }
                }

                using (var blittable1 = CreateBlittable())
                    using (var blittable2 = CreateBlittable())
                    {
                        Assert.Equal(blittable1, blittable2);
                        Assert.Equal(blittable1.GetHashCode(), blittable2.GetHashCode());

                        blittable1.TryGet("Office", out BlittableJsonReaderObject ob1);
                        blittable2.TryGet("Office", out BlittableJsonReaderObject ob2);

                        Assert.Equal(ob1.GetHashCode(), ob2.GetHashCode());
                        Assert.Equal(ob1, ob2);
                    }
            }
        }
        public unsafe void ReadDataTypesTest()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4, SharedMultipleUseFlag.None))
            {
                BlittableJsonReaderObject embeddedReader;
                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    builder.StartWriteObjectDocument();
                    builder.StartWriteObject();
                    builder.WritePropertyName("Value");
                    builder.WriteValue(1000);
                    builder.WriteObjectEnd();
                    builder.FinalizeDocument();
                    embeddedReader = builder.CreateReader();
                }

                using (var builder = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    var lonEscapedCharsString             = string.Join(",", Enumerable.Repeat("\"Cool\"", 200).ToArray());
                    var longEscapedCharsAndNonAsciiString = string.Join(",", Enumerable.Repeat("\"מגניב\"", 200).ToArray());

                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);

                    builder.StartWriteObjectDocument();
                    builder.StartWriteObject();

                    builder.WritePropertyName("FloatMin");
                    builder.WriteValue(float.MinValue);

                    builder.WritePropertyName("FloatMax");
                    builder.WriteValue(float.MaxValue);

                    builder.WritePropertyName("UshortMin");
                    builder.WriteValue(ushort.MinValue);

                    builder.WritePropertyName("UshortMax");
                    builder.WriteValue(ushort.MaxValue);

                    builder.WritePropertyName("UintMin");
                    builder.WriteValue(uint.MinValue);

                    builder.WritePropertyName("UintMax");
                    builder.WriteValue(uint.MaxValue);

                    builder.WritePropertyName("DoubleMin");
                    builder.WriteValue(double.MinValue);

                    builder.WritePropertyName("DoubleMax");
                    builder.WriteValue(double.MaxValue);

                    builder.WritePropertyName("LongMin");
                    builder.WriteValue(long.MinValue);

                    builder.WritePropertyName("LongMax");
                    builder.WriteValue(long.MaxValue);

                    builder.WritePropertyName("StringEmpty");
                    builder.WriteValue(string.Empty);

                    builder.WritePropertyName("StringSimple");
                    builder.WriteValue("StringSimple");

                    builder.WritePropertyName("StringEscapedChars");
                    builder.WriteValue("\"Cool\"");

                    builder.WritePropertyName("StringLongEscapedChars");
                    builder.WriteValue(lonEscapedCharsString);

                    builder.WritePropertyName("StringEscapedCharsAndNonAscii");
                    builder.WriteValue(longEscapedCharsAndNonAsciiString);


                    var lsvString      = "\"fooאbar\"";
                    var lsvStringBytes = Encoding.UTF8.GetBytes(lsvString);
                    fixed(byte *b = lsvStringBytes)
                    {
                        var escapePositionsMaxSize = JsonParserState.FindEscapePositionsMaxSize(lsvString);
                        var lsv             = context.AllocateStringValue(null, b, lsvStringBytes.Length);
                        var escapePositions = new FastList <int>();
                        var len             = lsvStringBytes.Length;

                        JsonParserState.FindEscapePositionsIn(escapePositions, b, ref len, escapePositionsMaxSize);
                        lsv.EscapePositions = escapePositions.ToArray();

                        builder.WritePropertyName("LSVString");
                        builder.WriteValue(lsv);
                    }

                    builder.WritePropertyName("Embedded");
                    builder.WriteEmbeddedBlittableDocument(embeddedReader);

                    builder.WriteObjectEnd();
                    builder.FinalizeDocument();

                    var reader = builder.CreateReader();
                    reader.BlittableValidation();

                    Assert.Equal(17, reader.Count);
                    Assert.Equal(float.MinValue, float.Parse(reader["FloatMin"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(float.MaxValue, float.Parse(reader["FloatMax"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(ushort.MinValue, ushort.Parse(reader["UshortMin"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(ushort.MaxValue, ushort.Parse(reader["UshortMax"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(uint.MinValue, uint.Parse(reader["UintMin"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(uint.MaxValue, uint.Parse(reader["UintMax"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(double.MinValue, double.Parse(reader["DoubleMin"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(double.MaxValue, double.Parse(reader["DoubleMax"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(long.MinValue, long.Parse(reader["LongMin"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(long.MaxValue, long.Parse(reader["LongMax"].ToString(), CultureInfo.InvariantCulture));
                    Assert.Equal(string.Empty, reader["StringEmpty"].ToString());
                    Assert.Equal("StringSimple", reader["StringSimple"].ToString());
                    Assert.Equal("\"Cool\"", reader["StringEscapedChars"].ToString());
                    Assert.Equal(lonEscapedCharsString, reader["StringLongEscapedChars"].ToString());
                    Assert.Equal(longEscapedCharsAndNonAsciiString, reader["StringEscapedCharsAndNonAscii"].ToString());
                    Assert.Equal(lsvString, reader["LSVString"].ToString());
                    Assert.Equal(1000, int.Parse((reader["Embedded"] as BlittableJsonReaderObject)["Value"].ToString(), CultureInfo.InvariantCulture));
                }
            }
        }
Esempio n. 21
0
        private bool TryHandleArrayValue(int index, Dictionary <string, object> result, KeyValuePair <string, BlittableJsonReaderArray> prop)
        {
            var arrays = new List <BlittableJsonReaderArray>
            {
                prop.Value
            };

            for (var i = 0; i < _docs.Length; i++)
            {
                if (i == index)
                {
                    continue;
                }

                if (_docs[i].TryGetWithoutThrowingOnError(prop.Key, out BlittableJsonReaderArray token) == false)
                {
                    return(false);
                }
                if (token == null)
                {
                    continue;
                }
                arrays.Add(token);
            }

            var set        = new HashSet <Tuple <object, BlittableJsonToken> >();
            var lastLength = arrays[0].Length;
            var sameSize   = true;

            foreach (var arr in arrays)
            {
                sameSize = arr.Length == lastLength;
                for (var propIndex = 0; propIndex < arr.Length; propIndex++)
                {
                    var tuple = arr.GetValueTokenTupleByIndex(propIndex);
                    set.Add(tuple);
                }
            }
            BlittableJsonReaderArray reader;

            using (var mergedArray = new ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer>(_context))
            {
                mergedArray.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                mergedArray.StartArrayDocument();
                mergedArray.StartWriteArray();
                foreach (var item in set)
                {
                    mergedArray.WriteValue(item.Item2, item.Item1);
                }
                mergedArray.WriteArrayEnd();
                mergedArray.FinalizeDocument();
                reader = mergedArray.CreateArrayReader();
            }

            if (sameSize && prop.Value.Equals(reader))
            {
                result.Add(prop.Key, reader);
                return(true);
            }

            result.Add(prop.Key, new ArrayWithWarning(reader));
            return(true);
        }
Esempio n. 22
0
        private static void WriteRawBlob(DocumentsOperationContext context, List <string> dbIds, List <CounterDetail> counters, ByteString newVal, ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer> builder)
        {
            foreach (var counterDetail in counters)
            {
                var dbId = ExtractDbId(context, counterDetail.CounterKey);

                int dbIdIndex;
                for (dbIdIndex = 0; dbIdIndex < dbIds.Count; dbIdIndex++)
                {
                    if (dbIds[dbIdIndex] == dbId)
                    {
                        break;
                    }
                }

                var counterEtag = context.DocumentDatabase.DocumentsStorage.GenerateNextEtag();

                var newEntry = (CountersStorage.CounterValues *)newVal.Ptr + dbIdIndex;
                newEntry->Value = counterDetail.TotalValue;
                newEntry->Etag  = counterEtag;
            }

            builder.WriteRawBlob(newVal.Ptr, newVal.Length);
        }