public void SkipAndTakeShouldSkipAndTake()
 {
     var runner = new DictionaryQueryRunner(SkipTakeSource(), new SkipClause(1), new TakeClause(1));
     var actual = runner.Run().ToList();
     Assert.AreEqual(1, actual.Count);
     Assert.AreEqual(1, actual[0]["Row"]);
 }
 public void ShouldNotRemoveDistinctRows()
 {
     var runner = new DictionaryQueryRunner(NonDuplicatingSource(), new DistinctClause());
     var actual = runner.Run().ToList();
     Assert.AreEqual(2, actual.Count);
     Assert.AreEqual(1, actual.Count(d => d.ContainsKey("Foo") && (string)d["Foo"] == "bar"));
     Assert.AreEqual(1, actual.Count(d => d.ContainsKey("Quux") && (string)d["Quux"] == "baz"));
 }
        public void SkipAndTakeShouldSkipAndTake()
        {
            var runner = new DictionaryQueryRunner(SkipTakeSource(), new SkipClause(1), new TakeClause(1));
            var actual = runner.Run().ToList();

            Assert.AreEqual(1, actual.Count);
            Assert.AreEqual(1, actual[0]["Row"]);
        }
 public void TakeShouldTake()
 {
     var runner = new DictionaryQueryRunner("FooTable", SkipTakeSource(), new TakeClause(2));
     var actual = runner.Run().ToList();
     Assert.AreEqual(2, actual.Count);
     Assert.AreEqual(0, actual[0]["Row"]);
     Assert.AreEqual(1, actual[1]["Row"]);
 }
 public void SkipAndTakeWithCountShouldSkipAndTakeAndGiveCount()
 {
     int count = 0;
     var runner = new DictionaryQueryRunner(SkipTakeSource(), new WithCountClause(n => count = n), new SkipClause(1), new TakeClause(1));
     var actual = runner.Run().ToList();
     Assert.AreEqual(3, count);
     Assert.AreEqual(1, actual.Count);
     Assert.AreEqual(1, actual[0]["Row"]);
 }
        public void ShouldNotRemoveDistinctRows()
        {
            var runner = new DictionaryQueryRunner(NonDuplicatingSource(), new DistinctClause());
            var actual = runner.Run().ToList();

            Assert.AreEqual(2, actual.Count);
            Assert.AreEqual(1, actual.Count(d => d.ContainsKey("Foo") && (string)d["Foo"] == "bar"));
            Assert.AreEqual(1, actual.Count(d => d.ContainsKey("Quux") && (string)d["Quux"] == "baz"));
        }
Exemple #7
0
        public void TakeShouldTake()
        {
            var runner = new DictionaryQueryRunner("FooTable", SkipTakeSource(), new TakeClause(2));
            var actual = runner.Run().ToList();

            Assert.AreEqual(2, actual.Count);
            Assert.AreEqual(0, actual[0]["Row"]);
            Assert.AreEqual(1, actual[1]["Row"]);
        }
        public void BasicWhereNotEqualShouldWork()
        {
            var tableRef    = new ObjectReference("FooTable");
            var whereClause = new WhereClause(new ObjectReference("Name", tableRef) != "Alice");
            var runner      = new DictionaryQueryRunner(SelectSource(), whereClause);
            var actual      = runner.Run().ToList();

            Assert.AreEqual(3, actual.Count);
            Assert.False(actual.Any(a => (string)a["Name"] == "Alice"));
        }
        public void BasicWhereLessThanOrEqualShouldWork()
        {
            var tableRef    = new ObjectReference("FooTable");
            var whereClause = new WhereClause(new ObjectReference("Weight", tableRef) <= 100M);
            var runner      = new DictionaryQueryRunner(SelectSource(), whereClause);
            var actual      = runner.Run().ToList();

            Assert.AreEqual(1, actual.Count);
            Assert.AreEqual("Alice", actual[0]["Name"]);
        }
        public void SkipAndTakeWithCountShouldSkipAndTakeAndGiveCount()
        {
            int count  = 0;
            var runner = new DictionaryQueryRunner(SkipTakeSource(), new WithCountClause(n => count = n), new SkipClause(1), new TakeClause(1));
            var actual = runner.Run().ToList();

            Assert.AreEqual(3, count);
            Assert.AreEqual(1, actual.Count);
            Assert.AreEqual(1, actual[0]["Row"]);
        }
        public void BasicLikeShouldWork()
        {
            var     tableRef    = new ObjectReference("FooTable");
            dynamic objRef      = new ObjectReference("Name", tableRef);
            var     expression  = new SimpleExpression(objRef, new SimpleFunction("like", new[] { "A%" }), SimpleExpressionType.Function);
            var     whereClause = new WhereClause(expression);
            var     runner      = new DictionaryQueryRunner(SelectSource(), whereClause);
            var     actual      = runner.Run().ToList();

            Assert.AreEqual(1, actual.Count);
            Assert.AreEqual("Alice", actual[0]["Name"]);
        }
