Resolved Issue #1 "Can't call inline functions in expressions"

Dynamo.ORM.UnitTests/Services/RepositoryInlineFunctionQueryTests.cs

@@ -0,0 +1,110 @@
+using Amazon.DynamoDBv2;
+using Amazon.DynamoDBv2.Model;
+using Dynamo.ORM.Services;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Dynamo.ORM.UnitTests.Services
+{
+    public class RepositoryInlineFunctionQueryTests
+    {
+        private readonly AmazonDynamoDBClient client;
+
+        public RepositoryInlineFunctionQueryTests()
+        {
+            var config = new AmazonDynamoDBConfig
+            {
+                ServiceURL = "http://localhost:8000/"
+            };
+            client = new AmazonDynamoDBClient(config);
+
+            var tables = client.ListTablesAsync().Result;
+
+            if (!tables.TableNames.Contains("TESTS"))
+                client.CreateTableAsync("TESTS", new List<KeySchemaElement> {
+                    new KeySchemaElement("Id", KeyType.HASH)
+                }, new List<AttributeDefinition> {
+                    new AttributeDefinition("Id", ScalarAttributeType.N)
+                }, new ProvisionedThroughput(1, 1))
+                .Wait();
+        }
+
+        /// <summary>
+        /// Test filtering with the ToUpper function
+        /// </summary>
+        [Fact]
+        public async void TestToUpperQueryOnStringParameter_ExpectResults()
+        {
+            var repository = new Repository(client);
+
+            var value = new TestModel();
+
+            value.PopulateProperties();
+
+            await repository.Add(value);
+
+            var entities = await repository.List<TestModel>(x => x.Property1 == "test".ToUpper());
+
+            var size = entities.Count;
+
+            Assert.NotEqual(0, size);
+
+            foreach (var entity in entities)
+                Assert.Null(entity.Property6);
+        }
+
+        /// <summary>
+        /// Test filtering with the toLower function
+        /// </summary>
+        [Fact]
+        public async void TestToLowerQueryOnStringParameter_ExpectResults()
+        {
+            var repository = new Repository(client);
+
+            var value = new TestModel();
+
+            value.PopulateProperties();
+
+            value.Id = 2000;
+            value.Property1 = "test";
+
+            await repository.Add(value);
+
+            var entities = await repository.List<TestModel>(x => x.Property1 == "TEST".ToLower());
+
+            var size = entities.Count;
+
+            Assert.NotEqual(0, size);
+
+            foreach (var entity in entities)
+                Assert.Null(entity.Property6);
+        }
+
+        /// <summary>
+        /// Test filtering with a newly instantiated array while calling the max value
+        /// </summary>
+        [Fact]
+        public async void TestMaxQueryOnIntParameter_ExpectResults()
+        {
+            var repository = new Repository(client);
+
+            var value = new TestModel();
+
+            value.PopulateProperties();
+
+            value.Property3 = 400;
+
+            await repository.Add(value);
+
+            var entities = await repository.List<TestModel>(x => x.Property3 == new int[] { 1, 400, 3 }.Max());
+
+            var size = entities.Count;
+
+            Assert.NotEqual(0, size);
+
+            foreach (var entity in entities)
+                Assert.Null(entity.Property6);
+        }
+    }
+}

Dynamo.ORM/Converters/ExpressionValues.cs

@@ -24,10 +24,10 @@ public class ExpressionValues
 
             SanitizeExpression(expression, ref expressionString);
 
-            return result;
+            return result.ToDictionary(s => s.Key, s => s.Value);
         }
 
-        private static Dictionary<string, AttributeValue> ConvertExpressionValues(BinaryExpression binaryExpression, ref int valueIndex, ref StringBuilder expressionString)
+        private static IDictionary<string, AttributeValue> ConvertExpressionValues(BinaryExpression binaryExpression, ref int valueIndex, ref StringBuilder expressionString)
         {
             var expressionValues = GetExpressionValues(binaryExpression, ref valueIndex, ref expressionString);
 
@@ -36,7 +36,7 @@ public class ExpressionValues
             return ConvertExpressionValues(expressionValues);
         }
 
-        private static Dictionary<string, AttributeValue> ConvertExpressionValues(IDictionary<string, object> expressionValues)
+        private static IDictionary<string, AttributeValue> ConvertExpressionValues(IEnumerable<KeyValuePair<string, object>> expressionValues)
         {
             var convertedExpressionValues = new Dictionary<string, AttributeValue>();
 
@@ -51,39 +51,38 @@ public class ExpressionValues
             return convertedExpressionValues;
         }
 
