Add support for Aggregate

Author: arontsang

src/PDO/Peachpie.Library.PDO.Sqlite/PDOSqliteDriver.cs

@@ -65,7 +65,26 @@ public override ExtensionMethodDelegate TryGetExtensionMethod(string name)
 
         private static PhpValue sqliteCreateAggregate(Context ctx, PDO pdo, PhpArray arguments)
         {
-            return PhpValue.False;
+            if (pdo.GetCurrentConnection<SqliteConnection>() is not {} connection)
+                return PhpValue.False;
+
+            var name = arguments[0].String;
+            var step = arguments[1].AsCallable();
+            var finalize = arguments[2].AsCallable();
+            var numberOfArguments = -1;
+            if (arguments.TryGetValue(3, out var args) && args.IsInteger())
+                numberOfArguments = args.ToInt();
+            
+            var handle = connection.Handle;
+            
+            raw.sqlite3_create_function(
+                handle,
+                name,
+                numberOfArguments,
+                null,
+                CreateAggregateStep(ctx, step),
+                CreateAggregateFinalize(ctx, finalize));
+            return PhpValue.True;
         }
         private static PhpValue sqliteCreateCollation(Context ctx, PDO pdo, PhpArray arguments)
         {
@@ -126,39 +145,83 @@ public override string GetLastInsertId(PDO pdo, string name)
             }
         }
 
-        private static delegate_function_scalar CreateScalarFunction(Context ctx, IPhpCallable callback)
+        private static delegate_function_aggregate_step CreateAggregateStep(Context ctx, IPhpCallable callback)
         {
             return (sqliteContext, data, args) =>
             {
+                if (sqliteContext.state is not StepFunctionState state)
+                {
+                    sqliteContext.state = state = new StepFunctionState();
+                }
+                var rowIndex = state.RowIndex++;
+                
                 var phpArgs = args
                     .Select(AsPhp)
+                    .Prepend(PhpValue.FromClr(rowIndex))
+                    .Prepend(state.Value)
                     .ToArray();
-                var ret = callback.Invoke(ctx, phpArgs);
-
 
-                if (ret.IsLong(out var longValue))
-                {
-                    raw.sqlite3_result_int64(sqliteContext, longValue);
-                }
-                else if (ret.IsInteger())
-                {
-                    raw.sqlite3_result_int(sqliteContext, ret.ToInt());
-                }
-                else if (ret.IsDouble(out var doubleValue))
-                {
-                    raw.sqlite3_result_double(sqliteContext, doubleValue);
-                }
-                else if (ret.IsString(out var stringValue))
-                {
-                    var foo = stringValue;
-                    raw.sqlite3_result_text(sqliteContext, foo);
-                }
-                else
+                var ret = callback.Invoke(ctx, phpArgs);
+                state.Value = ret;
+            };
+        }
+        
+        private static delegate_function_aggregate_final CreateAggregateFinalize(Context ctx, IPhpCallable callback)
+        {
+            return (sqliteContext, data) =>
+            {
+                if (sqliteContext.state is not StepFunctionState state)
                 {
-                    raw.sqlite3_result_null(sqliteContext);
+                    sqliteContext.state = state = new StepFunctionState();
                 }
+                
+                var ret = callback.Invoke(ctx, state.Value, state.RowIndex);
+                SetSqliteReturnValue(ret, sqliteContext);
+            };
+        }
+        
+        private static delegate_function_scalar CreateScalarFunction(Context ctx, IPhpCallable callback)
+        {
+            return (sqliteContext, data, args) =>
+            {
+                var phpArgs = args
+                    .Select(AsPhp)
+                    .ToArray();
+                var ret = callback.Invoke(ctx, phpArgs);
+                SetSqliteReturnValue(ret, sqliteContext);
             };
         }
+
+        private static void SetSqliteReturnValue(PhpValue ret, sqlite3_context sqliteContext)
+        {
+            if (ret.IsLong(out var longValue))
+            {
+                raw.sqlite3_result_int64(sqliteContext, longValue);
+            }
+            else if (ret.IsInteger())
+            {
+                raw.sqlite3_result_int(sqliteContext, ret.ToInt());
+            }
+            else if (ret.IsDouble(out var doubleValue))
+            {
+                raw.sqlite3_result_double(sqliteContext, doubleValue);
+            }
+            else if (ret.IsString(out var stringValue))
+            {
+                var foo = stringValue;
+                raw.sqlite3_result_text(sqliteContext, foo);
+            }
+            else
+            {
+                raw.sqlite3_result_null(sqliteContext);
+            }
+        }
+
+        private class StepFunctionState
+        {
+            public int RowIndex { get; set; }
+            public PhpValue Value { get; set; } = PhpValue.Null;
+        }
 
         private static PhpValue AsPhp(sqlite3_value value)
         {

tests/pdo/sqlite_udf_aggregate.php

@@ -0,0 +1,42 @@
+<?php
+
+$data = array(
+   'one',
+   'two',
+   'three',
+   'four',
+   'five',
+   'six',
+   'seven',
+   'eight',
+   'nine',
+   'ten',
+   );
+$pdo = new \PDO("sqlite::memory:");
+$pdo->exec("CREATE TABLE strings(a)");
+$insert = $pdo->prepare('INSERT INTO strings VALUES (?)');
+foreach ($data as $str) {
+    $insert->execute(array($str));
+}
+$insert = null;
+
+function max_len_step($context, $rownumber, $string)
+{
+    if (strlen($string) > $context) {
+        $context = strlen($string);
+    }
+    return $context;
+}
+
+function max_len_finalize($context, $rownumber)
+{
+    return $context === null ? 0 : $context;
+}
+
+$pdo->sqliteCreateAggregate('max_len', max_len_step, max_len_finalize);
+$stmt = $pdo->prepare('SELECT max_len(a) from strings');
+$stmt->execute();
+$result = $stmt->fetch(\PDO::FETCH_NUM)[0];
+if ($result != 5) {
+    throw new ErrorException("Expecting '5'");
+}