public int GetNextValue(string entity) { lock (_d) { KeyRange kr; if (_d.TryGetValue(entity, out kr)) { kr.Current++; if (kr.Current < kr.Max) { return kr.Current; } _d.Remove(entity); } var res = Db.GetCollection("hilo").FindAndModify( MongoQueryBuilder.DynQuery(x => x._id == entity), SortBy.Ascending("_id"), Update.Inc("cnt", Range), false, true); if (!res.Ok) throw new Exception(res.ErrorMessage); var d = res.ModifiedDocument; kr = new KeyRange(); kr.Current = d.GetValue("cnt", MongoDB.Bson.BsonValue.Create(0)).AsInt32; kr.Max = kr.Current + Range; _d[entity] = kr; return kr.Current; } }
public void TestKeyRangeIntersect14() { var range1 = new KeyRange <string>(Key <string> .CreateKey("a", true), Key <string> .CreatePrefixKey("x")); var range2 = new KeyRange <string>(Key <string> .CreateKey("x", true), null); var expected = new KeyRange <string>(Key <string> .CreateKey("x", true), Key <string> .CreatePrefixKey("x")); Assert.IsFalse(expected.IsEmpty); KeyRangeIntersectionHelper(range1, range2, expected); }
public void TestKeyRangeIntersect13() { var range1 = new KeyRange <int>(Key <int> .CreateKey(8, true), Key <int> .CreateKey(10, true)); var range2 = new KeyRange <int>(Key <int> .CreateKey(10, true), Key <int> .CreateKey(14, true)); var expected = new KeyRange <int>(Key <int> .CreateKey(10, true), Key <int> .CreateKey(10, true)); Assert.IsFalse(expected.IsEmpty); KeyRangeIntersectionHelper(range1, range2, expected); }
public void TestKeyRangeUnion14() { // The prefix matches more records so we want to use it var range1 = new KeyRange <string>(Key <string> .CreateKey("b", false), Key <string> .CreateKey("cc", true)); var range2 = new KeyRange <string>(Key <string> .CreateKey("a", false), Key <string> .CreatePrefixKey("c")); var expected = new KeyRange <string>(Key <string> .CreateKey("a", false), Key <string> .CreatePrefixKey("c")); KeyRangeUnionHelper(range1, range2, expected); }
protected virtual Task <List <Slice> > LoadPartsAsync(IFdbReadOnlyTransaction trans, TId id) { var key = this.Subspace.Keys.EncodePartial(id); return(trans .GetRange(KeyRange.StartsWith(key)) //TODO: options ? .Select(kvp => kvp.Value) .ToListAsync()); }
private void ClearTask(IFdbTransaction tr, Slice taskId) { tr.Annotate("Deleting task {0:P}", taskId); // clear all metadata about the task tr.ClearRange(KeyRange.StartsWith(this.TaskStore.Keys.Encode(taskId))); // decrement pending number of tasks this.Counters.Decrement(tr, COUNTER_PENDING_TASKS); }
/// <summary>Remove all the values for a specific key</summary> /// <param name="trans"></param> /// <param name="key"></param> /// <returns></returns> public void Remove([NotNull] IFdbTransaction trans, TKey key) { if (trans == null) { throw new ArgumentNullException("trans"); } trans.ClearRange(KeyRange.StartsWith(this.Location.Partial.Keys.Encode(key))); }
public void Test_KeyRange_Intersects() { Func <byte, byte, KeyRange> range = (x, y) => KeyRange.Create(Slice.FromByte(x), Slice.FromByte(y)); #region Not Intersecting... // [0, 1) [2, 3) // #X // #X Assert.That(range(0, 1).Intersects(range(2, 3)), Is.False); // [2, 3) [0, 1) // #X // #X Assert.That(range(2, 3).Intersects(range(0, 1)), Is.False); // [0, 1) [1, 2) // #X // #X Assert.That(range(0, 1).Intersects(range(1, 2)), Is.False); // [1, 2) [0, 1) // #X // #X Assert.That(range(1, 2).Intersects(range(0, 1)), Is.False); #endregion #region Intersecting... // [0, 2) [1, 3) // ##X // ##X Assert.That(range(0, 2).Intersects(range(1, 3)), Is.True); // [1, 3) [0, 2) // ##X // ##X Assert.That(range(1, 3).Intersects(range(0, 2)), Is.True); // [0, 1) [0, 2) // #X // ##X Assert.That(range(0, 1).Intersects(range(0, 2)), Is.True); // [0, 2) [0, 1) // ##X // #X Assert.That(range(0, 2).Intersects(range(0, 1)), Is.True); // [0, 2) [1, 2) // ##X // #X Assert.That(range(0, 2).Intersects(range(1, 2)), Is.True); // [1, 2) [0, 2) // #X // ##X Assert.That(range(1, 2).Intersects(range(0, 2)), Is.True); #endregion }
/// <summary>Insert a new document in the collection</summary> public async Task InsertAsync(IFdbTransaction trans, TDocument document) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (document == null) { throw new ArgumentNullException(nameof(document)); } var id = this.IdSelector(document); if (id == null) { throw new InvalidOperationException("Cannot insert a document with a null identifier"); } // encode the document var packed = this.ValueEncoder.EncodeValue(document); var subspace = await this.Location.Resolve(trans); if (subspace == null) { throw new InvalidOperationException($"Location '{this.Location}' referenced by Document Collection Layer was not found."); } // Key Prefix = ...(id,) var key = subspace.EncodePartial(id); // clear previous value trans.ClearRange(KeyRange.StartsWith(key)); int remaining = packed.Count; if (remaining <= this.ChunkSize) { // stored as a single element // Key = ...(id,) trans.Set(key, packed); } else { // splits in as many chunks as necessary // Key = ...(id, N) where N is the chunk index (0-based) int p = 0; int index = 0; while (remaining > 0) { int sz = Math.Max(remaining, this.ChunkSize); trans.Set(subspace[id, index], packed.Substring(p, sz)); ++index; p += sz; remaining -= sz; } } }
public void CreateKeySetFromRanges() { var ranges = KeySet.FromRanges( KeyRange.ClosedOpen(new Key("begin"), new Key("end")), KeyRange.ClosedClosed(new Key(1L), new Key(2L))); Assert.Collection(ranges.Ranges, range => Assert.Equal(KeyRange.ClosedOpen(new Key("begin"), new Key("end")), range), range => Assert.Equal(KeyRange.ClosedClosed(new Key(1L), new Key(2L)), range) ); }
public FdbRangeQuery <TId> Lookup(IFdbReadOnlyTransaction trans, TValue value, bool reverse = false) { var prefix = this.Subspace.Keys.EncodePartial(value); return(trans .GetRange(KeyRange.StartsWith(prefix), new FdbRangeOptions { Reverse = reverse }) .Select((kvp) => this.Subspace.Keys.Decode(kvp.Key).Item2)); }
public void Test_FdbKey_PrettyPrint() { // verify that the pretty printing of keys produce a user friendly output Assert.That(FdbKey.Dump(Slice.Nil), Is.EqualTo("<null>")); Assert.That(FdbKey.Dump(Slice.Empty), Is.EqualTo("<empty>")); Assert.That(FdbKey.Dump(Slice.FromByte(0)), Is.EqualTo("<00>")); Assert.That(FdbKey.Dump(Slice.FromByte(255)), Is.EqualTo("<FF>")); Assert.That(FdbKey.Dump(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 }.AsSlice()), Is.EqualTo("<00><01><02><03><04><05><06><07>")); Assert.That(FdbKey.Dump(new byte[] { 255, 254, 253, 252, 251, 250, 249, 248 }.AsSlice()), Is.EqualTo("<FF><FE><FD><FC><FB><FA><F9><F8>")); Assert.That(FdbKey.Dump(Slice.FromString("hello")), Is.EqualTo("hello")); Assert.That(FdbKey.Dump(Slice.FromString("héllø")), Is.EqualTo("h<C3><A9>ll<C3><B8>")); // tuples should be decoded properly Assert.That(FdbKey.Dump(TuPack.EncodeKey(123)), Is.EqualTo("(123,)"), "Singleton tuples should end with a ','"); Assert.That(FdbKey.Dump(TuPack.EncodeKey(Slice.FromByteString("hello"))), Is.EqualTo("(`hello`,)"), "ASCII strings should use single back quotes"); Assert.That(FdbKey.Dump(TuPack.EncodeKey("héllø")), Is.EqualTo("(\"héllø\",)"), "Unicode strings should use double quotes"); Assert.That(FdbKey.Dump(TuPack.EncodeKey(new byte[] { 1, 2, 3 }.AsSlice())), Is.EqualTo("(`<01><02><03>`,)")); Assert.That(FdbKey.Dump(TuPack.EncodeKey(123, 456)), Is.EqualTo("(123, 456)"), "Elements should be separated with a space, and not end up with ','"); Assert.That(FdbKey.Dump(TuPack.EncodeKey(default(object), true, false)), Is.EqualTo("(null, true, false)"), "Booleans should be displayed as numbers, and null should be in lowercase"); //note: even though it's tempting to using Python's "Nil", it's not very ".NETty" //note: the string representation of double is not identical between NetFx and .NET Core! So we cannot used a constant literal here Assert.That(FdbKey.Dump(TuPack.EncodeKey(1.0d, Math.PI, Math.E)), Is.EqualTo("(1, " + Math.PI.ToString("R", CultureInfo.InvariantCulture) + ", " + Math.E.ToString("R", CultureInfo.InvariantCulture) + ")"), "Doubles should used dot and have full precision (17 digits)"); Assert.That(FdbKey.Dump(TuPack.EncodeKey(1.0f, (float)Math.PI, (float)Math.E)), Is.EqualTo("(1, " + ((float)Math.PI).ToString("R", CultureInfo.InvariantCulture) + ", " + ((float)Math.E).ToString("R", CultureInfo.InvariantCulture) + ")"), "Singles should used dot and have full precision (10 digits)"); var guid = Guid.NewGuid(); Assert.That(FdbKey.Dump(TuPack.EncodeKey(guid)), Is.EqualTo($"({guid:B},)"), "GUIDs should be displayed as a string literal, surrounded by {{...}}, and without quotes"); var uuid128 = Uuid128.NewUuid(); Assert.That(FdbKey.Dump(TuPack.EncodeKey(uuid128)), Is.EqualTo($"({uuid128:B},)"), "Uuid128s should be displayed as a string literal, surrounded by {{...}}, and without quotes"); var uuid64 = Uuid64.NewUuid(); Assert.That(FdbKey.Dump(TuPack.EncodeKey(uuid64)), Is.EqualTo($"({uuid64:B},)"), "Uuid64s should be displayed as a string literal, surrounded by {{...}}, and without quotes"); // ranges should be decoded when possible var key = TuPack.ToRange(STuple.Create("hello")); // "<02>hello<00><00>" .. "<02>hello<00><FF>" Assert.That(FdbKey.PrettyPrint(key.Begin, FdbKey.PrettyPrintMode.Begin), Is.EqualTo("(\"hello\",).<00>")); Assert.That(FdbKey.PrettyPrint(key.End, FdbKey.PrettyPrintMode.End), Is.EqualTo("(\"hello\",).<FF>")); key = KeyRange.StartsWith(TuPack.EncodeKey("hello")); // "<02>hello<00>" .. "<02>hello<01>" Assert.That(FdbKey.PrettyPrint(key.Begin, FdbKey.PrettyPrintMode.Begin), Is.EqualTo("(\"hello\",)")); Assert.That(FdbKey.PrettyPrint(key.End, FdbKey.PrettyPrintMode.End), Is.EqualTo("(\"hello\",) + 1")); var t = TuPack.EncodeKey(123); Assert.That(FdbKey.PrettyPrint(t, FdbKey.PrettyPrintMode.Single), Is.EqualTo("(123,)")); Assert.That(FdbKey.PrettyPrint(TuPack.ToRange(t).Begin, FdbKey.PrettyPrintMode.Begin), Is.EqualTo("(123,).<00>")); Assert.That(FdbKey.PrettyPrint(TuPack.ToRange(t).End, FdbKey.PrettyPrintMode.End), Is.EqualTo("(123,).<FF>")); }
public void Test_FdbKey_PrettyPrint() { // verify that the pretty printing of keys produce a user friendly output Assert.That(FdbKey.Dump(Slice.Nil), Is.EqualTo("<null>")); Assert.That(FdbKey.Dump(Slice.Empty), Is.EqualTo("<empty>")); Assert.That(FdbKey.Dump(Slice.FromByte(0)), Is.EqualTo("<00>")); Assert.That(FdbKey.Dump(Slice.FromByte(255)), Is.EqualTo("<FF>")); Assert.That(FdbKey.Dump(Slice.Create(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 })), Is.EqualTo("<00><01><02><03><04><05><06><07>")); Assert.That(FdbKey.Dump(Slice.Create(new byte[] { 255, 254, 253, 252, 251, 250, 249, 248 })), Is.EqualTo("<FF><FE><FD><FC><FB><FA><F9><F8>")); Assert.That(FdbKey.Dump(Slice.FromString("hello")), Is.EqualTo("hello")); Assert.That(FdbKey.Dump(Slice.FromString("héllø")), Is.EqualTo("h<C3><A9>ll<C3><B8>")); // tuples should be decoded properly Assert.That(FdbKey.Dump(STuple.EncodeKey(123)), Is.EqualTo("(123,)"), "Singleton tuples should end with a ','"); Assert.That(FdbKey.Dump(STuple.EncodeKey(Slice.FromAscii("hello"))), Is.EqualTo("('hello',)"), "ASCII strings should use single quotes"); Assert.That(FdbKey.Dump(STuple.EncodeKey("héllø")), Is.EqualTo("(\"héllø\",)"), "Unicode strings should use double quotes"); Assert.That(FdbKey.Dump(STuple.EncodeKey(Slice.Create(new byte[] { 1, 2, 3 }))), Is.EqualTo("(<01 02 03>,)")); Assert.That(FdbKey.Dump(STuple.EncodeKey(123, 456)), Is.EqualTo("(123, 456)"), "Elements should be separated with a space, and not end up with ','"); Assert.That(FdbKey.Dump(STuple.EncodeKey(true, false, default(object))), Is.EqualTo("(1, 0, null)"), "Booleans should be displayed as numbers, and null should be in lowercase"); //note: even though it's tempting to using Python's "Nil", it's not very ".NETty" Assert.That(FdbKey.Dump(STuple.EncodeKey(1.0d, Math.PI, Math.E)), Is.EqualTo("(1, 3.1415926535897931, 2.7182818284590451)"), "Doubles should used dot and have full precision (17 digits)"); Assert.That(FdbKey.Dump(STuple.EncodeKey(1.0f, (float)Math.PI, (float)Math.E)), Is.EqualTo("(1, 3.14159274, 2.71828175)"), "Singles should used dot and have full precision (10 digits)"); var guid = Guid.NewGuid(); Assert.That(FdbKey.Dump(STuple.EncodeKey(guid)), Is.EqualTo(String.Format("({0},)", guid.ToString("B"))), "GUIDs should be displayed as a string literal, surrounded by {...}, and without quotes"); var uuid128 = Uuid128.NewUuid(); Assert.That(FdbKey.Dump(STuple.EncodeKey(uuid128)), Is.EqualTo(String.Format("({0},)", uuid128.ToString("B"))), "Uuid128s should be displayed as a string literal, surrounded by {...}, and without quotes"); var uuid64 = Uuid64.NewUuid(); Assert.That(FdbKey.Dump(STuple.EncodeKey(uuid64)), Is.EqualTo(String.Format("({0},)", uuid64.ToString("B"))), "Uuid64s should be displayed as a string literal, surrounded by {...}, and without quotes"); // ranges should be decoded when possible var key = STuple.ToRange(STuple.Create("hello")); // "<02>hello<00><00>" .. "<02>hello<00><FF>" Assert.That(FdbKey.PrettyPrint(key.Begin, FdbKey.PrettyPrintMode.Begin), Is.EqualTo("(\"hello\",).<00>")); Assert.That(FdbKey.PrettyPrint(key.End, FdbKey.PrettyPrintMode.End), Is.EqualTo("(\"hello\",).<FF>")); key = KeyRange.StartsWith(STuple.EncodeKey("hello")); // "<02>hello<00>" .. "<02>hello<01>" Assert.That(FdbKey.PrettyPrint(key.Begin, FdbKey.PrettyPrintMode.Begin), Is.EqualTo("(\"hello\",)")); Assert.That(FdbKey.PrettyPrint(key.End, FdbKey.PrettyPrintMode.End), Is.EqualTo("(\"hello\",) + 1")); var t = STuple.EncodeKey(123); Assert.That(FdbKey.PrettyPrint(t, FdbKey.PrettyPrintMode.Single), Is.EqualTo("(123,)")); Assert.That(FdbKey.PrettyPrint(STuple.ToRange(t).Begin, FdbKey.PrettyPrintMode.Begin), Is.EqualTo("(123,).<00>")); Assert.That(FdbKey.PrettyPrint(STuple.ToRange(t).End, FdbKey.PrettyPrintMode.End), Is.EqualTo("(123,).<FF>")); }
/// <summary>Delete a document from the collection</summary> /// <param name="trans"></param> /// <param name="ids"></param> public void DeleteMultiple(IFdbTransaction trans, IEnumerable<TId> ids) { if (trans == null) throw new ArgumentNullException(nameof(trans)); if (ids == null) throw new ArgumentNullException(nameof(ids)); foreach (var id in ids) { var key = this.Subspace.Keys.EncodePartial(id); trans.ClearRange(KeyRange.StartsWith(key)); } }
public void TestKeyRangeToStringExclusive() { var keyrange = new KeyRange <int>(Key <int> .CreateKey(1, false), Key <int> .CreateKey(2, false)); string s = keyrange.ToString(); Assert.IsNotNull(s); Assert.AreNotEqual(s, String.Empty); StringAssert.Contains(s, "1"); StringAssert.Contains(s, "2"); StringAssert.Contains(s, "exclusive"); }
public List <byte[]> GetKeys(byte[] startKey, int count) { var keyRange = new KeyRange { StartKey = startKey ?? new byte[0], EndKey = new byte[0], Count = count }; var aquilesSlicePredicate = new SlicePredicate(new List <byte[]>()); var getKeyRangeSliceCommand = new GetKeyRangeSliceCommand(keyspaceName, columnFamilyName, readConsistencyLevel, keyRange, aquilesSlicePredicate); commandExecutor.Execute(getKeyRangeSliceCommand); return(getKeyRangeSliceCommand.Output); }
public void TestKeyRangeToStringInclusive() { var keyrange = new KeyRange <int>(Key <int> .CreateKey(3, true), Key <int> .CreateKey(4, true)); string s = keyrange.ToString(); Assert.IsNotNull(s); Assert.AreNotEqual(s, String.Empty); StringAssert.Contains(s, "3"); StringAssert.Contains(s, "4"); StringAssert.Contains(s, "inclusive"); }
public void TestKeyRangeToStringPrefix() { var keyrange = new KeyRange <string>(Key <string> .CreateKey("3", true), Key <string> .CreatePrefixKey("4")); string s = keyrange.ToString(); Assert.IsNotNull(s); Assert.AreNotEqual(s, String.Empty); StringAssert.Contains(s, "3"); StringAssert.Contains(s, "4"); StringAssert.Contains(s, "prefix"); }
public IAsyncEnumerable <(TValue Value, long Count)> GetCounts([NotNull] IFdbReadOnlyTransaction trans, TKey key) { var range = KeyRange.StartsWith(this.Subspace.Keys.EncodePartial(key)); var query = trans .GetRange(range) .Select(kvp => (Value: this.Subspace.Keys.Decode(kvp.Key).Item2, Count: kvp.Value.ToInt64())); return(this.AllowNegativeValues ? query : query.Where(x => x.Count > 0)); }
public IEnumerable <string> ProduceKey(KeyRange keyRange) { var key = new List <string>(); for (int number = keyRange.KeyStart; number <= keyRange.KeyStop; number++) { var checkResult = CheckNumber(number); key.Add(!string.IsNullOrEmpty(checkResult) ? checkResult : number.ToString()); } return(key); }
internal static Apache.Cassandra.KeyRange ToCassandraKeyRange(this KeyRange keyRange) { if (keyRange == null) { return(null); } return(new Apache.Cassandra.KeyRange { Count = keyRange.Count, Start_key = keyRange.StartKey ?? new byte[0], End_key = keyRange.EndKey ?? new byte[0] }); }
public static IEnumerable <KeyRange> Create(IEnumerable <string> keys, IEnumerable <double> values, IEnumerable <double> mins, IEnumerable <double> maxs) { using (var b = keys.GetEnumerator()) using (var c = values.GetEnumerator()) using (var d = mins?.GetEnumerator()) using (var e = maxs?.GetEnumerator()) { while (b.MoveNext() && c.MoveNext() && (bool)(d?.MoveNext() ?? true) && (bool)(e?.MoveNext() ?? true)) { var ff = new KeyRange(b.Current, c.Current, d?.Current, e?.Current); yield return(ff); } } }
/// <summary> /// Determine if the given range matches at least the records described /// by the min/max values. /// </summary> /// <param name="keyRange">The key range.</param> /// <param name="min">The minimum value.</param> /// <param name="max">The maximum value.</param> /// <returns>True if the KeyRange is a superset of the values.</returns> private static bool KeyRangeIsSufficient(KeyRange <int> keyRange, int min, int max) { bool minIsSufficient = (null == keyRange.Min) || (keyRange.Min.Value == min && keyRange.Min.IsInclusive) || keyRange.Min.Value < min; bool maxIsSufficient = (null == keyRange.Max) || (keyRange.Max.Value == max && keyRange.Max.IsInclusive) || keyRange.Max.Value > max; return(minIsSufficient && maxIsSufficient); }
public ConvertTransform(IHostEnvironment env, Arguments args, IDataView input) : base(env, RegistrationName, env.CheckRef(args, nameof(args)).Column, input, null) { Host.AssertNonEmpty(Infos); Host.Assert(Infos.Length == Utils.Size(args.Column)); _exes = new ColInfoEx[Infos.Length]; for (int i = 0; i < _exes.Length; i++) { DataKind kind; KeyRange range; var col = args.Column[i]; if (col.ResultType != null) { kind = col.ResultType.Value; range = !string.IsNullOrEmpty(col.Range) ? KeyRange.Parse(col.Range) : col.KeyRange; } else if (col.KeyRange != null || !string.IsNullOrEmpty(col.Range)) { kind = Infos[i].TypeSrc.IsKey ? Infos[i].TypeSrc.RawKind : DataKind.U4; range = col.KeyRange ?? KeyRange.Parse(col.Range); } else if (args.ResultType != null) { kind = args.ResultType.Value; range = !string.IsNullOrEmpty(args.Range) ? KeyRange.Parse(args.Range) : args.KeyRange; } else if (args.KeyRange != null || !string.IsNullOrEmpty(args.Range)) { kind = Infos[i].TypeSrc.IsKey ? Infos[i].TypeSrc.RawKind : DataKind.U4; range = args.KeyRange ?? KeyRange.Parse(args.Range); } else { kind = DataKind.Num; range = null; } Host.CheckUserArg(Enum.IsDefined(typeof(DataKind), kind), nameof(args.ResultType)); PrimitiveType itemType; if (!TryCreateEx(Host, Infos[i], kind, range, out itemType, out _exes[i])) { throw Host.ExceptUserArg(nameof(args.Column), "source column '{0}' with item type '{1}' is not compatible with destination type '{2}'", input.Schema.GetColumnName(Infos[i].Source), Infos[i].TypeSrc.ItemType, itemType); } } SetMetadata(); }
/// <summary>Remove all fields of an hashset</summary> /// <param name="id"></param> public void Delete(IFdbTransaction trans, IVarTuple id) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (id == null) { throw new ArgumentNullException(nameof(id)); } // remove all fields of the hash trans.ClearRange(KeyRange.StartsWith(GetKey(id))); }
/// <summary> /// Run a test with one randomly generated expression tree. /// </summary> /// <param name="rangeWasEmpty">True if an empty range was generated.</param> /// <param name="rangeWasExact"> /// True if the generated range matched the given maximums and minimums exactly. /// </param> private void DoOneTest(out bool rangeWasEmpty, out bool rangeWasExact) { // Unfortunately this generates a Func<KeyValuePair<int, int>, bool> instead // of a Predicate<KeyValuePair<int, int>. We work around that by calling // PredicateExpressionEvaluator directly. Expression <Func <KeyValuePair <int, int>, bool> > expression = this.CreateExpression(); Func <KeyValuePair <int, int>, bool> func = expression.Compile(); // This is the test Oracle: we create the KeyValuePairs and see which ones // are matched by the expression. int min = MinValue; int max = MaxValue; int count = 0; for (int i = MinValue; i < MaxValue; ++i) { KeyValuePair <int, int> kvp = new KeyValuePair <int, int>(i, i); if (func(kvp)) { if (count++ == 0) { min = kvp.Key; } max = kvp.Key; } } KeyRange <int> keyRange = PredicateExpressionEvaluator <int> .GetKeyRange(expression.Body, keyMemberInfo); if (count > 0) { Assert.IsTrue( KeyRangeIsSufficient(keyRange, min, max), "KeyRange is too small. Expression: {0}, Min = {1}, Max = {2}, Got {3}", expression, min, max, keyRange); rangeWasExact = KeyRangeIsExact(keyRange, min, max); rangeWasEmpty = false; } else { rangeWasExact = keyRange.IsEmpty; rangeWasEmpty = true; } }
/// <summary>Insert a new document in the collection</summary> public void Insert(IFdbTransaction trans, TDocument document) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (document == null) { throw new ArgumentNullException(nameof(document)); } var id = this.IdSelector(document); if (id == null) { throw new InvalidOperationException("Cannot insert a document with a null identifier"); } // encode the document var packed = this.ValueEncoder.EncodeValue(document); // Key Prefix = ...(id,) var key = this.Location.Partial.Keys.Encode(id); // clear previous value trans.ClearRange(KeyRange.StartsWith(key)); int remaining = packed.Count; if (remaining <= this.ChunkSize) { // stored as a single element // Key = ...(id,) trans.Set(key, packed); } else { // splits in as many chunks as necessary // Key = ...(id, N) where N is the chunk index (0-based) int p = 0; int index = 0; while (remaining > 0) { int sz = Math.Max(remaining, this.ChunkSize); trans.Set(this.Location.Keys.Encode(id, index), packed.Substring(p, sz)); ++index; p += sz; remaining -= sz; } } }
/// <summary>Delete a document from the collection</summary> /// <param name="trans"></param> /// <param name="id"></param> public void Delete(IFdbTransaction trans, TId id) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (id == null) { throw new ArgumentNullException(nameof(id)); } var key = this.Location.Partial.Keys.Encode(id); trans.ClearRange(KeyRange.StartsWith(key)); }
/// <summary> /// Optimized insert of presorted key/value pairs. /// If the input is not presorted, please use AddRange() instead. /// </summary> /// <param name="items">The ordered list of items to insert</param> /// <param name="allowUpdates">True to overwrite any existing records</param> /// <returns>The total number of records inserted or updated</returns> public int AddRangeSorted(IEnumerable <KeyValuePair <TKey, TValue> > items, bool allowUpdates) { int result = 0; using (AddRangeInfo bulk = new AddRangeInfo(allowUpdates, items)) { while (!bulk.IsComplete) { KeyRange range = new KeyRange(_keyComparer); using (RootLock root = LockRoot(LockType.Insert, "BulkInsert")) result += AddRange(root.Pin, ref range, bulk, null, int.MinValue); } } DebugComplete("AddRange({0} records)", result); return(result); }
/// <summary>Delete a document from the collection</summary> /// <param name="trans"></param> /// <param name="ids"></param> public void DeleteMultiple(IFdbTransaction trans, IEnumerable <TId> ids) { if (trans == null) { throw new ArgumentNullException(nameof(trans)); } if (ids == null) { throw new ArgumentNullException(nameof(ids)); } foreach (var key in this.Location.Partial.Keys.Encode(ids)) { trans.ClearRange(KeyRange.StartsWith(key)); } }
private ConvertTransform(IHost host, ModelLoadContext ctx, IDataView input) : base(host, ctx, input, null) { Host.AssertValue(ctx); // *** Binary format *** // <prefix handled in static Create method> // <base> // for each added column // byte: data kind, with high bit set if there is a key range // if there is a key range // ulong: min // int: count (0 for unspecified) // byte: contiguous Host.AssertNonEmpty(Infos); _exes = new ColInfoEx[Infos.Length]; for (int i = 0; i < _exes.Length; i++) { byte b = ctx.Reader.ReadByte(); var kind = (DataKind)(b & 0x7F); Host.CheckDecode(Enum.IsDefined(typeof(DataKind), kind)); KeyRange range = null; if ((b & 0x80) != 0) { range = new KeyRange(); range.Min = ctx.Reader.ReadUInt64(); int count = ctx.Reader.ReadInt32(); if (count != 0) { if (count < 0 || (ulong)(count - 1) > ulong.MaxValue - range.Min) { throw Host.ExceptDecode(); } range.Max = range.Min + (ulong)(count - 1); } range.Contiguous = ctx.Reader.ReadBoolByte(); } PrimitiveType itemType; if (!TryCreateEx(Host, Infos[i], kind, range, out itemType, out _exes[i])) { throw Host.ExceptParam(nameof(input), "source column '{0}' is not of compatible type", input.Schema.GetColumnName(Infos[i].Source)); } } SetMetadata(); }
public void TestSample12() { Expression<Predicate<int>> expression = x => x >= -1 && x < 101; KeyRange<int> actual = PredicateExpressionEvaluator<int>.GetKeyRange(expression.Body, null); KeyRange<int> expected = new KeyRange<int>(Key<int>.CreateKey(-1, true), Key<int>.CreateKey(101, false)); Assert.AreEqual(expected, actual); }
public void TestStringStartsWithIntersection() { string s = "baz"; KeyRange<string> actual = KeyValueExpressionEvaluator<string, string>.GetKeyRange(x => x.Key.StartsWith(s) && x.Key.CompareTo("z") < 0); var expected = new KeyRange<string>(Key<string>.CreateKey(s, true), Key<string>.CreatePrefixKey(s)); Assert.AreEqual(expected, actual); }
public void TestNullDateTimeExpression() { DateTime? min = null; Func<DateTime?> fmax = () => DateTime.MaxValue; var expected = new KeyRange<DateTime>(null, Key<DateTime>.CreateKey(DateTime.MaxValue, false)); var actual = KeyValueExpressionEvaluator<DateTime, string>.GetKeyRange(x => min <= x.Key && x.Key < fmax()); Assert.AreEqual(expected, actual); }
public void VerifyDeMorgansForAnd() { // This should be the same as (x.Key > 11 || x.Key > 22) KeyRange<int> actual = KeyValueExpressionEvaluator<int, string>.GetKeyRange(x => !(x.Key <= 11 && x.Key <= 22)); KeyRange<int> expected = new KeyRange<int>(Key<int>.CreateKey(11, false), null); Assert.AreEqual(expected, actual); }
public void VerifyNotOfGeGivesLt() { KeyRange<int> actual = KeyValueExpressionEvaluator<int, string>.GetKeyRange(x => !(x.Key >= 4)); KeyRange<int> expected = new KeyRange<int>(null, Key<int>.CreateKey(4, false)); }
public void TestNullableGuidExpression() { Func<Guid?> f = () => Guid.Empty; var expected = new KeyRange<Guid>(Key<Guid>.CreateKey(Guid.Empty, true), Key<Guid>.CreateKey(Guid.Empty, true)); var actual = KeyValueExpressionEvaluator<Guid, string>.GetKeyRange(x => x.Key == f()); Assert.AreEqual(expected, actual); }
/// <summary> /// Determine if the given range matches at least the records described /// by the min/max values. /// </summary> /// <param name="keyRange">The key range.</param> /// <param name="min">The minimum value.</param> /// <param name="max">The maximum value.</param> /// <returns>True if the KeyRange is a superset of the values.</returns> private static bool KeyRangeIsSufficient(KeyRange<int> keyRange, int min, int max) { bool minIsSufficient = (null == keyRange.Min) || (keyRange.Min.Value == min && keyRange.Min.IsInclusive) || keyRange.Min.Value < min; bool maxIsSufficient = (null == keyRange.Max) || (keyRange.Max.Value == max && keyRange.Max.IsInclusive) || keyRange.Max.Value > max; return minIsSufficient && maxIsSufficient; }
public void TestNullableUShortExpression() { ushort? min = 1; Func<ushort?> fmax = () => 8; var expected = new KeyRange<ushort>(Key<ushort>.CreateKey(1, true), Key<ushort>.CreateKey(8, false)); var actual = KeyValueExpressionEvaluator<ushort, string>.GetKeyRange(x => min <= x.Key && x.Key < fmax()); Assert.AreEqual(expected, actual, "ushort to int? promotion not supported"); }
public void TestNullableDoubleExpression() { double? min = 1; Func<double?> fmax = () => 8; var expected = new KeyRange<double>(Key<double>.CreateKey(1, true), Key<double>.CreateKey(8, false)); var actual = KeyValueExpressionEvaluator<double, string>.GetKeyRange(x => min <= x.Key && x.Key < fmax()); Assert.AreEqual(expected, actual); }
public void TestSample11() { // Regression test for: // Assert.IsTrue failed. // Error at entry 0. Not enough entries in actual. // First missing entry is [ggi, ggi] // expression = x => ((Compare("ggi", x.Key) <= 0) && (x.Key.Equals("f*g") || x.Key.StartsWith("g"))) KeyRange<string> actual = KeyValueExpressionEvaluator<string, string>.GetKeyRange( x => ((String.Compare("ggi", x.Key) <= 0) && (x.Key.Equals("f*g") || x.Key.StartsWith("g")))); KeyRange<string> expected = new KeyRange<string>( Key<string>.CreateKey("ggi", true), Key<string>.CreatePrefixKey("g")); Assert.AreEqual(expected, actual); Assert.IsFalse(actual.IsEmpty); }
public void TestSample10() { // Regression test for: // Assert.IsTrue failed. // Error at entry 21. Not enough entries in actual. // First missing entry is [ibh, ibh] // expression = x => (x.Key.StartsWith("i") || (x.Key.Equals("ibg") || ("f" = x.Key))) KeyRange<string> actual = KeyValueExpressionEvaluator<string, string>.GetKeyRange( x => (x.Key.StartsWith("i") || (x.Key.Equals("ibg") || ("f" == x.Key)))); KeyRange<string> expected = new KeyRange<string>(Key<string>.CreateKey("f", true), Key<string>.CreatePrefixKey("i")); Assert.AreEqual(expected, actual); }
public void TestSample9() { // Regression test for: // KeyRange is too small. // Expression: // x => Not(((2137 >= x.Key) && Not((-3611 = x.Key)))) KeyRange<int> actual = KeyValueExpressionEvaluator<int, int>.GetKeyRange( x => !((2137 >= x.Key) && !(-3611 == x.Key))); KeyRange<int> expected = new KeyRange<int>(Key<int>.CreateKey(-3611, true), null); Assert.AreEqual(expected, actual); }
public void TestSample5() { DateTime? date = DateTime.UtcNow; TimeSpan? timespan = TimeSpan.FromDays(90); KeyRange<DateTime> actual = KeyValueExpressionEvaluator<DateTime, string>.GetKeyRange(d => d.Key >= date && d.Key <= date + timespan); KeyRange<DateTime> expected = new KeyRange<DateTime>(Key<DateTime>.CreateKey(date.Value, true), Key<DateTime>.CreateKey(date.Value + timespan.Value, true)); Assert.AreEqual(expected, actual); }
public void TestEquals() { var expected = new KeyRange<long>(Key<long>.CreateKey(10, true), Key<long>.CreateKey(10, true)); var actual = KeyValueExpressionEvaluator<long, string>.GetKeyRange(x => x.Key.Equals(10)); Assert.AreEqual(expected, actual); }
public void TestIntNullableLongExpression() { long? min = 1; Func<long?> fmax = () => 8; var expected = new KeyRange<int>(Key<int>.CreateKey(1, true), Key<int>.CreateKey(8, false)); var actual = KeyValueExpressionEvaluator<int, string>.GetKeyRange(x => min <= x.Key && x.Key < fmax()); Assert.AreEqual(expected, actual); }
public void TestSample13() { string s = "foo"; Expression<Predicate<int>> expression = x => x > -1 && s.Length < 101; KeyRange<int> actual = PredicateExpressionEvaluator<int>.GetKeyRange(expression.Body, null); KeyRange<int> expected = new KeyRange<int>(Key<int>.CreateKey(-1, false), null); Assert.AreEqual(expected, actual); }
/// <summary> /// Common test for constant folding tests. /// </summary> /// <param name="expression"> /// An expression which should come out to x.Key LE 32 /// </param> private static void ConstantFoldingHelper(Expression<Predicate<KeyValuePair<int, long>>> expression) { KeyRange<int> actual = KeyValueExpressionEvaluator<int, long>.GetKeyRange(expression); KeyRange<int> expected = new KeyRange<int>(null, Key<int>.CreateKey(32, true)); Assert.AreEqual(expected, actual); }
public void VerifyStaticMethodCallAccessIsOptimized() { var expected = new KeyRange<int>(null, Key<int>.CreateKey(8, false)); var actual = KeyValueExpressionEvaluator<int, string>.GetKeyRange( x => x.Key < Math.Min(8, 9)); Assert.AreEqual(expected, actual); }
public void TestNullIntExpression() { int? min = 1; Func<int?> fmax = () => null; var expected = new KeyRange<int>(Key<int>.CreateKey(1, true), null); var actual = KeyValueExpressionEvaluator<int, string>.GetKeyRange(x => min <= x.Key && x.Key < fmax()); Assert.AreEqual(expected, actual); }
public void VerifyComparisonWithComplexNullable() { int? min = -99; int? max = 1; KeyRange<int> actual = KeyValueExpressionEvaluator<int, string>.GetKeyRange(x => min < x.Key && x.Key < max + 8); KeyRange<int> expected = new KeyRange<int>(Key<int>.CreateKey(-99, false), Key<int>.CreateKey(9, false)); Assert.AreEqual(expected, actual); }
public void TestNullableBoolExpression() { Func<bool?> f = () => false; var expected = new KeyRange<bool>(Key<bool>.CreateKey(false, true), Key<bool>.CreateKey(false, true)); var actual = KeyValueExpressionEvaluator<bool, string>.GetKeyRange(x => x.Key == f()); Assert.AreEqual(expected, actual); }
public void VerifyNotOfNe() { KeyRange<int> actual = KeyValueExpressionEvaluator<int, string>.GetKeyRange(x => !(x.Key != 3)); KeyRange<int> expected = new KeyRange<int>(Key<int>.CreateKey(3, true), Key<int>.CreateKey(3, true)); Assert.AreEqual(expected, actual); }
public void TestStringStartsWithUnion() { KeyRange<string> actual = KeyValueExpressionEvaluator<string, string>.GetKeyRange( x => x.Key.StartsWith("b") || (x.Key.CompareTo("a") > 0 && x.Key.CompareTo("b") <= 0)); var expected = new KeyRange<string>(Key<string>.CreateKey("a", false), Key<string>.CreatePrefixKey("b")); Assert.AreEqual(expected, actual); }
public void TestNullableTimeSpanExpression() { TimeSpan? min = TimeSpan.MinValue; Func<TimeSpan?> fmax = () => TimeSpan.MaxValue; var expected = new KeyRange<TimeSpan>(Key<TimeSpan>.CreateKey(TimeSpan.MinValue, true), Key<TimeSpan>.CreateKey(TimeSpan.MaxValue, false)); var actual = KeyValueExpressionEvaluator<TimeSpan, string>.GetKeyRange(x => min <= x.Key && x.Key < fmax()); Assert.AreEqual(expected, actual); }
/// <summary> /// Determine if the given range matches the given min/max values exactly. /// </summary> /// <param name="keyRange">The key range.</param> /// <param name="min">The minimum value.</param> /// <param name="max">The maximum value.</param> /// <returns>True if the KeyRange is an exact match.</returns> private static bool KeyRangeIsExact(KeyRange<int> keyRange, int min, int max) { bool minIsCorrect = (null != keyRange.Min) && ((keyRange.Min.Value == min && keyRange.Min.IsInclusive) || (keyRange.Min.Value == min - 1 && !keyRange.Min.IsInclusive)); bool maxIsCorrect = (null != keyRange.Max) && ((keyRange.Max.Value == max && keyRange.Max.IsInclusive) || (keyRange.Max.Value == max + 1 && !keyRange.Max.IsInclusive)); if (!minIsCorrect && MinValue == min && null == keyRange.Min) { // No min value is correct if we start at the minimum value minIsCorrect = true; } if (!maxIsCorrect && MaxValue - 1 == max && null == keyRange.Max) { // No max value is correct if we end at the maximum value maxIsCorrect = true; } return minIsCorrect && maxIsCorrect; }
public void TestStringStaticEqualsReversed() { KeyRange<string> actual = KeyValueExpressionEvaluator<string, string>.GetKeyRange(x => String.Equals("baz", x.Key)); var expected = new KeyRange<string>(Key<string>.CreateKey("baz", true), Key<string>.CreateKey("baz", true)); Assert.AreEqual(expected, actual); }