IMPRESSUM dotted_line KONTAKT dotted_line search dotted_line Contact dotted_line sitemap
76 PHP-Resource Mitglieder online


php-resource



Zurück   PHP-Scripte PHP-Tutorials PHP-Jobs und vieles mehr > Blogs > AmicaNoctis
 

Login

 
eingeloggt bleiben
star Jetzt registrieren   star Passwort vergessen
 

Bewerten

Gruppenwechsel in PHP

"Gruppenwechsel in PHP" bei Mister Wong speichern "Gruppenwechsel in PHP" bei YiGG.de speichern "Gruppenwechsel in PHP" bei Google speichern "Gruppenwechsel in PHP" bei del.icio.us speichern "Gruppenwechsel in PHP" bei Digg speichern "Gruppenwechsel in PHP" bei icio.de speichern "Gruppenwechsel in PHP" bei My Yahoo speichern
Veröffentlicht: 03-06-2010 um 02:13 von AmicaNoctis

Da das Thema Gruppenwechsel immer mal wieder im Forum auftaucht, will ich an dieser Stelle mal einen lächerlich einfachen Ansatz vorstellen und erklären.

Wenn man eine Abfrage über mehrere Datenbanktabellen durchführt, erhält man fast immer eine Ergebnismenge in der Daten mehrfach vorkommen, die zwar in der Tabelle aus der sie stammen eindeutig sind, durch die Verknüpfung mit anderen Tabellen jedoch mehrfach in verschiedenen Kombinationen erscheinen. Ein Beispiel:

Code:
+---------------------------------------------------------+
| table: revision                                         |
+----+------------+--------+---------------------+--------+
| id | table_fkey | row_id | time                | type   |
+----+------------+--------+---------------------+--------+
|  1 |          1 |   NULL | 2010-03-03 09:20:30 | insert |
|  2 |          1 |      1 | 2010-03-03 09:20:30 | update |
|  3 |          1 |      1 | 2010-03-03 09:20:30 | update |
|  4 |          1 |   NULL | 2010-03-03 09:20:30 | insert |
|  5 |          1 |      2 | 2010-03-03 09:20:30 | update |
|  6 |          1 |      2 | 2010-03-03 09:20:31 | update |
|  7 |          1 |      1 | 2010-03-03 09:20:31 | update |
|  8 |          1 |      2 | 2010-03-03 09:20:31 | update |
|  9 |          1 |   NULL | 2010-03-03 09:20:31 | insert |
| 10 |          1 |      3 | 2010-03-03 09:20:31 | update |
:    :            :        :                     :        :
+----+------------+--------+---------------------+--------+

+-------------------------------------------------------------------+
| table: change                                                     |
+----+-------------+---------------+--------------------+-----------+
| id | column_fkey | revision_fkey | new_value          | old_value |
+----+-------------+---------------+--------------------+-----------+
|  1 |           1 |             1 | 1                  | NULL      |
|  2 |           2 |             1 | 2                  | NULL      |
|  3 |           3 |             1 | NULL               | NULL      |
|  4 |           4 |             1 |                    | NULL      |
|  5 |           3 |             2 | phpstaruml         | NULL      |
:    :             :               :                    :           :
| 13 |           2 |             7 | 4                  | 2         |
| 14 |           1 |             8 | 2                  | 3         |
| 15 |           2 |             8 | 3                  | 4         |
| 16 |           1 |             9 | 5                  | NULL      |
| 17 |           2 |             9 | 6                  | NULL      |
| 18 |           3 |             9 | NULL               | NULL      |
| 19 |           4 |             9 |                    | NULL      |
| 20 |           3 |            10 | AssociationTag.php | NULL      |
:    :             :               :                    :           :
+----+-------------+---------------+--------------------+-----------+
Die Abfrage

Code:
select
	revision.id as rev_id,
	revision.row_id,
	revision.type,
	`change`.id as chg_id,
	`change`.new_value,
	`change`.old_value,
from `change`
join revision on revision.id = change.revision_fkey;
liefert dann jeden revision-Datensatz mehrfach, wenn ihm mehrere change-Datensätze zugeordnet sind:

