[PHP/MySQL] Query -> tabel, zonder kennis van de kolomnamen

[Joep]

Hallo devvers, daar ben ik weer.

Ik wil de inhoud van een tabel opvragen en laten zien op een webpagina. Dat gaat uiteraard vrij makkelijk op de onderstaande manier:

PHP:

<div class="floatleftpad"><table>
<tr>
<th>ID</th>
<th>Name</th>
<th>Phone number</th>
<th>Email address</th>
</tr>

<?php
$result = execute("SELECT * FROM agent ORDER BY first_name");

/* Functie execute() voert de query uit en returnt het resultaat van de query */

while($row = mysqli_fetch_array($result)) {
echo '<tr>';
echo '<td>' . $row['id'] . '</td>';
echo '<td>' . $row['first_name'] . ' ' . $row['last_name'] . '</td>';
echo '<td>' . $row['phone_number'] . '</td>';
echo '<td>' . $row['email_address'] . '</td>';
echo '</tr>';
}
</table>
</div>
?>

Allemaal leuk en aardig, maar ik heb geen zin om dit heel vaak handmatig te moeten kopiëren voor andere tabellen, want dat kost veel tijd en m'n code wordt dan onoverzichtelijk.

Daarom wil ik een stukje code schrijven dat het resultaat van een query in html uitspuugt, zonder dat ik de kolomnamen handmatig moet typen. De kolomnamen van de query in html uitspugen lukt me al:

PHP:

<?php
while ($fieldinfo = mysqli_fetch_field($result)) {
echo $fieldinfo->name;
}
?>

Het probleem is echter dat niet elke tabel hetzelfde aantal kolommen heeft, dus zat ik er aan te denken om het aantal kolommen te tellen d.m.v. de volgende query:

SQL:

SELECT count(*)
FROM information_schema.columns
WHERE table_name = 'insertTableNameHere';
?>

en dit aantal dan te gebruiken om een for-loop te bouwen die het volgende genereert binnen de while-loop die bovenaan in deze post staat:

PHP:

<?php
echo '<tr>';
echo '<td>' . $row[0] . '</td>';
echo '<td>' . $row[1] . '</td>';
echo '<td>' . $row[2] . '</td>';
echo '<td>' . $row[3] . '</td>';
echo '<td>' . $row[4] . '</td>';
echo '</tr>';
?>

Iets zegt me echter dat ik te complex bezig ben en dat dit veel makkelijker kan. Ik heb gezocht en geprobeerd, maar kan nergens een voorbeeld vinden. Wie weet er een betere oplossing?

OOP en PDO is voor mij op dit moment nog een brug te ver, dus een dergelijke oplossing is voor mij moeilijker te doorgronden.

[JJerome]

Kijk even naar: http://php.net/manual/en/mysqli-result.fetch-assoc.php (en de voorbeelden die daar bij staan)

[NMe]

Zoiets?

PHP:

function fetchTable($data)
{
    if (empty($data))
        return '';

    $return = '<table><tr>';
    foreach (reset($data) as $key => $val)
    {
        $return .= '<th>'.htmlentities($key).'</th>';
    }
    $return .= '</tr>';
    foreach ($data as $row)
    {
        $return .= '<tr>';
        foreach ($row as $column)
        {
            $return .= '<td>'.htmlentities($column).'</td>';
        }
        $return .= '</tr>';
    }
    $return .= '<table>';
    return $return;
}

$data = [];
while ($row = mysql_fetch_assoc($resultset))
{
    $data[] = $row;
}
echo fetchTable($data);

Uit de losse pols, niet getest, en zonder mysqli omdat ik geen zin had om de syntax daarvan uit te zoeken.

[ Voor 11% gewijzigd door NMe op 04-09-2014 11:38 ]

[Joep]

Oh god, arrays en foreach Ik ga het even doornemen en proberen.

[ZeroXT]

NMe schreef op woensdag 03 september 2014 @ 14:12:
Zoiets?

PHP:

function fetchTable($data)
{
    if (empty($data))
        return '';

    $return = '<table><tr>';
    foreach (reset($data) as $key => val)
    {
        $return .= '<th>'.mysql_real_escape_string($key).'</th>';
    }
    $return .= '</tr>';
    foreach ($data as $row)
    {
        $return .= '<tr>';
        foreach ($row as $column)
        {
            $return .= '<td>'.mysql_real_escape_string($column).'</td>';
        }
        $return .= '</tr>';
    }
    $return .= '<table>';
    return $return;
}

$data = [];
while ($row = mysql_fetch_assoc($resultset))
{
    data[] = $row;
}
echo fetchTable($data);

