Ankündigung

Einklappen
Keine Ankündigung bisher.

PHP Array-Klasse für tabellenartige Datenstrukturen

Einklappen

Neue Werbung 2019

Einklappen
X
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • PHP Array-Klasse für tabellenartige Datenstrukturen

    Vorgestellt und diskutiert werden soll das Konzept einer PHP-Klasse für die Selection und Sortierung für mehrdimensionale Arrays mit Tabellenstrukturen. Nützlich kann eine solche Klasse bei der Verarbeitung von Daten sein welche z.B. als JSON aus einer API(Webservice) oder als CSV daherkommen. Mit tabellenartigen Datenstrukturen sind Arrays ähnlich wie dies hier gemeint:
    PHP-Code:
    $data = [ 
      [
    'id' => 1'val' => 23.333333333], 
      [
    'id' => 2'val' => 13.7777777777], 
    ]; 
    Bei der Notation der Methoden fällt sofort die Ähnlichkeit zu SQL auf.
    PHP-Code:
    $newData tableArray::create($data
      ->
    select('id, FORMAT("%6.2f",val) AS rval'
      ->
    orderBy('val ASC')
      ->
    fetchAll(); 
    Das ist beabsichtigt. Die Funktionsweise ist jedoch schon etwas anders. Beispiel select-Methode.

    Die mit Komma getrennten Ausdrücke werden nacheinander abgearbeitet. Ein alleinstehender Feldname(Schlüssel) wird nur für einen Abruf der Daten mit FetchAll() vorgemerkt. Ein Ausdruck mit AS erzeugt intern eine neue Spalte. Diese neue Spalte steht "sofort" für nachfolgende Ausdrücke im select oder nachfolgende Methoden zur Verfügung. Durch die Nutzung von Funktionen für select und orderBy wird die Klasse extrem vielseitig. Die obige FORMAT-Funktion entspricht der sprintf-Funktion von PHP.

    Folgende Funktionen sind aktuell verfügbar:
    UPPER, LOWER, TRIM, FORMAT, DATEFORMAT, REPLACE, SUBSTR, LIKE, INTVAL, FLOATVAL

    Ist keine dieser Funktionen für den konkreten Anwendungsfall nutzbar, können eigene Funktionen mit der Methode addSqlFunction der Klasse bekannt gemacht und benutzt werden.
    PHP-Code:
    $newData tableArray::create($data)
      ->
    addSqlFunction('mul',function($v1,$v2){return $v1*$v2;})
      ->
    select('id,val,factor,mul(val,factor) as product')
      ->
    fetchAll(); 
    Diese Funktionen sind alle auch für die Methode orderBy nutzbar.
    PHP-Code:
      ->orderBy("LIKE(pos,'%CEO%') DESC, pos ASC, name"
    Eine Vergleichsfunktion wie bei usort muss vom Nutzer nicht erstellt werden, diese wird in der Klasse dynamisch aus dem Sortierausdruck erstellt. Damit wird das Sortieren eines Arrays mit mehreren Kriterien stark vereinfacht.
    Das jetzige Konzept verlangt für jede Tabellenzeile einen gleiche Struktur. Leider wird das in der Praxis von den Datenlieferanten nicht immer eingehalten.
    Die Frage wie damit umgegangen werden soll, wenn beispielsweise ein Feldelement fehlt, ist noch ein offenes Problem.

    Die Feldelemente können selbst wieder Arrays, Objekte oder ein Gemisch aus Arrays und Objekten der StdClass sein. Typisch sind da solche Strukturen
    PHP-Code:
    $data = [ 
      [
    'id' => 1'@attributes' => ['currency' => "USD",'rate' => "1.1370"]], 
      [
    'id' => 2'@attributes' => ['currency' => "JPY",'rate' => "1.28"]], 
    ]; 
    wenn die Daten aus einer XML kommen. Um Zugriff auf untere Ebenen zu haben gibt es 2 Methoden um die Daten unterhalb der 2.Ebene zu "flatten".
    Mit
    PHP-Code:
      ->flatten() 
    wird das Array in der 2.Ebene flach gemacht. Das Resultat
    PHP-Code:
    $newData = [
      [
    'id' => 1'@attributes.currency' => "USD"'@attributes.rate' => "1.1370"],
      [
    'id' => 2'@attributes.currency' => "JPY"'@attributes.rate' => "1.28",]
    ]; 
    Mit der Methode addFlatKeys() bleiben die tieferen Strukturen erhalten und die flachen Elemente werden zugefügt. Dieses Konzept erscheint für mich als ein gangbarer Weg tiefe Strukturen zu verarbeiten und gleichzeitig den Aufwand des internen Parsers für select und orderBy klein zu halten.
    Die einzelnen Methoden sind auch mehrfach nutzbar. Sortierungen wie die ältesten 5 Mitglieder zu ermitteln und diese dann den Namen nach sortiert auszugeben stellt auch kein Problem dar.
    PHP-Code:
      ->orderBy('alter DESC')
      ->
    limit(5)
      ->
    orderBy('name ASC'
    Zum Schluss möchte ich noch etwas klarstellen:
    Die Klasse ist nicht dafür gedacht Daten roh aus einer Datenbank zu holen um diese dann zu Filtern und zu Sortieren. Das kann mit einer Datenbank besser und schneller erledigt werden. Auch bei größeren Datenmengen (>1000 Datensätze) und wenn diese nicht sofort verarbeitet werden ist abzuwägen, ob es nicht Sinn macht die Daten in eine Datenbank zu bringen.

    LG jspit

    PHP-Klassen auf github


  • #2
    PHP-Code:
    ->select('id, FORMAT("%6.2f",val) AS rval'
    Wäre es nicht sinnvoller, einen Parameter für jeden Key zu nehmen?
    PHP-Code:
    ->select('id''FORMAT("%6.2f",val) AS rval'
    oder auch als array...
    PHP-Code:
    ->select(['id''rval' => 'FORMAT("%6.2f",val)']) 

    Kommentar


    • #3
      Sieht für mich so ähnlich aus wie:

      https://github.com/Athari/YaLinqo

      Kommentar


      • #4
        Oder ähnlich wie: https://github.com/ReactiveX/RxPHP (http://reactivex.io/) auch wenn es natürlich eine komplett andere Syntax hat.

        Kommentar


        • #5
          Dormilich : Inwiefern sinnvoller? Deine Vorschläge sind mehr PHP-Like und dadurch womöglich auch einfacher umzusetzen. Den für die Umsetzung meiner Syntax notwendigen Parser habe ich bereits im Griff. Hatte Anfangs die Befürchtung das dadurch zuviel Zeit draufgeht, das hat sich jedoch als unbegründet erwiesen. Eine an SQL angelehnte Syntax, die ohne viel zu überlegen hingeschrieben werden kann ohne sich Gedanken über die Reihenfolge von Argumenten oder etwa notwendige Arraystrukturen zu machen möchte ich nicht aufgeben.
          To do a common thing uncommonly well brings success.
          Links wie es andere Entwickler gemacht haben sind immer willkommen. Hab aber beides bisher nur überflogen. Beim Link von hellbringer kann ich bestimmt noch was nützliches entdecken.
          Die Syntax beim Link #3 ist für mich jedoch nicht auf den ersten Blick verständlich. Es werden Bezeichner eingeführt wie $cat für die eine Zuordnung zu den Daten nicht erkennbar ist.
          Das Ziel dort so wie ich das sehe, beliebige Wunschstrukturen von Arrays zu erzeugen, geht weit über das hinaus was ich mit meiner Klasse möchte. Bei mir ist erstmal immer eine reguläre Tabelle das Ziel.

          Edit: Der Link #3 hat ein schönes Beispiel, das ich als Test mal mit meinem Ansatz und der Einschränkung Resultat = Tabelle umgesetzt habe (dabei noch einen Bug gefunden)

          Datenbasis:
          PHP-Code:
          $products = array(
              array(
          'name' => 'Keyboard',    'catId' => 'hw''quantity' =>  10'id' => 1),
              array(
          'name' => 'Mouse',       'catId' => 'hw''quantity' =>  20'id' => 2),
              array(
          'name' => 'Monitor',     'catId' => 'hw''quantity' =>   0'id' => 3),
              array(
          'name' => 'Joystick',    'catId' => 'hw''quantity' =>  15'id' => 4),
              array(
          'name' => 'CPU',         'catId' => 'hw''quantity' =>  15'id' => 5),
              array(
          'name' => 'Motherboard''catId' => 'hw''quantity' =>  11'id' => 6),
              array(
          'name' => 'Windows',     'catId' => 'os''quantity' => 666'id' => 7),
              array(
          'name' => 'Linux',       'catId' => 'os''quantity' => 666'id' => 8),
              array(
          'name' => 'Mac',         'catId' => 'os''quantity' => 666'id' => 9),
          );
          $categories = array(
              array(
          'name' => 'Hardware',          'id' => 'hw'),
              array(
          'name' => 'Operating systems''id' => 'os'),
          ); 
          Aufgabe (Orginalkommentar):
          // Put products with non-zero quantity into matching categories;
          // sort categories by name;
          // sort products within categories by quantity descending, then by name.

          Lösung:
          PHP-Code:
          $newData tableArray::create($products)
            ->
          innerJoinOn($categories,'t2','id','catId')
            ->
          filter() 
            ->
          orderBy('t2.name,quantity DESC,name')
            ->
          select('t2.name AS Categorie,name,quantity')
            ->
          fetchAll();

          echo 
          html::table('border=1',HTML::KEYTITLE,$newData); 
          Resultat:
          result_tablearray.png
          Die Aufgabenstellung oben kann für diesen Fall fast 1:1 umgesetzt werden. Das SELECT um die id's wegzulassen ist eine Zugabe von mir.

          LG jspit
          PHP-Klassen auf github

          Kommentar


          • #6
            Ich habe mir das Projekt eben angesehen und finde es grundsätzlich gut.

            Bisher habe ich es immer so gehalten, CSVs etc. in eine SQLite Memory DB zu packen und damit zu arbeiten. Das ging recht flott.

            Ich weiß nicht so recht, ob Deine Lösung einen erheblichen Geschwindigkeitsvorteil bietet und werde es testen.

            Kommentar


            • #7
              Den Test hab ich bereits gemacht. Am Ende von diesen Test wird das für ein Array mit 1000 Zeilen gemacht. Daher kommt auch die Zahl 1000 im Startbeitrag.
              SQLite (im RAM) braucht dort viel mehr Zeit beim Insert und ist schneller bei der Auswertung. Die Zeit/Geschwindikkeit steht für mich bei dem Projekt jedoch nicht an erster Stelle, da die nach meinem Ermessen für beide Varianten traumhaft sind.

              Bei einem Test bei dem eine API ca 260K Daten als JSON liefert kam ich auf solche Zeiten:
              Webservicezugriff : 1 Sek.
              Json-Decode : 100ms
              Verarbeitung mit tablearray: 10ms


              Anmerkung: Der Test läuft in Echtzeit, daher ergeben sich bei jeden Aufruf geringfügig andere Zeiten.
              Anmerkung2: Die Klasse ist noch nicht ausgetestet, den letzten Bock ha ich heute früh gefunden.
              PHP-Klassen auf github

              Kommentar


              • #8
                Zitat von #5
                PHP-Code:
                  ->filter() 
                Was macht das "nackte" filter() hier?
                Debugging: Finde DEINE Fehler selbst! | Gegen Probleme beim E-Mail-Versand | Sicheres Passwort-Hashing | Includes niemals ohne __DIR__
                PHP.de Wissenssammlung | Kein Support per PN

                Kommentar


                • #9
                  Zitat von hausl Beitrag anzeigen
                  Was macht das "nackte" filter() hier?
                  Arbeitet mit dem Defaultparameter NULL ähnlich wie array_filter() , nur das hier alle Zeilen rausgefiltert werden die in einer Spalte den Wert null, 0 oder "" haben. Im Beispiel ist das der Monitor.
                  Im Normalfall wird dort als Parameter eine anonyme Funktion übergeben.
                  PHP-Klassen auf github

                  Kommentar


                  • #10
                    Cool, gefällt mir sehr gut. Habe sowas bisher auch immer über den SQLite Umweg gemacht.
                    Hast du evt. geplant, noch einfache Aggregatfunktionen und GroupBy einzubauen? Oder funktioniert das sogar schon irgendwie mit fetchGroup und addSqlFunction?
                    sorry, shift-taste kaputt

                    Kommentar


                    • #11
                      Zitat von Meister1900 Beitrag anzeigen
                      Habe sowas bisher auch immer über den SQLite Umweg gemacht.
                      Ist ja auch keine schlechte Lösung. Wenn es mit den Daten passt spricht so einiges für eine Datenbanklösung.
                      Eben ein wenig mehr Aufwand durch die notwendige Erstellung der Tabellen und dem Insert der Daten.
                      Es gibt jedoch Anwendungsfälle, da wird dies für eine Datenbanklösung sehr aufwendig (Stichwort Normalisierung).
                      So ist immer abzuwägen, was für den konkreten Anwendungsfall der bessere Weg ist.

                      Zitat von Meister1900 Beitrag anzeigen
                      Hast du evt. geplant, noch einfache Aggregatfunktionen und GroupBy einzubauen?
                      Wohl eher nicht, da dies in meinen Augen Aufgaben sind, die Datenbanken sozusagen auf den Laib geschneidert sind. Hab in der Richtung mir auch noch keine Gedanken gemacht.
                      Will mich bezüglich Erweiterungen da zum jetzigen Zeitpunkt nicht festlegen, denn eine solche Notwendigkeit zeigt sich erst bei der Benutzung der Klasse in konkreten Anwendungen.
                      Zudem steht es ja jeden frei, die Klasse nach eigenen Anforderungen zu erweitern oder umzubauen.

                      LG jspit





                      PHP-Klassen auf github

                      Kommentar


                      • #12
                        Die Version 2.0 der Klasse bekommt jetzt doch einfache Aggregatefunktionen wie MIN,MAX,SUM und AVG. Diese Funktionen können auch in Verbindung mit einen 'GroupBy' genutzt werden können.
                        Die Realisierung erfolgt mit der universellen Filterfunktion filterGroupAggregate(). Abweichend von der bekannten SQL-Syntax wird hier als erster Parameter ein Array der Form ['feldname' => 'Aggregatfunktionen',..]
                        übergeben. Beispiel:

                        PHP-Code:
                          ->filterGroupAggregate(['sales' => 'SUM']) 
                        Es gilt für die Methode auch nicht die Forderung, das alle Spalten aggregiert oder gruppiert werden müssen.
                        Für die Funktionen MIN und MAX wird immer die zugehörige Arrayzeile geliefert.
                        Als zweiter Parameter kann optional ein Array mit Feldnamen (Keys) mitgegeben werden, nach denen gruppiert wird.

                        Dazu mal ein Komplettbespiel:
                        PHP-Code:
                        $data = [ 
                          [
                        'id' => "1",'group' => 1'value' => 2'value2' => 3], 
                          [
                        'id' => "2",'group' => 2'value' => 4'value2' => 7],
                          [
                        'id' => "3",'group' => 1'value' => 1'value2' => 2], 
                          [
                        'id' => "4",'group' => 2'value' => 6'value2' => 8],
                        ];

                        $newData tableArray::create($data)
                          ->
                        filterGroupAggregate(['value' => 'MAX''value2' => 'AVG'],['group'])
                          ->
                        orderBy('value2 DESC')
                          ->
                        fetchAll();

                        $expected = [ 
                          [
                        'id' => "4",'group' => 2'value' => 6'value2' => 7.5],
                          [
                        'id' => "1",'group' => 1'value' => 2'value2' => 2.5], 
                        ];
                        var_dump($newData === $expected);  //bool(true) 
                        Die 'id' wird hier weder gruppiert noch aggregiert. Abweichend von einigen Datenbanken wie MySQL wird ist die id hier immer die vom MAX-Wert der Gruppe 'group'.

                        PHP-Klassen auf github

                        Kommentar


                        • #13
                          Die bisherigen Versionen der PHP-Klasse TableArray benötigten immer eine tabellenartige Arraystruktur als Basis. Bei praktischen Anwendungen für API's hat sich gezeigt, das diese oft umfangreiche Daten als JSON in sehr komplexen Strukturen liefern. Für die Klasse wurden bisher vorab die Daten eingesammelt um dann ein 2-dimensionales Array als Basis zu erstellen.

                          Die Version 2.6 bietet jetzt auch für diese Aufgabe Unterstützung. Gezeigt werden soll dies anhand einer realen Applikation für Wetterwarnungen mit der API des DWD (https://www.dwd.de).

                          Die API liefert als Response einen riesigen einzeiligen String der wie folgt beginnt:

                          Code:
                          warnWetter.loadWarnings({"time":1641660567000,"warnings":{"106535000":[{"regionName":"Vogelsbergkreis","state":"Hessen", ...
                          Ein JavaScript Beautifier wie https://beautifier.io/ macht das ganze erstmal lesbar:

                          PHP-Code:
                          warnWetter.loadWarnings({
                              
                          "time"1641660567000,
                              
                          "warnings": {
                                  
                          "106535000": [{
                                      
                          "regionName""Vogelsbergkreis",
                                      
                          "state""Hessen",
                                      
                          "type"3,
                                      
                          "level"3,
                                      
                          "description""Es tritt im Warnzeitraum oberhalb 600 m Schneefall mit Mengen zwischen 8 cm und 15 cm auf. Verbreitet wird es glatt.",
                                      
                          "end"1641726000000,
                                      
                          "start"1641668400000,
                                      
                          "event""SCHNEEFALL",
                                      
                          "headline""Amtliche WARNUNG vor SCHNEEFALL",
                                      
                          "instruction""",
                                      
                          "stateShort""HE",
                                      
                          "altitudeStart"600,
                                      
                          "altitudeEnd"null
                                  
                          }, {
                                      
                          "regionName""Vogelsbergkreis",
                           :
                           :
                                      
                          "altitudeStart"400,
                                      
                          "altitudeEnd"null
                                  
                          }],
                                  
                          "107132000": [{
                                      
                          "regionName""Kreis Altenkirchen (Westerwald)"
                          Das obige Format ist kein reines JSON sondern ein JSONP zugeschnitten für Javascript. Benötigt werden die Daten von den Schlüsseln "headline","regionName" sowie "start" und "end". Diese liegen gruppiert nach AGS (Allgemeiner Gemeinde Schlüssel) unterhalb von "warnings". Manuell wären folgende Schritte notwendig:
                          • Extrahieren der JSON-Daten
                          • konvertieren in ein Array
                          • Erstellen eines 2-dimensionalen Arrays mit "Tabellenstruktur"
                          In der aktuellen Version wird das mit einer Filterfunktion erreicht, welche neben dem $content dem statischen Konstruktor der Klasse übergeben wird.

                          PHP-Code:
                          $filter = function($cur,$key,$iterator){
                              
                          $required = ["regionName","state","headline","start","end"];
                              return 
                          array_diff($required,array_keys($cur)) === [];
                          };

                          $tabArr TableArray::createFromJson($content,$filter)
                            ->
                          print('debug output',5)

                          Die Funktion arbeitet für diesen Fall so das alle Unterarrays eingesammelt werden welche über alle Schlüssel "regionName","state","headline","start" und "end" verfügen. Es wird rekursiv die gesamte Struktur durchsucht. Wo dieses Array gefunden wird ist für unseren Fall hier egal. Für andere Anwendungen kann es notwendig werden die Parameter $key und $iterator bei der Auswahl mit zu berücksichtigen.

                          Wir haben jetzt ein 2-dimensionales Array wie wir es als Basis brauchen:

                          PHP-Code:
                          // debug output
                          $data = array (
                            
                          'warnings.106535000.0' => 
                            array (
                              
                          'regionName' => 'Vogelsbergkreis',
                              
                          'state' => 'Hessen',
                              
                          'type' => 3,
                              
                          'level' => 3,
                              
                          'description' => 'Es tritt im Warnzeitraum oberhalb 600 m Schneefall mit Mengen zwischen 8 cm und 15 cm auf. Verbreitet wird es glatt.',
                              
                          'end' => 1641726000000,
                              
                          'start' => 1641668400000,
                              
                          'event' => 'SCHNEEFALL',
                              
                          'headline' => 'Amtliche WARNUNG vor SCHNEEFALL',
                              
                          'instruction' => '',
                              
                          'stateShort' => 'HE',
                              
                          'altitudeStart' => 600,
                              
                          'altitudeEnd' => NULL,
                            ),
                            
                          'warnings.106535000.1' => 
                            array (
                              
                          'regionName' => 'Vogelsbergkreis'
                          Jedes Subarray ist mit einen Schlüssel versehen der den kompletten Schlüsselpfad in der sog. Dot-Notation vom Orginalarray beinhaltet. Dieser kann wenn er weiter benötigt wird mit der addKeys-Methode in das Subarray übernommen werden. Mit
                          PHP-Code:
                          ->filterLikeIn("state",'Berlin,Brandenburg'
                          bleiben dann nur die Unterarrays übrig, welche im "state" Berlin oder Brandenburg enthalten.

                          PHP-Code:
                          $data = array (
                            
                          => 
                            array (
                              
                          'regionName' => 'Stadt Potsdam',
                              
                          'state' => 'Brandenburg',
                              
                          'type' => 5,
                              
                          'level' => 2,
                              
                          'description' => 'Es tritt leichter Frost zwischen 0 °C und -3 °C auf.',
                              
                          'end' => 1641718800000,
                              
                          'start' => 1641661200000,
                              
                          'event' => 'FROST',
                              
                          'headline' => 'Amtliche WARNUNG vor FROST',
                              
                          'instruction' => '',
                              
                          'stateShort' => 'BB',
                              
                          'altitudeStart' => NULL,
                              
                          'altitudeEnd' => NULL,
                            ),
                            
                          => 
                            array (
                              
                          'regionName' => 'Kreis Elbe-Elster',
                              
                          'state' => 'Brandenburg'
                          Für eine Warnmeldung sollen nun nur "regionName" und die "headline" verwendet werden. Dann soll das Array zuerst nach "state" und dann nach 'regionName'
                          sortiert werden. Der gesamte Code ist dann:
                          PHP-Code:
                          $data TableArray::createFromJson($content,$filter)
                            ->
                          filterLikeIn("state",'Berlin,Brandenburg')
                            ->
                          select('regionName, headline')
                            ->
                          orderBy('state,regionName'
                            ->
                          fetchAll()

                          In $data ist jetzt ein Array ähnlich

                          PHP-Code:
                          $data = array (
                            
                          => 
                            array (
                              
                          'regionName' => 'Berlin',
                              
                          'headline' => 'Amtliche WARNUNG vor FROST',
                            ),
                            
                          => 
                            array (
                              
                          'regionName' => 'Kreis Barnim',
                              
                          'headline' => 'Amtliche WARNUNG vor FROST',
                            ),
                            
                          => 
                            array (
                              
                          'regionName' => 'Kreis Dahme-Spreewald',
                              
                          'headline' => 'Amtliche WARNUNG vor FROST',
                            ), 
                          Die Ausgabe der Warnungen ist jetzt kein Problem mehr.

                          Die API liefert immer aktuelle Warnungen. Sollen historische Daten verfügbar gemacht werden dann müssen einige der Felder in einer Datenbank gespeichert werden. Dafür können Named PreparedStatements und PDO benutzt werden.

                          PHP-Code:
                          //$db = new PDO(...);
                          $sql "INSERT INTO tab (state,regionName,headline,datefrom,dateto) 
                             VALUES (:state,:regionName,:headline,:datefrom,:dateto)"
                          ;
                          $stmt $db->prepare($sql); 
                          Für ein Insert werden wird nun ein Array mit genau den obigen Schlüsseln benötigt und natürlich mit Werten welche die DB versteht. Dafür müssen 'start' und 'end' welche als Milliskunden-Timestamps vorliegen in das DB konforme Format Y-m-d H:i:s gebracht werden. Das realisiert die select-Methode, welche interne Funktionen nutzen kann und sogleich notwendige Umbenennungen vornimmt. Komplett sieht der Code dafür so aus:
                          PHP-Code:
                          $tabArr TableArray::createFromJson($content,$filter)
                            ->
                          filterLikeIn("state",'Berlin,Brandenburg')
                            ->
                          select('state,
                                      regionName,
                                      headline,
                                      DATEFORMAT("Y-m-d H:i:s",start,"ms") as datefrom,
                                      DATEFORMAT("Y-m-d H:i:s",end,"ms") as dateto
                                    '
                          )

                          Die Daten in $tabArr sind genau so wie sie für ein Insert benötigt werden:

                          PHP-Code:
                          $data = array (
                            
                          => 
                            array (
                              
                          'state' => 'Brandenburg',
                              
                          'regionName' => 'Stadt Potsdam',
                              
                          'headline' => 'Amtliche WARNUNG vor FROST',
                              
                          'datefrom' => '2022-01-08 18:00:00',
                              
                          'dateto' => '2022-01-09 10:00:00',
                            ),
                            
                          => 
                            array (
                              
                          'state' => 'Brandenburg',
                              
                          'regionName' => 'Kreis Elbe-Elster',
                              
                          // : 
                          $tabArr hat u.A. das Traversable-Interface integriert, so dass direkt mit foreach-Konstrukten gearbeitet werden kann.

                          PHP-Code:
                            foreach($tabArr as $row){
                              
                          $stmt->execute($row);
                            } 
                          Datenbankabfragen können ebenso einfach mit der TableArray-Klasse weiterverarbeitet werden. Dafür kann direkt ein PDOStatement dem Konstruktor übergeben werden:

                          PHP-Code:
                          $stmt $db->query($sql);
                          $tArr TableArray::create($stmt)
                            -> .. 
                          Richtig Sinn macht das jedoch erst wenn weitere Datenquellen die nicht aus der DB stammen oder spezielle Berechnungen/Konvertierungen mit ins Spiel kommen die mit Datenbanken nicht oder nur mit hohen Aufwand realisierbar sind.

                          Bedanke mich für die Ausdauer beim Lesen.
                          LG jspit




                          PHP-Klassen auf github

                          Kommentar


                          • #14
                            Vom Code und vom Funktionsumfang her finde ich die Klasse weiterhin sehr Interessant.

                            Was mir noch fehlt, damit man die Klasse in Projekten einsetzen kann, wäre eine Composer Datei und das die Klasse ein Namespace nutzt.
                            Ich habe im Code gesehen, dass du den Namespace bereits vorbereitet hast (aber auskommentiert).

                            PS: Die Dokumentation ist scheinbar gerade defekt: jspit.de/tools/classdoc.php?class=tableArray

                            Kommentar


                            • #15
                              Zitat von Zeichen32 Beitrag anzeigen
                              Vom Code und vom Funktionsumfang her finde ich die Klasse weiterhin sehr Interessant.

                              Was mir noch fehlt, damit man die Klasse in Projekten einsetzen kann, wäre eine Composer Datei und das die Klasse ein Namespace nutzt.
                              Ich habe im Code gesehen, dass du den Namespace bereits vorbereitet hast (aber auskommentiert).

                              PS: Die Dokumentation ist scheinbar gerade defekt: jspit.de/tools/classdoc.php?class=tableArray
                              verwenden kannst du sie aber doch trotzdem in deinem projekt, wenn du ihr einfach den namespace deiner app verpasst für das autoloaing, oder?
                              zumindest würde ich das so machen. aber über composer ist natürlich einfacher und man bekommt auch automatisch updates
                              sorry, shift-taste kaputt

                              Kommentar

                              Lädt...
                              X