Code:
+--------+--------+--------++--------+--------------------+-----------+
| rev_id | row_id | type   || chg_id | new_value          | old_value |
+--------+--------+--------++--------+--------------------+-----------+
|      1 |   NULL | insert ||      1 | 1                  | NULL      |
|      1 |   NULL | insert ||      2 | 2                  | NULL      |
|      1 |   NULL | insert ||      3 | NULL               | NULL      |
|      1 |   NULL | insert ||      4 |                    | NULL      |
|      2 |      1 | update ||      5 | phpstaruml         | NULL      |
:        :        :        ::        :                    :           :
|      7 |      1 | update ||     13 | 4                  | 2         |
|      8 |      2 | update ||     14 | 2                  | 3         |
|      8 |      2 | update ||     15 | 3                  | 4         |
|      9 |   NULL | insert ||     16 | 5                  | NULL      |
|      9 |   NULL | insert ||     17 | 6                  | NULL      |
|      9 |   NULL | insert ||     18 | NULL               | NULL      |
|      9 |   NULL | insert ||     19 |                    | NULL      |
|     10 |      3 | update ||     20 | AssociationTag.php | NULL      |
:        :        :        ::        :                    :           :
+--------+--------+--------++--------+--------------------+-----------+
In der Ausgabe will man so etwas aber meist gruppiert darstellen, weil das einfach übersichtlicher ist oder aber daraus eine hierarchische Struktur (z. B. XML) erstellen und genau das macht man mit einem Gruppenwechsel.

Die am häufigsten anzutreffende Variante besteht darin, einen Wert zwischenzuspeichern, um ihn dann mit dem nächsten vergleichen zu können. Unterscheiden sich die beiden, wird in der Ausgabe der Gruppenbruch erzeugt und den neue Wert für die nachfolgenden Vergleiche zwischengespeichert:

PHP-Code:
$old null;
foreach (
$rows as $row) {
    if (
$row[$column] != $old) {
        
create_group_break($row[$column]);
        
$old $row[$column];
    }
    
create_row_output($row);

Bis hierher ist das auch noch recht übersichtlich, aber damit ist es dann vorbei, wenn man sowieso mit Arrays arbeiten möchte oder der Gruppenwechsel mehrere Ebenen umfasst.

Dabei ist es gerade in PHP so leicht, wenn man sich die Eigenschaften von Arrays zunutze macht. Bei Wertzuweisungen zu einem Array gibt man ja den Schlüssel an, unter dem der Wert gespeichert werden soll:

PHP-Code:
$array["key"] = $neuerWert
Dabei ist es naheliegenderweise egal, ob unter diesem Schlüssel bereits ein Wert gespeichert war (dann wird er überschrieben) oder ob er neu angelegt wird. Das schöne ist aber, dass dies auch über mehrere Ebenen funktioniert:

PHP-Code:
$array["abc"]["def"][] = "wert 1";
$array["abc"]["ghi"][] = "wert 2";
$array["abc"]["def"][] = "wert 3";
print_r($array); 
ergibt

PHP-Code:
Array
(
    [
abc] => Array
        (
            [
def] => Array
                (
                    [
0] => wert 1
                    
[1] => wert 3
                
)
            [
ghi] => Array
                (
                    [
0] => wert 2
                
)
        )

Vorhandene Schlüssel werden also jeweils weiter benutzt und neue einfach hinzugefügt. Genau das ist schon alles, was man für einen Gruppenwechsel braucht. Wenn man also im Beispiel oben die Datensätze zweistufig gruppieren will – zuerst nach Typ, dann nach Revision – braucht man dafür nicht mehr als das hier:

PHP-Code:
$array = array();
foreach (
$rows as $row) {
    
$array[$row["type"]][$row["rev_id"]][] = $row;

Das gruppierte Ergebnis steht dann in $array. Et voilà.

Digg this Post! Add Post to del.icio.us Bookmark Post in Technorati Furl this Post!
Kategorie: Kategorielos
Hits 8205 Kommentare 0 Stichworte bearbeiten Hinweis auf diesen Blog-Eintrag per E-Mail verschicken
« Zurück     Startseite des Blogs     Nächste »
Kommentare 0

Kommentare

 
Trackbacks 0

Trackbacks


Alle Zeitangaben in WEZ +2. Es ist jetzt 22:25 Uhr.



Search Engine Friendly URLs by vBSEO 3.3.0