Uit de losse pols, niet getest, en zonder mysqli omdat ik geen zin had om de syntax daarvan uit te zoeken.

Wat heeft mysql_real_escape_string met HTML te maken? Je haalt iets uit de database dat vervolgens escaped moet worden met htmlentities ipv mysql_real_escape_string.

Sidenote: je hebt in de while loop een $ vergeten voor data.

[PsychoMantis_NL]

Afgezien van het feit dat htmlentities() i.c.m. stripslashes() gebruikt zou moeten worden (je wilt immers unescapen, je inderdaad mysql_real_escape_string() niet nodig hebt, en dat Nme niet alleen een $ is vergeten op regel 29 (waar jij op doelt), maar ook op regel 7 (val moet worden $val), werkt zijn voorbeeld, zelfs uit de losse pols , prima.

Wanneer ik $data handmatig vul met:

PHP:

$data = array(
      array(
            'naam' => 'jan' ,
            'leeftijd' => '12' ,
            'haarkleur' => 'bruin'
      ) ,
      array(
            'naam' => 'piet' ,
            'leeftijd' => '45' ,
            'haarkleur' => 'zwart'
      )
);

Krijg ik netjes een tabel met de volgende output

HTML:

<table>
     <tr>
          <th>naam</th>
          <th>leeftijd</th>
          <th>haarkleur</th>
     </tr>
     <tr>
          <td>jan</td>
          <td>12</td>
          <td>bruin</td>
     </tr>
     <tr>
          <td>piet</td>
          <td>45</td>
          <td>zwart</td>
     </tr>
<table>

Je krijgt alleen een probleem wanneer je meerdere queries in dezelfde tabel weer zou geven, waarbij niet alle vereiste veldnamen in je 1^e resultset zitten.

Zou je de array bijvoorbeeld vullen met:

PHP:

$data = array(
      array(
            'naam' => 'jan' ,
            'leeftijd' => '12' ,
            'haarkleur' => 'bruin'
      ) ,
      array(
            'naam' => 'piet' ,
            'leeftijd' => '45' ,
            'haarkleur' => 'zwart' ,
            'lengte' => '187'
      )
);

Dan wordt wel netjes de lengte ge-output, maar ontbreekt daar de heading omdat deze niet in de eerste array zit die de headings bepaald.

Nou is dat allemaal wel op te lossen, en bovendien kan ik me zo snel ook even niet bedenken wanneer dit voor zou komen, maar daar zou dus nog iets op verzonnen moeten worden wanneer dit voorkomt.

offtopic:
Quotes om een int? Ja, voor de volledigheid hier even wel, ondanks dat het niet hoeft

[ Voor 3% gewijzigd door PsychoMantis_NL op 04-09-2014 08:55 ]

[ACM]

PsychoMantis_NL schreef op donderdag 04 september 2014 @ 08:47:
Afgezien van het feit dat htmlentities() i.c.m. stripslashes() gebruikt zou moeten worden (je wilt immers unescapen

Je hoeft hier helemaal niet te escapen of unescapen en 'mag' dat daardoor eigenlijk ook niet doen.

Je wilt alleen wel voorkomen dat speciale tekens je html in de war schoppen en dus htmlspecialchars of htmlentities gebruiken. Met tabelnamen is de kans daarop overigens wel vrij klein.

Overigens had de TS natuurlijk in de topicstart natuurlijk ook tijdens het ophalen van de mysqli_fetch_field-velden in de while-loop een tellertje op kunnen hogen en dat gebruiken in de for-loop. Of mysqli_stmt_field_count kunnen opvragen.

Sterker nog... je kan heel die aantallen negeren doordat je precies evenveel velden uit de fetch_assoc/row-rijen krijgt als dat er mysqli_fetch_field-velden zijn
Of anders gezegd, je kan gewoon een foreach over de velden uit fetch_assoc/row doen. Dus je genereert dan automatsch altijd al evenveel th's als td's.

[Barryvdh]

ACM schreef op donderdag 04 september 2014 @ 08:56:
[...]

Je hoeft hier helemaal niet te escapen of unescapen en 'mag' dat daardoor eigenlijk ook niet doen.

Dat ligt er aan hoe de data in de database gestopt is. Als je hem escaped met erin stoppen, moet je hem ook unescapen met eruit halen. Als je prepared statements oid. gebruikt hoeft dat natuurlijk niet.

[NMe]

ACM schreef op donderdag 04 september 2014 @ 08:56:
[...]

Je wilt alleen wel voorkomen dat speciale tekens je html in de war schoppen en dus htmlspecialchars of htmlentities gebruiken. Met tabelnamen is de kans daarop overigens wel vrij klein.

Blond momentje inderdaad, dat had een htmlentities-call moeten zijn.

Ik zal mijn code voor het nageslacht even corrigeren.

Barryvdh schreef op donderdag 04 september 2014 @ 09:34:
[...]

Dat ligt er aan hoe de data in de database gestopt is. Als je hem escaped met erin stoppen, moet je hem ook unescapen met eruit halen. Als je prepared statements oid. gebruikt hoeft dat natuurlijk niet.

Nee hoor, als je het escapet voordat je het erin stopt zet je "dit is een 'string'" om naar "dit is een \'string\'" in je query, maar je database slaat het alsnog gewoon als "dit is een 'string'" op. Alleen als je dubbel gaat lopen escapen (wat nog wel eens wil gebeuren als magic quotes aan staat en je daarbovenop nog blind gaat escapen) moet je daarna ook nog eens unescapen bij het eruit halen.

[ Voor 45% gewijzigd door NMe op 04-09-2014 11:40 ]

[Voutloos]

Check, tenzij je met legacy van dubbele escaping of magic quotes zit, heb je in een mysql context (ook met de oude api's) gewoon geen stripslashes() nodig. Anders gezegd: stripslashes() is -in deze context- al jaren een vette code smell.

[Barryvdh]

Voutloos schreef op donderdag 04 september 2014 @ 11:52:
Check, tenzij je met legacy van dubbele escaping of magic quotes zit, heb je in een mysql context (ook met de oude api's) gewoon geen stripslashes() nodig. Anders gezegd: stripslashes() is -in deze context- al jaren een vette code smell.

Ah, Naja gebruik tegenwoordig gewoon prepared statements of een ORM, nog makkelijker

[NMe]

Barryvdh schreef op donderdag 04 september 2014 @ 12:59:
[...]

Ah, Naja gebruik tegenwoordig gewoon prepared statements of een ORM, nog makkelijker

Zie hier de reden waarom ik twee basale functies door elkaar haalde.

[Joep]

NMe schreef op woensdag 03 september 2014 @ 14:12:
Zoiets?

PHP:

function fetchTable($data)
{
    if (empty($data))
        return '';

    $return = '<table><tr>';
    foreach (reset($data) as $key => $val)
    {
        $return .= '<th>'.htmlentities($key).'</th>';
    }
    $return .= '</tr>';
    foreach ($data as $row)
    {
        $return .= '<tr>';
        foreach ($row as $column)
        {
            $return .= '<td>'.htmlentities($column).'</td>';
        }
        $return .= '</tr>';
    }
    $return .= '<*/*table>';
    return $return;
}

$data = *array()*;
while ($row = mysql*i*_fetch_assoc($result**))
{
    $data[] = $row;
}
echo fetchTable($data);

Uit de losse pols, niet getest, en zonder mysqli omdat ik geen zin had om de syntax daarvan uit te zoeken.

Er zitten nog wat foutjes in (alles tussen de **), maar nu werkt het wel. Het is me echter nog steeds te omslachtig en in mijn situatie iets minder bruikbaar (ik heb stom genoeg niet alles omschreven, anders had je dit ook wel gezien). Hoe dan ook, bedankt

I.c.m. onderstaande quote van ACM heb ik de boel ff herschreven. Ik houd niet zo van associative arrays, want als je dan een uitzondering wil maken m.b.t. een kolom, dan moet je een kolomNAAM gaan vergelijken met een waarde en ik wil net een functie hebben die niks van kolomnamen weet.

ACM schreef op donderdag 04 september 2014 @ 08:56:
Overigens had de TS natuurlijk in de topicstart natuurlijk ook tijdens het ophalen van de mysqli_fetch_field-velden in de while-loop een tellertje op kunnen hogen en dat gebruiken in de for-loop. Of mysqli_stmt_field_count kunnen opvragen.

Sterker nog... je kan heel die aantallen negeren doordat je precies evenveel velden uit de fetch_assoc/row-rijen krijgt als dat er mysqli_fetch_field-velden zijn
Of anders gezegd, je kan gewoon een foreach over de velden uit fetch_assoc/row doen. Dus je genereert dan automatsch altijd al evenveel th's als td's.

PHP:

function execute($query) {
$connect = mysqli_connect("Bladiebla");
if (mysqli_connect_errno())
{
    echo 'Failed to connect to MySQL: ' . mysqli_connect_error();
}
return mysqli_query($connect, $query);
mysqli_close($connect);
}

function generate($query)
{
    $result = execute($query);
    $return = '<table>'."\r\n".'<tr>'."\r\n";
    
    while ($fieldinfo = mysqli_fetch_field($result))
    {
        $return .= '<th>'.$fieldinfo->name.'</th>'."\r\n";
    }
    
    $return .= '</tr>'."\r\n";
    
    while ($row = mysqli_fetch_row($result))
    {
        $return .= '<tr>'."\r\n";
        foreach ($row as $key => $value)
        {
            $return .= '<td>'.$value.'</td>'."\r\n";
        }
        $return .= '</tr>'."\r\n";
    }

    $return .= '</table>'."\r\n";
    return $return;
}

echo generate("SELECT * FROM Agent");

Bedoelde je zoiets ACM? Er zit misschien nog wat code in die er niks mee van doen heeft, maar bij mij werkt de boel iig

Nog wat hulp gekregen van een klasgenoot, collega en vanavond nog van een oud huisgenoot Debuggen gaat ook makkelijker met:

PHP:

echo '<pre>';
print_r($row);
echo '</pre>';

Prepared statements met mysqli is next

[NMe]

Joep schreef op woensdag 10 september 2014 @ 14:34:
[...]

Er zitten nog wat foutjes in (alles tussen de **), maar nu werkt het wel.

Die [] vs. array() is geen fout maar een verschil in PHP-versie. PHP 5.4 en hoger ondersteunen die short syntax. Dat ik mysqli_* niet gebruikte zei ik al in de post zelf en komt vooral omdat ik geen zin had om op te zoeken hoe die anders was dan mysql_*. Ik gebruik zelf een ORM dus ik zie die functies nooit. En of jij je variabele nu $result of $resultset noemt weet ik natuurlijk niet.

I.c.m. onderstaande quote van ACM heb ik de boel ff herschreven. Ik houd niet zo van associative arrays, want als je dan een uitzondering wil maken m.b.t. een kolom, dan moet je een kolomNAAM gaan vergelijken met een waarde en ik wil net een functie hebben die niks van kolomnamen weet.

Als je een uitzondering wil maken dan wéét je waarop je een uitzondering wil maken en dús weet je de kolomnaam.... "Ik hou niet zo van associative arrays" is net zoiets als "ik hou niet van sturen" zeggen als je in de auto zit. Je kan er zo veel of weinig van houden als je wil, maar als je een bocht moet maken is zo'n stuur toch verdomd handig.

[Joep]

1.) Klopt

2.) Ik heb een aantal tabellen met als eerste kolom 'id' als PK. Dan vind ik if ($row[0]) wat handiger dan if ($row == 'id') als ik bijvoorbeeld een kolomnaam verander d.m.v. een alias in m'n query. Daarnaast heb ik soms zin om i.p.v. 'id' iets anders weer te geven, bijvoorbeeld 'User ID' en daarom vind ik een enumeratieve array handiger. Maargoed, #MeerdereWegenLeidenNaarRome

[Voutloos]

Zo'n beetje iedereen vind assoc. arrays in dit geval duidelijker. Jij wellicht ook over een paar weken/maanden, je weet het alleen nog niet.

[NMe]

Joep schreef op woensdag 10 september 2014 @ 15:10:
2.) Ik heb een aantal tabellen met als eerste kolom 'id' als PK. Dan vind ik if ($row\[0]) wat handiger dan if ($row == 'id') als ik bijvoorbeeld een kolomnaam verander d.m.v. een alias in m'n query. Daarnaast heb ik soms zin om i.p.v. 'id' iets anders weer te geven, bijvoorbeeld 'User ID' en daarom vind ik een enumeratieve array handiger. Maargoed, #MeerdereWegenLeidenNaarRome

Juist daarom is het handiger om met associative arrays te werken. Met jouw opzet kun je nooit kolommen toevoegen aan je datamodel tenzij je eerst al je query's naloopt om te zien of je toevallig ergens een select * hebt gebruikt (even los van of dat nou al dan niet een goed idee is) waardoor je resultset ineens anders ingedeeld wordt.

[ Voor 3% gewijzigd door NMe op 10-09-2014 15:21 ]

[Joep]

Voutloos schreef op woensdag 10 september 2014 @ 15:13:
Zo'n beetje iedereen vind assoc. arrays in dit geval duidelijker. Jij wellicht ook over een paar weken/maanden, je weet het alleen nog niet.

Zou kunnen

NMe schreef op woensdag 10 september 2014 @ 15:20:
Juist daarom is het handiger om met associative arrays te werken. Met jouw opzet kun je nooit kolommen toevoegen aan je datamodel tenzij je eerst al je query's naloopt om te zien of je toevallig ergens een select * hebt gebruikt (even los van of dat nou al dan niet een goed idee is) waardoor je resultset ineens anders ingedeeld wordt.

Zolang ik dit alleen bij de eerste kolom van een tabel doe en deze altijd op z'n plek blijft in de tabel is er niets aan de hand en hoef ik mijn functie niet te herschrijven als de kolomnaam verandert.

[HansvDr]

Ik doe het regelmatig op ongeveer de onderstaande manier:

Ik heb onderstaand voorbeeld Array:

PHP:

$data = array(
      array(
            'naam' => 'jan' ,
            'leeftijd' => '12' ,
            'haarkleur' => 'bruin'
      ) ,
      array(
            'naam' => 'piet' ,
            'leeftijd' => '45' ,
            'haarkleur' => 'zwart'
      )
);

En de volgende functie:

PHP:

function array2table($myarray)
{
    $ret="";
    if(count($myarray)>0)
    {
        $keys = array_keys($myarray[0]);
        $ret = "<table><tr><th>".implode("</th><th>", $keys)."</th></tr>";
        foreach ($myarray as $record) 
        {
            $values = array_values($record);
            $ret = $ret . "<tr><td>".implode("</td><td>", $values)."</td></tr>";
        }
        $ret = $ret .  "</table>";
    }
    return $ret;
}

En uiteraard de aanroep:

PHP:

echo array2table($data);

Niet dat de andere manieren niet goed zijn uiteraard, dit is hoe ik het zo ongeveer doe. (Uiteraard is de echte functie uitgebreider maar dat is voor dit topic niet zo belangrijk)

[DJMaze]

Je kan ook fetch_assoc() voor de eerste gebruiken en dan fetch_row() omdat deze laatste sneller is.

PHP:

$row = mysqli_fetch_assoc($result);
echo '<table><thead><tr><th>';
echo implode('</th><th>',array_map('htmlspecialchars', array_keys($row)));
echo '</th></tr></thead><tbody><tr><td>';
echo implode('</td><td>',array_map('htmlspecialchars', $row));
echo '</td></tr>';
while ($row = mysqli_fetch_row($result)) {
    echo '<tr><td>';
    echo implode('</td><td>',array_map('htmlspecialchars', $row));
    echo '</td></tr>';
}
echo '</tbody></table>';

[NMe]

DJMaze schreef op donderdag 11 september 2014 @ 16:33:
Je kan ook fetch_assoc() voor de eerste gebruiken en dan fetch_row() omdat deze laatste sneller is.

Dat kan, maar met de hardware van tegenwoordig is dat echt een micro-optimalisatie.

[RobIII]

HansvDr schreef op donderdag 11 september 2014 @ 15:17:
Ik doe het regelmatig op ongeveer de onderstaande manier:
[...]

PHP:

//...
        $ret = "<table><tr><th>".implode("</th><th>", $keys)."</th></tr>";
//...
            $ret = $ret . "<tr><td>".implode("</td><td>", $values)."</td></tr>";

Leuk totdat je een keer <script...> in je keys en/of values hebt zitten Je zult op z'n minst die keys/values even (per stuk) door htmlentities of htmlspecialchars of hoe dat ook heet in PHP heen moeten halen (met array_walk/array_map o.i.d. desnoods).

[HansvDr]

RobIII schreef op donderdag 11 september 2014 @ 17:39:
[...]

Leuk totdat je een keer <script...> in je keys en/of values hebt zitten Je zult op z'n minst die keys/values even (per stuk) door htmlentities of htmlspecialchars of hoe dat ook heet in PHP heen moeten halen (met array_walk/array_map o.i.d. desnoods).

Uiteraard, maar in dit voorbeeld zit het er niet in. Ik wilde alleen laten zien hoe ik van een Array een tabel maak, meer niet.

Daarom schreef ik ook:

(Uiteraard is de echte functie uitgebreider maar dat is voor dit topic niet zo belangrijk)

Maar goed, als ik wel html kan verwachten omdat de gebruiker invloed heeft op de inhoud van de Array doe ik iets als:

PHP:

function array2table($myarray)
{
    $ret="";
    if(count($myarray)>0)
    {
        $ret = "<table><tr><th>".implode("</th><th>", array_map('htmlentities', array_keys($myarray[0])))."</th></tr>";
        foreach ($myarray as $record) 
        {
            $ret = $ret . "<tr><td>".implode("</td><td>", array_map('htmlentities', array_values($record)))."</td></tr>";
        }
        $ret = $ret .  "</table>";
    }
    return $ret;
}

[ Voor 6% gewijzigd door HansvDr op 11-09-2014 22:06 ]