Esempio n. 1
0
        public void BasicIntFlatStructure()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4))
            {
                using (var builder = new ManualBlittalbeJsonDocumentBuilder <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. 2
0
        private bool TryParse(DocumentsOperationContext context, PatcherOperationScope scope, out BlittableJsonReaderObject val)
        {
            if (scope.ActualPatchResult == JsValue.Undefined || scope.ActualPatchResult == JsValue.Undefined)
            {
                val = null;
                return(false);
            }

            if (scope.ActualPatchResult == TombstoneResolverValue)
            {
                val = null;
                return(true);
            }
            var obj = scope.ActualPatchResult.AsObject();

            using (var writer = new ManualBlittalbeJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
            {
                writer.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                writer.StartWriteObjectDocument();
                scope.ToBlittableJsonReaderObject(writer, obj);
                writer.FinalizeDocument();
                val = writer.CreateReader();
                return(true);
            }
        }
Esempio n. 3
0
        public void BigAmountOfPreperties(int propertiesAmount)
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4))
            {
                using (var builder = new ManualBlittalbeJsonDocumentBuilder <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();

                    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));
                    }
                }
            }
        }
Esempio n. 4
0
        public void BasicNestedEmptyObject()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4))
            {
                using (var builder = new ManualBlittalbeJsonDocumentBuilder <UnmanagedWriteBuffer>(context))
                {
                    builder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
                    builder.StartWriteObjectDocument();

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

                    var reader = builder.CreateReader();
                    Assert.Equal(1, reader.Count);
                    var nested = reader["EmptyObject"] as BlittableJsonReaderObject;
                    Assert.Equal(0, nested.Count);
                }
            }
        }
Esempio n. 5
0
        public void SimpleArrayDocument()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4))
            {
                using (var builder = new ManualBlittalbeJsonDocumentBuilder <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));
                    }
                }
            }
        }
Esempio n. 6
0
        public void BasicIntNestedStructure()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4))
            {
                using (var builder = new ManualBlittalbeJsonDocumentBuilder <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));
                }
            }
        }
Esempio n. 7
0
        public void ObjectWithNestedIntArrayTest()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4))
            {
                using (var builder = new ManualBlittalbeJsonDocumentBuilder <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));
                }
            }
        }
 public BlittableJsonWriter(JsonOperationContext context, DocumentInfo documentInfo = null,
                            BlittableJsonDocumentBuilder.UsageMode?mode             = null, BlittableWriter <UnmanagedWriteBuffer> writer = null)
 {
     _manualBlittalbeJsonDocumentBuilder = new ManualBlittalbeJsonDocumentBuilder <UnmanagedWriteBuffer>(context, mode, writer);
     _manualBlittalbeJsonDocumentBuilder.Reset(BlittableJsonDocumentBuilder.UsageMode.None);
     _manualBlittalbeJsonDocumentBuilder.StartWriteObjectDocument();
     _documentInfo = documentInfo;
     _first        = true;
 }
Esempio n. 9
0
        public void ToBlittableJsonReaderObject(ManualBlittalbeJsonDocumentBuilder <UnmanagedWriteBuffer> writer, ObjectInstance jsObject, string propertyKey = null,
                                                bool recursiveCall = false)
        {
            if (jsObject.Class == "Function")
            {
                // getting a Function instance here,
                // means that we couldn't evaluate it using Jint
                return;
            }
            writer.StartWriteObject();
            foreach (var property in jsObject.GetOwnProperties())
            {
                if (property.Key == Constants.Indexing.Fields.ReduceKeyFieldName || property.Key == Constants.Indexing.Fields.DocumentIdFieldName)
                {
                    continue;
                }

                var value = property.Value.Value;
                if (value.HasValue == false)
                {
                    continue;
                }

                if (value.Value.IsRegExp())
                {
                    continue;
                }

                var recursive = jsObject == value;
                writer.WritePropertyName(property.Key);
                if (recursiveCall && recursive)
                {
                    writer.WriteValueNull();
                }
                else
                {
                    ToBlittableJsonReaderValue(writer, value.Value, CreatePropertyKey(property.Key, propertyKey), recursive);
                }
            }
            writer.WriteObjectEnd();
        }
Esempio n. 10
0
        private void WriteDocumentsBlittable(DocumentsOperationContext context, IEnumerable <Document> documentsToWrite, List <Document> includes)
        {
            HttpContext.Response.Headers["Content-Type"] = "binary/blittable-json";


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

                    writer.StartWriteObject();
                    writer.WritePropertyName("Results");

                    writer.StartWriteArray();

                    foreach (var document in documentsToWrite)
                    {
                        writer.WriteEmbeddedBlittableDocument(document.Data);
                    }

                    writer.WriteArrayEnd();

                    writer.WritePropertyName("Includes");

                    writer.StartWriteArray();

                    foreach (var include in includes)
                    {
                        writer.WriteEmbeddedBlittableDocument(include.Data);
                    }

                    writer.WriteArrayEnd();

                    writer.WriteObjectEnd();

                    writer.FinalizeDocument();
                }
        }
