Visa källa för Pdo\Sqlite::createAggregate

== Pdo\Sqlite::createAggregate ==
'''(PHP 8 >= 8.4.0)'''

Pdo\Sqlite::createAggregate — Registrerar en aggregerande användardefinierad funktion för användning i SQL-frågor

=== Beskrivning ¶ ===
'''public Pdo\Sqlite::createAggregate(
    string $name,
    callable $step,
    callable $finalize,
    int $numArgs = -1
): bool'''

Den här metoden liknar [[Pdo\Sqlite::createFunction]] förutom att den registrerar funktioner som kan användas för att beräkna ett resultat aggregerat över alla rader i en fråga.

Den största skillnaden mellan den här metoden och [[Pdo\Sqlite::createFunction]] är att två funktioner krävs för att hantera aggregeringen.

'''Tips'''  
Genom att använda den här metoden är det möjligt att åsidosätta inbyggda SQL-funktioner.

=== Parametrar ¶ ===

; name  
: Namnet på funktionen som används i SQL-frågor.

; step  
: Callback-funktion som anropas för varje rad i resultatmängden. Callback-funktionen bör ackumulera resultatet och lagra det i aggregeringskontexten.  
Den här funktionen måste definieras så här:

<pre>
step(
    mixed $context,
    int $rownumber,
    mixed $value,
    mixed ...$values
): mixed
</pre>

'''context'''  
''null'' för den första raden; vid efterföljande rader kommer det att ha värdet som tidigare returnerades från step-funktionen; du bör använda detta för att upprätthålla tillståndet för aggregeringen.

'''rownumber'''  
Det aktuella radnumret.

'''value'''  
Det första argumentet som skickas till aggregeringen.

'''values'''  
Fler argument som skickas till aggregeringen.

Returvärdet för den här funktionen kommer att användas som context-argument i nästa anrop av step- eller finalize-funktionerna.

; finalize  
: Callback-funktion för att aggregera den ”uppstegade” datan från varje rad. När alla rader har bearbetats kommer den här funktionen att anropas, och den bör då ta datan från aggregeringskontexten och returnera resultatet. Den här callback-funktionen bör returnera en typ som SQLite förstår (d.v.s. en skalär typ).  
Den här funktionen måste definieras så här:

<pre>
fini(mixed $context, int $rowcount): mixed
</pre>

'''context'''  
Innehåller returvärdet från det allra sista anropet till step-funktionen.

'''rowcount'''  
Innehåller antalet rader över vilka aggregeringen utfördes.

Returvärdet för den här funktionen kommer att användas som returvärde för aggregeringen.

; numArgs  
: En antydan till SQLite-parsern om callback-funktionen tar ett förutbestämt antal argument.

=== Returvärden ¶ ===
Returnerar true vid framgång eller false vid misslyckande.

=== Exempel ¶ ===

==== Exempel #1 Pdo\Sqlite::createAggregate()-exempel ====
I det här exemplet skapar vi en anpassad aggregeringsfunktion som heter max_length och som kan användas i SQL-frågor.

I det här exemplet skapar vi en aggregerande funktion, kallad max_length, som beräknar längden på den längsta strängen i en av kolumnerna i tabellen. För varje rad anropas funktionen max_len_step och får en parameter $context. Parametern context fungerar som vilken annan PHP-variabel som helst och kan sättas till att innehålla en array eller till och med ett objekt. I det här exemplet använder vi den för att spara det maximala längdvärdet vi har sett hittills; om $string har en längd som är längre än det nuvarande maximala värdet uppdaterar vi context för att innehålla detta nya maximala värde.

När alla rader har bearbetats anropar SQLite funktionen max_len_finalize för att bestämma det aggregerade resultatet. Det är möjligt att utföra någon form av beräkning baserat på data i $context. I det här grundläggande exemplet beräknades resultatet medan frågan fortskred, så context-värdet kan returneras direkt.

<pre>
Run code
<?php
$data = [
   'one',
   'two',
   'three',
   'four',
   'five',
   'six',
   'seven',
   'eight',
   'nine',
   'ten',
];
$db = new Pdo\Sqlite('sqlite::memory:');
$db->exec("CREATE TABLE strings(a)");
$insert = $db->prepare('INSERT INTO strings VALUES (?)');
foreach ($data as $str) {
    $insert->execute(array($str));
}
$insert = null;

function max_len_step($context, $row_number, $string)
{
    if (strlen($string) > $context) {
        $context = strlen($string);
    }
    return $context;
}

function max_len_finalize($context, $row_count)
{
    return $context === null ? 0 : $context;
}

$db->createAggregate('max_len', 'max_len_step', 'max_len_finalize');

var_dump($db->query('SELECT max_len(a) from strings')->fetchAll());
?>
</pre>

=== Tips ===
Det rekommenderas INTE att du sparar en kopia av värdena i context och sedan bearbetar dem i slutet, då du skulle få SQLite att använda mycket minne för att behandla frågan – tänk bara på hur mycket minne som skulle krävas om en miljon rader sparades i minnet, var och en med en sträng på 32 byte i längd.

=== Se även ¶ ===
* [[Pdo\Sqlite::createFunction]] - Registrerar en användardefinierad funktion för användning i SQL-frågor  
* [[Pdo\Sqlite::createCollation]] - Registrerar en användardefinierad funktion för användning som kollationsfunktion i SQL-frågor  
* sqlite_create_function()  
* sqlite_create_aggregate()

= Sidslut =

Orginalhemsidan på Engelska :https://www.php.net/manual/en/pdo-sqlite.createaggregate.php
<BR>[[PHP]]
[[Funktioner]]
[[Funktionsreferens]]
[[Databas-tillägg]]

<HR>
Det här är en maskinöversättning av PHP-manualen till svenska. Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på 
https://www.linux.se/kontaka-linux-se/
<BR><BR>Tack till [https://datorhjalp.se/huddinge  Datorhjälp Huddinge] som har  sponsrat [https://www.linux.se Linux.se] med webbhotell.

[[Kategori:Php]]
[[Kategori:Databas-tillägg]]