Comparative analysis of the efficiency of reading and writing files in PHP and reading and writing databases

set_time_limit(0);
function fnGet($filename)
{
$content = file_get_contents($filename);
return $content;
}
function fnGetContent($filename)
{
$content = fnGet($filename);
return $content;
}
$times=100000;
echo '数据库查询结果：';
//---------------------------------
$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
$res=$dbcon->mydb_query("SELECT log_Content FROM blog WHERE log_ID='1'");
$row=$dbcon->mydb_fetch_row($res);
$content=$row[0];
}
echo 'fetch_row '.$times.' 次时间：'.(fnGetMicroTime()-$begin).'秒';
//---------------------------------
$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
$res=$dbcon->mydb_query("SELECT log_Content FROM blog WHERE log_ID='1'");
$row=$dbcon->mydb_fetch_array($res);
$content=$row['log_Content'];
}
echo 'fetch_array '.$times.' 次时间：'.(fnGetMicroTime()-$begin).'秒';
//---------------------------------
$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
$res=$dbcon->mydb_query("SELECT log_Content FROM blog WHERE log_ID='1'");
$row=$dbcon->mydb_fetch_object($res);
$content=$row->log_Content;
}
echo 'fetch_object '.$times.' 次时间：'.(fnGetMicroTime()-$begin).'秒';
//---------------------------------
$dbcon->mydb_free_results();
$dbcon->mydb_disconnect();
fnWriteCache('test.txt',$content);
echo '直接读文件测试结果：';
//---------------------------------
$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
$content = fnGetContent('test.txt');
}
echo 'file_get_contents直接读'.$times.'次时间：'.(fnGetMicroTime()-$begin).'秒';
//---------------------------------
$begin=fnGetMicroTime();
for($i=0;$i<$times;$i++)
{
$fname = 'test.txt';
if(file_exists($fname))
{
$fp=fopen($fname,"r");//flock($fp,LOCK_EX);
$file_data=fread($fp, filesize($fname));//rewind($fp);
fclose($fp);
}
$content = fnGetContent('test.txt');
}
echo 'fopen直接读'.$times.'次时间：'.(fnGetMicroTime()-$begin).'秒';

Query results for 4K size data: fetch_row 100000 times time: 16.737720012665 ​​seconds fetch_array 100000 times time: 16.661195993423 seconds fetch_object 100000 times time: 16.775065898895 seconds

Directly read file test results: file_get_contents read directly 100000 times time: 5.4631857872009 seconds fopen reads directly 100000 times time: 11.463611125946 seconds

Plastic ID query results: fetch_row 100000 times time: 12.812072038651 seconds fetch_array 100000 times time: 12.667390108109 seconds fetch_object 100000 times time: 12.988099098206 seconds

Directly read file test results: file_get_contents read directly 100000 times time: 5.6616430282593 seconds fopen direct reading time 100000 times: 11.542816877365 seconds

Test conclusion: 1. Reading files directly is more efficient than database query, and the connection and disconnection time is not included in the article.

2. The larger the content read at one time, the more obvious the advantage of reading files directly (the time to read files increases slightly, which is related to the continuity of file storage and cluster size). This result is exactly what Tianyuan expected. On the contrary, it shows that MYSQL may have additional operations for reading larger files (the time has increased by nearly 30% twice). If it is just a simple assignment conversion, the difference should be small.

3. It can be inferred that the database efficiency will only get worse without testing when writing files and INSERT.

4. If a small configuration file does not need to use database features, it is more suitable to be stored in a separate file. There is no need to create a separate data table or record. It is more convenient to store large files such as pictures and music in files. It is more reasonable to only put index information such as paths or thumbnails into the database.

5. If you only read files in PHP, file_get_contents is more efficient than fopen and fclose. Excluding the time required to determine the existence of this function, it will take about 3 seconds less.

6. fetch_row and fetch_object should be converted from fetch_array. I have not seen the source code of PHP. From the execution alone, it can be seen that fetch_array is more efficient. This seems to be contrary to what is said on the Internet. Assuming that the program efficiency is equivalent to that of key processes and does not include caching and other measures, reading and writing any type of data is not as fast as directly operating files. Regardless of the MSYQL process, the "file" must be read from the disk in the end. (Equivalent to the record storage area), so of course the premise of all this is that the content is read-only and has nothing to do with any sorting or search operations.