[php] wat is sneller, mysql of *.txt includen?

[pim]

Ik heb +/- 10.000 Html bestanden van +/- 10.000 tekens, die dagelijks +/- 10.000 keer opgevraagd gaan worden.

Is het sneller om deze weg te schrijven naar *.txt bestanden en ze vervolgens te includen, of is het sneller om ze weg te schrijven naar een table in Mysql, en elke keer op te halen?

Statisch wegschrijven naar Html files is geen optie.. (waarom doet er ff niet toe..)

[hennink]

Veranderd de inhoud van de bestanden vaak?

[Janoz]

Om hier een fatsoenlijk antwoord op te geven zul je toch echt meer informatie moeten geven. Op basis van de aanwezige feiten kan helemaal niks geconcludeerd worden.

[pim]

Ongeveer 30% van de files, zal dagelijks veranderen..

Verder zal er altijd een mysql verbinding zijn, dus die zou niet speciaal gemaakt hoeven te worden voor de include..

[ Voor 3% gewijzigd door pim op 07-10-2003 12:21 ]

[Cavorka]

MySQL verbinding voor een include?

En 10000 HTML pagina's... Ik begrijp het niet echt: je werkt met PHP maar je hebt evengoed 10000 html files?

Uit ervaring kan ik zeggen dat includen niet echt snel is. Vooral 'grote' bestanden (>50k), nemen redelijk wat tijd in beslag. Is allemaal wel relatief hoor, maar het gaat soms richting honderste(n) van seconden. Ik vind dat altijd redelijk pittig.

Maar ehm: wat let je om het even te testen? Loopje, 10000 keer (om maar even in de 10k sfeer te blijven) includen van een bestand, daarna 10000 uit een DB trekken, timestampjes (microseconds) tussendoor: voila. Antwoord.

[ Voor 71% gewijzigd door Cavorka op 07-10-2003 12:24 ]

[pim]

Die 10.000 html pagina's, zijn eigenlijk 10.000 PHPpagina's met elke 30 queries..
Deze wil ik statisch wegschrijven zodat het serverload scheelt.

Met een Mysql Include bedoel ik een pagina ophalen uit een mysqltable, i.p.v. uit een txtfile.

[ Voor 5% gewijzigd door pim op 07-10-2003 12:23 ]

[Michali]

Waarom benchmark je het niet even. Dan ben je er redelijk snel achter.

[Verwijderd]

Ik denk dat MySQL efficiënter zal zijn, voornamelijk omdat de mogelijkheden groter zijn. Sorteren, wijzigen waar bla='bla' (dus ook meerdere tegelijk). Ik denk dat die dingen met queries een stuk makkelijker gaan.

Het is wel goed om na te denken over het server-side cachen van de pagina's, bijv. wanneer deze toegevoegd / gewijzigd worden, aangezien het zo veel bestanden zijn. Als je dit niet doet dan krijg je zeer waarschijnlijk een overload aan MySQL queries.

Verder is het ook makkelijker om de boel bij te houden d.m.v. een content management system.

[JeRa]

Even een beetje offtopic, want ik ben nog nooit een situatie tegengekomen waarbij je 10.000 verschillende pagina's nodig hebt. Is het niet veel makkelijker om al die pagina's te laten genereren door één PHP-scriptje en die eventueel op de server te cachen? Ik kan me niet voorstellen dat je met de hand al die pagina's hebt zitten te maken

[Cavorka]

@Michali: Ehm... dat zei ik.

@JeRa: Ehm... dat zei ik.
En hij heeft dus 10000 verschillende text files met 30 queries erin.

@ReSistanZ: CMS voor text files is net zo eenvoudig (nou ja, bijna dan) als een CMS voor een MySQL based dinges. Of bedoelde je dat niet?

[ Voor 82% gewijzigd door Cavorka op 07-10-2003 12:31 ]

[JeRa]

Cavorka schreef op 07 October 2003 @ 12:29:
@JeRa: Ehm... dat zei ik.
En hij heeft dus 10000 verschillende text files met 30 queries erin.

