oDataProvider: support aggregation/distinct/groupby

Author: lazarv

src/Types/StorageProviders/oData/oDataCompiler.js

@@ -8,6 +8,9 @@ $C('$data.storageProviders.oData.oDataModelBinderConfigCompiler', $data.modelBin
             builder.modelBinderConfig.$type = opDef.returnType || opDef.dataType;
             builder.modelBinderConfig.$value = function(meta, data){ return opDef.projection(data[meta.$source]); };
         }
+        if (opDef.aggregate){
+            if (opDef.returnType || opDef.dataType) builder.modelBinderConfig.$type = opDef.returnType || opDef.dataType;
+        }
     }
 });
 
@@ -34,7 +37,28 @@ $C('$data.storageProviders.oData.oDataCompiler', $data.Expressions.EntityExpress
         if(queryFragments.$expand){
             queryFragments.$expand = queryFragments.$expand.toString();
         }
-        
+        var $apply = "";
+        if (queryFragments.aggregate){
+            $apply = `aggregate(${queryFragments.aggregate.join(",")})`;
+        }
+        if (queryFragments.groupby){
+            queryFragments.groupby = queryFragments.groupby.filter(function(it, i, arr){ return arr.indexOf(it) == i; });
+            $apply = queryFragments.aggregate
+                ? `groupby((${queryFragments.groupby.join(",")}),${$apply})`
+                : `groupby((${queryFragments.groupby.join(",")}))`;
+        }
+        if ($apply && queryFragments.$filter){
+            $apply = `filter(${queryFragments.$filter})/${$apply}`;
+        }
+        if ($apply){
+            queryFragments = Object.assign({}, queryFragments, {
+                aggregate: [],
+                groupby: [],
+                $filter: "",
+                $select: "",
+                $apply: $apply
+            });
+        }
 
         query.modelBinderConfig = {};
         var modelBinder = $data.storageProviders.oData.oDataModelBinderConfigCompiler.create(query, this.includes, true);
@@ -271,5 +295,22 @@ $C('$data.storageProviders.oData.oDataCompiler', $data.Expressions.EntityExpress
                 headers: compiled.headers
             });
         }
+    },
+
+    VisitDistinctExpression: function (expression, context) {
+        this.Visit(expression.source, context);
+        context.groupby = context.groupby || [];
+        context.groupby.push(...context.$select.split(','));
+    },
+
+    VisitGroupExpression: function (expression, context) {
+        this.Visit(expression.source, context);
+        
+        var groupContext = Object.assign({}, context);
+        var orderCompiler = Container.createoDataOrderCompiler(this.provider);
+        orderCompiler.compile(expression.selector, groupContext);
+
+        context.groupby = context.groupby || [];
+        context.groupby.push(...groupContext.data.split(','));
     }
 }, {});

src/Types/StorageProviders/oData/oDataProjectionCompiler.js

@@ -168,7 +168,19 @@ $C('$data.storageProviders.oData.oDataProjectionCompiler', $data.Expressions.Ent
         //context.data += expression.value;
 		context.data = context.data.slice(0, context.data.length - 1);
     },
-    VisitEntityFieldOperationExpression: function (expression, context) {
-        this.Visit(expression.source, context);
+    VisitEntityFieldOperationExpression: function VisitEntityFieldOperationExpression(expression, context) {
+        Guard.requireType("expression.operation", expression.operation, $data.Expressions.MemberInfoExpression);
+
+        var opDef = expression.operation.memberDefinition;
+        if (opDef.aggregate){
+            var opName = opDef.mapTo || opDef.name;
+            context.aggregate = context.aggregate || [];
+            
+            var temp = context.data;
+            this.Visit(expression.source, context);
+            var field = context.data.replace(temp, "");
+            context.data = temp.replace(/,$/, "");
+            context.aggregate.push(`${field} with ${opName} as ${field}`);
+        }else this.Visit(expression.source, context);
     }
 });

src/Types/StorageProviders/oData/oDataProvider.js

@@ -1084,7 +1084,35 @@ $C('$data.storageProviders.oData.oDataProvider', $data.StorageProviderBase, null
                 dataType: "boolean", allowedIn: [$data.Expressions.FilterExpression, $data.Expressions.OrderExpression, $data.Expressions.SomeExpression, $data.Expressions.EveryExpression],
                 parameters: [{ name: "@expression", dataType: 'GeometryPoint' }, { name: "in", dataType: 'GeometryPolygon' }]
 
-            }]
+            }],
+
+            // aggregate functions
+            'sum': {
+                allowedIn: [$data.Expressions.ProjectionExpression],
+                mapTo: 'sum',
+                aggregate: true
+            },
+            'count': {
+                allowedIn: [$data.Expressions.ProjectionExpression],
+                mapTo: 'countdistinct',
+                returnType: $data.Integer,
+                aggregate: true
+            },
+            'min': {
+                allowedIn: [$data.Expressions.ProjectionExpression],
+                mapTo: 'min',
+                aggregate: true
+            },
+            'max': {
+                allowedIn: [$data.Expressions.ProjectionExpression],
+                mapTo: 'max',
+                aggregate: true
+            },
+            'avg': {
+                allowedIn: [$data.Expressions.ProjectionExpression],
+                mapTo: 'average',
+                aggregate: true
+            }
         },
         enumerable: true,
         writable: true
@@ -1164,7 +1192,9 @@ $C('$data.storageProviders.oData.oDataProvider', $data.StorageProviderBase, null
                 includeFrameName: '$count',
                 implementation: function(){ return 'true' }
             },
-            find: {}
+            find: {},
+            distinct: {},
+            groupBy: {}
         },
         enumerable: true,
         writable: true