Exemple #12
0
        protected IEnumerable <dynamic> Run()
        {
            IEnumerable <SimpleQueryClauseBase> unhandledClauses;
            var result = _dataStrategy.Run.RunQuery(this, out unhandledClauses);

            if (unhandledClauses != null)
            {
                var unhandledClausesList = unhandledClauses.ToList();
                if (unhandledClausesList.Count > 0)
                {
                    result = new DictionaryQueryRunner(_tableName, result, unhandledClausesList).Run();
                }
            }

            return(SimpleResultSet.Create(result, _tableName, _dataStrategy).Cast <dynamic>());
        }
 public void SelectShouldRestrictColumnList()
 {
     var tableRef = new ObjectReference("FooTable");
     var selectClause = new SelectClause(new SimpleReference[] { new ObjectReference("Id", tableRef), new ObjectReference("Name", tableRef) });
     var runner = new DictionaryQueryRunner(SelectSource(), selectClause);
     var actual = runner.Run().ToList();
     Assert.AreEqual(4, actual.Count);
     Assert.AreEqual(2, actual[0].Count);
     Assert.AreEqual(1, actual[0]["Id"]);
     Assert.AreEqual("Alice", actual[0]["Name"]);
     Assert.AreEqual(2, actual[1].Count);
     Assert.AreEqual(2, actual[1]["Id"]);
     Assert.AreEqual("Bob", actual[1]["Name"]);
     Assert.AreEqual(2, actual[2].Count);
     Assert.AreEqual(3, actual[2]["Id"]);
     Assert.AreEqual("Charlie", actual[2]["Name"]);
     Assert.AreEqual(2, actual[3].Count);
     Assert.AreEqual(4, actual[3]["Id"]);
     Assert.AreEqual("David", actual[3]["Name"]);
 }
        public void SelectShouldRestrictColumnList()
        {
            var tableRef     = new ObjectReference("FooTable");
            var selectClause = new SelectClause(new SimpleReference[] { new ObjectReference("Id", tableRef), new ObjectReference("Name", tableRef) });
            var runner       = new DictionaryQueryRunner(SelectSource(), selectClause);
            var actual       = runner.Run().ToList();

            Assert.AreEqual(4, actual.Count);
            Assert.AreEqual(2, actual[0].Count);
            Assert.AreEqual(1, actual[0]["Id"]);
            Assert.AreEqual("Alice", actual[0]["Name"]);
            Assert.AreEqual(2, actual[1].Count);
            Assert.AreEqual(2, actual[1]["Id"]);
            Assert.AreEqual("Bob", actual[1]["Name"]);
            Assert.AreEqual(2, actual[2].Count);
            Assert.AreEqual(3, actual[2]["Id"]);
            Assert.AreEqual("Charlie", actual[2]["Name"]);
            Assert.AreEqual(2, actual[3].Count);
            Assert.AreEqual(4, actual[3]["Id"]);
            Assert.AreEqual("David", actual[3]["Name"]);
        }
        public void WhereNotEqualWithByteArrayShouldWork()
        {
            var tableRef    = new ObjectReference("FooTable");
            var whereClause = new WhereClause(new ObjectReference("Array", tableRef) != new byte[] { 1, 2, 3, 4 });
            var data        = new List <IDictionary <string, object> >
            {
                new Dictionary <string, object>
                {
                    { "Name", "Steve" }, { "Array", new byte[] { 1, 2, 3, 4 } }
                },
                new Dictionary <string, object>
                {
                    { "Name", "Dave" }, { "Array", new byte[] { 2, 3, 4 } }
                },
            };
            var runner = new DictionaryQueryRunner(data, whereClause);
            var actual = runner.Run().ToList();

            Assert.AreEqual(1, actual.Count);
            Assert.AreEqual("Dave", actual[0]["Name"]);
        }
        public void WhereNotNullShouldWork()
        {
            var tableRef    = new ObjectReference("FooTable");
            var whereClause = new WhereClause(new ObjectReference("Value", tableRef) != null);
            var data        = new List <IDictionary <string, object> >
            {
                new Dictionary <string, object>
                {
                    { "Name", "Steve" }, { "Value", null }
                },
                new Dictionary <string, object>
                {
                    { "Name", "Dave" }, { "Value", 42 }
                },
            };
            var runner = new DictionaryQueryRunner(data, whereClause);
            var actual = runner.Run().ToList();

            Assert.AreEqual(1, actual.Count);
            Assert.AreEqual("Dave", actual[0]["Name"]);
        }
        public void SelectLengthShouldUseLengthFunction()
        {
            var tableRef     = new ObjectReference("FooTable");
            var function     = new FunctionReference("Length", new ObjectReference("Name", tableRef)).As("NameLength");
            var selectClause = new SelectClause(new SimpleReference[] { new ObjectReference("Name", tableRef), function });
            var runner       = new DictionaryQueryRunner(SelectSource(), selectClause);
            var actual       = runner.Run().ToList();

            Assert.AreEqual(4, actual.Count);
            Assert.AreEqual(2, actual[0].Count);
            Assert.AreEqual("Alice", actual[0]["Name"]);
            Assert.AreEqual(5, actual[0]["NameLength"]);
            Assert.AreEqual(2, actual[1].Count);
            Assert.AreEqual("Bob", actual[1]["Name"]);
            Assert.AreEqual(3, actual[1]["NameLength"]);
            Assert.AreEqual(2, actual[2].Count);
            Assert.AreEqual("Charlie", actual[2]["Name"]);
            Assert.AreEqual(7, actual[2]["NameLength"]);
            Assert.AreEqual(2, actual[3].Count);
            Assert.AreEqual("David", actual[3]["Name"]);
            Assert.AreEqual(5, actual[3]["NameLength"]);
        }
 public void SelectLengthShouldUseLengthFunction()
 {
     var tableRef = new ObjectReference("FooTable");
     var function = new FunctionReference("Length", new ObjectReference("Name", tableRef)).As("NameLength");
     var selectClause = new SelectClause(new SimpleReference[] { new ObjectReference("Name", tableRef), function });
     var runner = new DictionaryQueryRunner(SelectSource(), selectClause);
     var actual = runner.Run().ToList();
     Assert.AreEqual(4, actual.Count);
     Assert.AreEqual(2, actual[0].Count);
     Assert.AreEqual("Alice", actual[0]["Name"]);
     Assert.AreEqual(5, actual[0]["NameLength"]);
     Assert.AreEqual(2, actual[1].Count);
     Assert.AreEqual("Bob", actual[1]["Name"]);
     Assert.AreEqual(3, actual[1]["NameLength"]);
     Assert.AreEqual(2, actual[2].Count);
     Assert.AreEqual("Charlie", actual[2]["Name"]);
     Assert.AreEqual(7, actual[2]["NameLength"]);
     Assert.AreEqual(2, actual[3].Count);
     Assert.AreEqual("David", actual[3]["Name"]);
     Assert.AreEqual(5, actual[3]["NameLength"]);
 }
 public void BasicWhereNotEqualShouldWork()
 {
     var tableRef = new ObjectReference("FooTable");
     var whereClause = new WhereClause(new ObjectReference("Name", tableRef) != "Alice");
     var runner = new DictionaryQueryRunner(SelectSource(), whereClause);
     var actual = runner.Run().ToList();
     Assert.AreEqual(3, actual.Count);
     Assert.False(actual.Any(a => (string)a["Name"] == "Alice"));
 }
 public void WhereNotNullShouldWork()
 {
     var tableRef = new ObjectReference("FooTable");
     var whereClause = new WhereClause(new ObjectReference("Value", tableRef) != null);
     var data = new List<IDictionary<string, object>>
                    {
                        new Dictionary<string, object>
                            {
                                {"Name", "Steve"}, { "Value", null }
                            },
                        new Dictionary<string, object>
                            {
                                {"Name", "Dave"}, { "Value", 42 }
                            },
                    };
     var runner = new DictionaryQueryRunner(data, whereClause);
     var actual = runner.Run().ToList();
     Assert.AreEqual(1, actual.Count);
     Assert.AreEqual("Dave", actual[0]["Name"]);
 }
 public void WhereNotEqualWithByteArrayShouldWork()
 {
     var tableRef = new ObjectReference("FooTable");
     var whereClause = new WhereClause(new ObjectReference("Array", tableRef) != new byte[] { 1, 2, 3, 4 });
     var data = new List<IDictionary<string, object>>
                    {
                        new Dictionary<string, object>
                            {
                                {"Name", "Steve"}, { "Array", new byte[] { 1, 2, 3, 4}}
                            },
                        new Dictionary<string, object>
                            {
                                {"Name", "Dave"}, { "Array", new byte[] { 2, 3, 4}}
                            },
                    };
     var runner = new DictionaryQueryRunner(data, whereClause);
     var actual = runner.Run().ToList();
     Assert.AreEqual(1, actual.Count);
     Assert.AreEqual("Dave", actual[0]["Name"]);
 }
 public void BasicWhereLessThanOrEqualShouldWork()
 {
     var tableRef = new ObjectReference("FooTable");
     var whereClause = new WhereClause(new ObjectReference("Weight", tableRef) <= 100M);
     var runner = new DictionaryQueryRunner(SelectSource(), whereClause);
     var actual = runner.Run().ToList();
     Assert.AreEqual(1, actual.Count);
     Assert.AreEqual("Alice", actual[0]["Name"]);
 }
 public void BasicLikeShouldWork()
 {
     var tableRef = new ObjectReference("FooTable");
     dynamic objRef = new ObjectReference("Name", tableRef);
     var expression = new SimpleExpression(objRef, new SimpleFunction("like", new[] {"A%"}), SimpleExpressionType.Function);
     var whereClause = new WhereClause(expression);
     var runner = new DictionaryQueryRunner(SelectSource(), whereClause);
     var actual = runner.Run().ToList();
     Assert.AreEqual(1, actual.Count);
     Assert.AreEqual("Alice", actual[0]["Name"]);
 }