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 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 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);
 }

        /// <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 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 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);
 }

 /// <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 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 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);
 }

 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 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 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 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 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 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 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("fag") || x.Key.StartsWith("g")))
     KeyRange<string> actual =
         KeyValueExpressionEvaluator<string, string>.GetKeyRange(
             x => ((String.Compare("ggi", x.Key) <= 0) && (x.Key.Equals("fag") || 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 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);
 }

 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);
 }

 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 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);
 }