Dan lijkt het me het handigste, ook voor toekomstige plannen en een eventueel CMS, dat hij die text files in een database zet, de queries laat afhandelen door PHP en vervolgens de resultaten (aan de hand vd URL) cached op de server. Zal veel werk zijn, maar dat zou het ook wel waard zijn. Met zoiets kun je niet veel...

[pim]

Om bewerkbaarheid, schaalbaarheid gaat het niet, puur om serverload.

Ik zal idd zelf eens een test script maken.
Postte het hier ff voor het geval dat iemand misschien een heel goed advies zou hebben

[Roa]

Even een beetje offtopic, maar waarom heb je in hemelsnaam 10.000 bestanden met elk 30 queries? En ik snap dus ook niet zo goed wat je nu bedoeld; heb je nou gewoon 10.000 verschillende reviews (voorbeeldje)? Dan lijkt mysql mij het makkelijkst...

Maja, et zal wel, even testen idd...

[hennink]

OK,

wat je kan doen, want ik zie je probleem wel, is het volgende.
Je zegt dat elke pagina die je ophaalt 30 queries moet doen.
Stel even simpel gezegd dat je de pagina's ophaalt middels de volgende methode
pagina.php?id=3994
etc...
En je komt hier vanaf een formuliertjes of wat dan ook...
Wat je dan kan doen is elke x minuten alle pagina's genereren met een php script vanaf je prompt(lees cron) en ze wegschrijven als pagina3994.html etc.
Het formulier waarmee je vroeger direct uitkwam op de pagina.php?id....
pas je dan aan dat je op de juiste locatie uitkomt.
Het zoeken naar het juiste formulier zou je dan nog wel mysql driven kunnen doen, maar op daadwerkelijk opvragen van de pagina's dan niet.
Maar je kan ook kijken naar adodb met CacheExecute etc.. en ook MySQL 4 heeft goede mogelijkheden tot het cachen van queries.
Voordeel met het genereren van de pagina's is dat je altijd weet wat de load ongeveer is.
Ook bij extreme pieken heb je alleen last van je formulier, wat wellicht ook deels te cachen valt.
Verder heb je dan alleen elke x minuten dus het genereren van je bestanden.
Een uitbreiding hierop kan zijn in de tool waarmee je de inhoud van een van de bestanden kan aanpassen om na het opslaan het formulier direct te genereren als html.

[mocean]

Ik zou een template engine aanbevelen.