Esempio n. 11
0
        public void FlatObjectWithEmptyArray()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4))
            {
                using (var builder = new ManualBlittalbeJsonDocumentBuilder <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. 12
0
        private void ToBlittableJsonReaderValue(ManualBlittalbeJsonDocumentBuilder <UnmanagedWriteBuffer> writer, JsValue v, string propertyKey, bool recursiveCall)
        {
            if (v.IsBoolean())
            {
                writer.WriteValue(v.AsBoolean());
                return;
            }

            if (v.IsString())
            {
                const string RavenDataByteArrayToBase64 = "raven-data:byte[];base64,";
                var          valueAsObject = v.ToObject();
                var          value         = valueAsObject?.ToString();
                if (value != null && value.StartsWith(RavenDataByteArrayToBase64))
                {
                    value = value.Remove(0, RavenDataByteArrayToBase64.Length);
                    var byteArray = Convert.FromBase64String(value);
                    writer.WriteValue(Encoding.UTF8.GetString(byteArray));
                    return;
                }
                writer.WriteValue(value);
                return;
            }

            if (v.IsNumber())
            {
                var num = v.AsNumber();

                KeyValuePair <object, JsValue> property;
                if (_propertiesByValue.TryGetValue(propertyKey, out property))
                {
                    var originalValue = property.Key;
                    if (originalValue is float || originalValue is int)
                    {
                        // If the current value is exactly as the original value, we can return the original value before we made the JS conversion,
                        // which will convert a Int64 to jsFloat.
                        var jsValue = property.Value;
                        if (jsValue.IsNumber() && Math.Abs(num - jsValue.AsNumber()) < double.Epsilon)
                        {
                            writer.WriteValue((int)originalValue);
                            return;
                        }

                        //We might have change the type of num from Integer to long in the script by design
                        //Making sure the number isn't a real float before returning it as integer
                        if (originalValue is int &&
                            (Math.Abs(num - Math.Floor(num)) <= double.Epsilon ||
                             Math.Abs(num - Math.Ceiling(num)) <= double.Epsilon))
                        {
                            writer.WriteValue((long)num);
                            return;
                        }
                        writer.WriteValue((float)num);
                        return; //float
                    }
                }

                // If we don't have the type, assume that if the number ending with ".0" it actually an integer.
                var integer = Math.Truncate(num);
                if (Math.Abs(num - integer) < double.Epsilon)
                {
                    writer.WriteValue((long)integer);
                    return;
                }
                writer.WriteValue(num);
                return;
            }
            if (v.IsNull() || v.IsUndefined())
            {
                writer.WriteValueNull();
                return;
            }
            if (v.IsArray())
            {
                var jsArray = v.AsArray();
                writer.StartWriteArray();
                foreach (var property in jsArray.GetOwnProperties())
                {
                    if (InheritedProperties.Contains(property.Key))
                    {
                        continue;
                    }

                    var jsInstance = property.Value.Value;
                    if (!jsInstance.HasValue)
                    {
                        continue;
                    }

                    ToBlittableJsonReaderValue(writer, jsInstance.Value, propertyKey + "[" + property.Key + "]",
                                               recursiveCall);
                }
                writer.WriteArrayEnd();
                return;
            }
            if (v.IsDate())
            {
                writer.WriteValue(v.AsDate().ToDateTime().ToString(Abstractions.Default.DateTimeFormatsToWrite));
                return;
            }
            if (v.IsObject())
            {
                ToBlittableJsonReaderObject(writer, v.AsObject(), propertyKey, recursiveCall);
                return;
            }
            if (v.IsRegExp())
            {
                writer.WriteValueNull();
                return;
            }

            throw new NotSupportedException(v.Type.ToString());
        }
Esempio n. 13
0
        public unsafe void ReadDataTypesTest()
        {
            using (var context = new JsonOperationContext(1024, 1024 * 4))
            {
                BlittableJsonReaderObject embeddedReader;
                using (var builder = new ManualBlittalbeJsonDocumentBuilder <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 ManualBlittalbeJsonDocumentBuilder <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 lsv             = new LazyStringValue(null, b, lsvStringBytes.Length, context);
                        var escapePositions = new List <int>();

                        BlittableWriter <UnmanagedWriteBuffer> .FillBufferWithEscapePositions(lsvString, escapePositions);

                        lsv.EscapePositions = escapePositions.ToArray();

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

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

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

                    var reader = builder.CreateReader();
                    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));
                }
            }
        }