-        private static IDictionary<string, object> GetExpressionValues(BinaryExpression binaryExpression, ref int valueIndex, ref StringBuilder expressionString)
+        private static IEnumerable<KeyValuePair<string, object>> GetExpressionValues(BinaryExpression binaryExpression, ref int valueIndex, ref StringBuilder expressionString)
         {
             var variableName = $":val{valueIndex}";
             IEnumerable<KeyValuePair<string, object>> expressionValues = new Dictionary<string, object>();
 
-            if (binaryExpression.Left is UnaryExpression)
-            {
-                expressionValues = GetExpressionValues(binaryExpression.Left as UnaryExpression, ref valueIndex, ref expressionString);
-            }
-            else if (IsExpressionNodeType(binaryExpression.Left.NodeType))
-                expressionValues = expressionValues.Union(GetExpressionValues(binaryExpression.Left as BinaryExpression, ref valueIndex, ref expressionString));
-            else if (IsMemberNode(binaryExpression.Left))
-            {
-                AppedExpressionValue(binaryExpression, binaryExpression.Left, binaryExpression.Right, variableName, ref expressionValues, ref expressionString);
-                valueIndex++;
-            }
+            expressionValues = expressionValues.Union(GetExpressionValues(binaryExpression, binaryExpression.Left, binaryExpression.Right, ref valueIndex, ref expressionString));
+            expressionValues = expressionValues.Union(GetExpressionValues(binaryExpression, binaryExpression.Right, binaryExpression.Left, ref valueIndex, ref expressionString));
+
+            return expressionValues;
+        }
+
+        private static IEnumerable<KeyValuePair<string, object>> GetExpressionValues(BinaryExpression binaryExpression, Expression primaryExpression, Expression secondaryExpression, ref int valueIndex, ref StringBuilder expressionString)
+        {
+            var variableName = $":val{valueIndex}";
+            IEnumerable<KeyValuePair<string, object>> expressionValues = new Dictionary<string, object>();
 
-            if (binaryExpression.Right is UnaryExpression)
+            if (primaryExpression is UnaryExpression)
             {
-                expressionValues = GetExpressionValues(binaryExpression.Right as UnaryExpression, ref valueIndex, ref expressionString);
+                expressionValues = expressionValues.Union(GetExpressionValues(primaryExpression as UnaryExpression, ref valueIndex, ref expressionString));
             }
-            else if (IsExpressionNodeType(binaryExpression.Right.NodeType))
-                expressionValues = expressionValues.Union(GetExpressionValues(binaryExpression.Right as BinaryExpression, ref valueIndex, ref expressionString));
-            else if (IsMemberNode(binaryExpression.Right))
+            else if (IsExpressionNodeType(primaryExpression.NodeType))
+                expressionValues = expressionValues.Union(GetExpressionValues(primaryExpression as BinaryExpression, ref valueIndex, ref expressionString));
+            else if (IsMemberNode(primaryExpression))
             {
-                AppedExpressionValue(binaryExpression, binaryExpression.Right, binaryExpression.Left, variableName, ref expressionValues, ref expressionString);
+                AppedExpressionValue(binaryExpression, primaryExpression, secondaryExpression, variableName, ref expressionValues, ref expressionString);
                 valueIndex++;
             }
 
-            return expressionValues.ToDictionary(s => s.Key, s => s.Value);
+            return expressionValues;
         }
 
-        private static IDictionary<string, object> GetExpressionValues(UnaryExpression unaryExpression, ref int valueIndex, ref StringBuilder expressionString)
+        private static IEnumerable<KeyValuePair<string, object>> GetExpressionValues(UnaryExpression unaryExpression, ref int valueIndex, ref StringBuilder expressionString)
         {
             var variableName = $":val{valueIndex}";
             IEnumerable<KeyValuePair<string, object>> expressionValues = new Dictionary<string, object>();
@@ -102,7 +101,7 @@ public class ExpressionValues
                 expressionString.Replace(unaryExpression.ToString(), propertyName);
             }
 
-            return expressionValues.ToDictionary(s => s.Key, s => s.Value);
+            return expressionValues;
         }
 
         private static void AppedExpressionValue(BinaryExpression binaryExpression, Expression propertyExpression, Expression valueExpression, string variableName, ref IEnumerable<KeyValuePair<string, object>> expressionValues, ref StringBuilder expressionString)
@@ -137,7 +136,10 @@ private static bool IsMemberNode(Expression expression)
 
         private static bool IsExpressionNodeType(ExpressionType nodeType)
         {
-            if (nodeType != ExpressionType.MemberAccess && nodeType != ExpressionType.Constant && nodeType != ExpressionType.New)
+            if (nodeType != ExpressionType.MemberAccess &&
+                nodeType != ExpressionType.Constant &&
+                nodeType != ExpressionType.New &&
+                nodeType != ExpressionType.Call)
                 return true;
             return false;
         }