Zelf heb ik erg goede ervaringen met Smarty (http://smarty.php.net/).
Die heeft een cache systeem ingebouwd. Als je bijvoorbeeld templates hebt met 30 queries, kan je Smarty laten cachen. Bijvoorbeeld een bepaalde vaststaande tijd, of je bouwt een mechanisme waarin je cached totdat de inhoud is veranderd.

Als je een site hebt met zoveel pagina's/records is een Smarty best het overwegen waard, al is het tunen ervan wel een klus als je het voor het eerst doet.

[Verwijderd]

Misschien ben je iets met de deze test, © ACM en lichtjes aangepast door mij:

PHP:

<?

error_reporting(E_ALL);

$totalTests = 100;
$totalEntries = 100;

function getTime()
{
    list($usec, $sec) = explode(" ", microtime());
    
    return ( (float) $usec + (float) $sec );
}

/*********/
/* Files */
/*********/
$arrayToFile = array();

for ($i = 0; $i < $totalEntries; $i++)
{
    $arrayToFile[$i]['id'] = $i + 1;
    $arrayToFile[$i]['name'] = "Napoleon";
}

$file = fopen("bench1", "w+");

if ($file)
    fwrite($file, serialize($arrayToFile)); 

/* start benchmark */
$startTime = getTime();

for ($i = 0; $i < $totalTests; $i++)
{
    if (file_exists("bench1"))
    {
        $result = array();
        $result = unserialize(file_get_contents("bench1"));

//      print_r($result);
    }
}

echo "Files: " . (getTime() - $startTime) . "\n";

/* clean up */
unlink("bench1");

/*********/
/* MySQL */
/*********/
$dbConn = mysql_connect("localhost", "root");
mysql_select_db("Peter");

mysql_query("DROP TABLE IF EXISTS bench1");
mysql_query("CREATE TABLE bench1 (id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,
name CHAR(8) NOT NULL , PRIMARY KEY(id))");

for ($i = 0; $i < $totalEntries; $i++)
    mysql_query("INSERT INTO bench1 VALUES ('', 'Napoleon')");

mysql_close($dbConn);

/* start benchmark */
$startTime = getTime();

for ($i = 0; $i < $totalTests; $i++)
{
    /* connect to database and select database */
    $dbConn = mysql_connect("localhost", "root");
    mysql_select_db("Peter");

    /* execute query */
    $queryResult = mysql_query("SELECT id, name FROM bench1");

    /* get results */
    if ($queryResult && mysql_num_rows($queryResult) > 0)
    {
        $result = array();
    
        while ($row = mysql_fetch_assoc($queryResult))
            $result[] = $row;

//      print_r($result);
    }

    /* close connection */
    mysql_close($dbConn);
}

echo "MySQL: " . (getTime() - $startTime) . "\n";

/* clean up */
$dbConn = mysql_connect("localhost", "root");
mysql_select_db("Peter");

mysql_query("DROP TABLE bench1");

?>

Op mijn pc waren files 10x sneller.

[pim]

Late reactie..

Ik heb zelf een test gerunned, 200 files van 80kb achter mekaar "geinclude"..
Met include() duurde het gemiddeld 2,2 sec, en met mysql ook 2,2 sec. Dus ik houd het maar op mysql voor de bewerkbaarheid..

Op de site bouw ik overigens zelf het mechanisme wat cashed, totdat de inhoud word veranderd..

[Verwijderd]

Laat je die test eens zien?

[pim]

Hiermee haal ik de TXT files op:
Copy (1) of testje.txt
Copy (2 of testje.txt
Copy (3 of testje.txt
etc.

PHP:

//bovenaan 
function getµsecs() 
{$gettime=explode(" ",substr(microtime(),1)); 
$time=substr($gettime[1],-6).$gettime[0]; 
return (float)$time; 
} 
$begin=getµsecs(); 


$x++;
echo"<textarea cols=50 rows=6>";
while($x < 200){

    include("Copy ($x) of testje.txt");

$x++;
}
echo"</textarea>";
//onderaan 
$end=getµsecs(); 
$difference=substr($end-$begin,0,8); 
echo"<br>"; 
echo "199 pagina's geparsed d.m.v. INCLUDES in $difference seconden"; 
?>

Hiermee het scriptje om de TXT files niet te includen, maar uit een MySQL TEXT veld te halen..

PHP:

<?
//bovenaan 
function getµsecs() 
{$gettime=explode(" ",substr(microtime(),1)); 
$time=substr($gettime[1],-6).$gettime[0]; 
return (float)$time; 
} 
$begin=getµsecs(); 


$x++;
while($x < 200){

mysql_connect("localhost", "pim", "") || error("geen verbinding");
mysql_select_db("pim");

    $result = mysql_query ("SELECT html FROM snelheid where id = $x");
    $row = mysql_fetch_row($result);
    
    echo $row[0];
    
    if(!$result){
    print("Er is iets fout gegaan met het invoegen: ".mysql_error());
    } 

$x++;

mysql_close;
}


//onderaan 
$end=getµsecs(); 
$difference=substr($end-$begin,0,8); 
echo"<br>"; 
echo "199 pagina's uit MySQL geparsed in $difference seconden"; 
?>

Deze scriptjes heb ik beide 10 keer gerunned..

[ Voor 10% gewijzigd door pim op 10-10-2003 16:38 ]

[djluc]

En als je een beetje hogere aantallen gaat gebruiken, bijvoorbeeld 10000? Zie je dan nog steeds geen verschil?

Variablen mogen trouwens buiten de quotes, dat schijnt ook performance te schelen, een heel klein beetje dan hè

[Cavorka]

Ja precies, 200 keer? Damn, dat is echt veel te weinig. 10000 keer, of 100000 (ff je timeouts regelen in je php.ini / httpd.conf). En in je test connect en deconnect je telkens, zal dit in realtime ook gebeuren, of zal je dan zowiezo (damn, Nederlands) al een DB connectie hebben (ivm met andere queries)? Best wel een issue.

De test van DiEana is IMHO totaal niet representatief, aangezien je een file gaat includen waar een regel in staat. Had dan tenminste gebenched of er verschil was tussen het includen van een bestand van 100 bytes of een van 80kb (zoals pim zelf deed).

[ Voor 21% gewijzigd door Cavorka op 10-10-2003 21:54 ]

[Grijze Vos]

Hangt ook nogal af van je mysql DB tables. Je kunt hash-tables maken om te cachen, dan zet ie ze alleen in het geheugen. Dat gaat wat sneller, dan een table op een HD. (Ervanuit gaande dat je daardoor niet gaat swappen als een gek.)

Je kunt op verschillende manieren veel tweaken hier en daar..

[Verwijderd]

Cavorka schreef op 10 October 2003 @ 21:53:De test van DiEana is IMHO totaal niet representatief, aangezien je een file gaat includen waar een regel in staat. Had dan tenminste gebenched of er verschil was tussen het includen van een bestand van 100 bytes of een van 80kb (zoals pim zelf deed).

De test (die van ACM, niet die van mij) was een benchmark van caching van queries in files, niet over het opslaan van volledige sites (vandaar jouw opmerking ivm. 80kb, veronderstel ik). De test is dan wel representatief, imho. En waarom verander je eerst niet even de 2 variabelen bovenaan niet (dan kan je meer tests en/of grote files/tabellen krijgen) en probeer je het zelf eens uit?
En wat bedoel je met 'waar een regel instaat'? Een array wordt geserialiseerd opgeslagen in een .txt en vervolgens weer opgevraagd. Als jij dat (zomaar) een regel vindt, mij goed

En als je een beetje logisch nadenkt, mysql is eigenlijk niets meer als het opvragen van files, maar dan met een hele backend er omheen. Tenzij mysql zelf gaat cachen (in geheugen bijvoorbeeld) zie ik totaal geen logica waarom mysql sneller kan zijn dan files, het doet zóóveel meer vooraleer hij de 'file' gaat openen.

Het grappige is dat deze test een zeer simpele query is (geen joins, groups, condities of wat je maar wil), dus wat zal het tijdverschil wel niet zijn bij meer ingewikkelde queries? Het opvragen van je data via mysql gaat dan zoiezo trager, maar van files blijft het nagenoeg gelijk!

nofi

[Cavorka]

Ja, ik had idd een beetje slecht gekeken. Pardon. Ik dacht dat je maar 1 regel vulde met data, dat het bestand dus maar een regel met 'Napoleon' erin was.

En als je een beetje logisch nadenkt, mysql is eigenlijk niets meer als het opvragen van files, maar dan met een hele backend er omheen. Tenzij mysql zelf gaat cachen (in geheugen bijvoorbeeld) zie ik totaal geen logica waarom mysql sneller kan zijn dan files, het doet zóóveel meer vooraleer hij de 'file' gaat openen.

Dat is dus de vraag! Ik denk dat je gelijk hebt, maar een 1:1 test van wat de TS wil zou natuurlijk uitkomst brengen (hij heeft het zelf gedaan, echter nog niet helemaal perfect (ant**** mode)). Uit de eerste resultaten blijkt dus dat het niets uitmaakt. Dat is best interessant, aangezien wat jij zegt echt geen poep is. Maar waar zit dan de 'vertraging' van het inlezen van files t.o.v. de data uit de DB te halen?