Julius Beckmann » MySQL

PHP/MySQL: Warning: mysql_query(): Unable to save result set ...

Julius — Mon, 18 Jan 2010 15:08:36 +0000

Today i found a error in a tiny script i was working on.
The error Message looked like this:

Warning: mysql_query() [function.mysql-query]: Unable to save result set in /var/www/example.php on line 55

First i found a few hints about repairing or optimizing MySQL tables, but this did not work out.
After a few debugging outputs a realized that the query was not properly written.

The original query looked like this:

SELECT id

FROM `table` 

WHERE `order` >

(

  SELECT `order` 

  FROM `table` 

  WHERE active = 1

)

LIMIT 1;

As you can see the query as a non correlated subquery. It worked fine nearly all the time, but only when the subquery returns only zero or one lines. If there are more lines MySQL generates the "Unable to save result set", because `order` cant be bigger then 2 resultvalues at the same time.
The right query looks like this:

SELECT id

FROM `table` 

WHERE `order` >

(

  SELECT `order` 

  FROM `table` 

  WHERE active = 1

  LIMIT 1

)

LIMIT 1;

A extra LIMIT 1 makes the deal perfect, and saved a little bit of my day.

Benchmark: APC vs. MySQL MEMORY fetching Speed

Julius — Wed, 02 Sep 2009 15:07:44 +0000

I once wrote a article about APC and MySQL MEMORY table caching and found out that APC needs very much memory compared to MySQL MEMORY. Now i did a short benchmark to check out the fetching speed of these two solutions with a interesting result.

Script

First, the benchmark script:

// Simple test script benchmarking cache access times

// of APC and MySQL MEMORY

// by: Julius Beckmann (juliusbeckmann.de)
// Config

$n = 10000;

$newline = "
\n";
// Init benchmark array with $n entrys

$array = array();

$i = 0;

while($i++ < $n) {

  $array[] = rand(0,999999);

}
echo "Testarray has ".count($array)." random integer entrys".$newline;

// Check direct array access time

$time_start = microtime(true);

$i = 0;

while($i < $n) {

  $devnull = $array[$i++];

}

$time_end = microtime(true);

$time = $time_end-$time_start;

echo number_format($time, 3, '.', '')

  ." seconds - direct array access".$newline;

// Adding these array values to APC

foreach($array as $k => $v) {

  apc_store('test_'.$k, $v);

}

// Benchmarking apc_fetch

$time_start = microtime(true);

$i = 0;

$count = count($array);

while($i < $count) {

  $devnull = apc_fetch('test_'.$i++);

}

$time_end = microtime(true);

$time = $time_end-$time_start;

echo number_format($time, 3, '.', '')

  ." seconds - apc_fetch()".$newline;

// Deleting APC entrys

foreach($array as $k => $v) {

  apc_delete('test_'.$k);

}

// Benchmark mysql
// Connect

$link = mysql_connect('localhost', 'username', 'password');

if (!$link) die('Not connected : ' . mysql_error());

$db_selected = mysql_select_db('database', $link);

if (!$db_selected) die ('Can\'t use foo : ' . mysql_error());

// Adding these array values to mySQL Memory table

/* TABLE:

 CREATE TABLE `test_memory` (

`key` INT UNSIGNED NOT NULL ,

`value` INT UNSIGNED NOT NULL

) ENGINE = MEMORY 

*/

foreach($array as $k => $v) {

  mysql_query('INSERT INTO test_memory (`key`,`value`) VALUES ('.$k.', '.$v.');');

}

// Benchmark mysql memory table

$time_start = microtime(true);

$i = 0;

$count = count($array);

while($i < $count) {

  list(,$devnull) = mysql_fetch_row(mysql_query('SELECT * FROM `test_memory` WHERE `key` ='.$i++.';'));

}

$time_end = microtime(true);

$time = $time_end-$time_start;

echo number_format($time, 3, '.', '')

  ." seconds - mysql_query from MEMORY table FIRST RUN".$newline;

// Benchmark a second time to check for mysql caches

$time_start = microtime(true);

$i = 0;

$count = count($array);

while($i < $count) {

  list(,$devnull) = mysql_fetch_row(mysql_query('SELECT * FROM `test_memory` WHERE `key` ='.$i++.';'));

}

$time_end = microtime(true);

$time = $time_end-$time_start;

echo number_format($time, 3, '.', '')

  ." seconds - mysql_query from MEMORY table SECOND RUN".$newline;

// Trunc memory table 

mysql_query('TRUNCATE TABLE test_memory;');
?>

Result

Output of the script:

Testarray has 10000 random integer entrys
0.002 seconds - direct array access
0.011 seconds - apc_fetch()
1.304 seconds - mysql_query from MEMORY table FIRST RUN
1.167 seconds - mysql_query from MEMORY table SECOND RUN

The measured times are only fetching times. Fetching should by done much often in reality than storing, so it is way more important.

As you can see the direct access is the fastes. APC is ony 5 times slower than direct access. That is very fast compared to the MySQL equivalent. MySQL took about 100 times longer than APC. This result is astonishing. I though MySQL might be about 5 or 10 times slower then APC, but 100 is very much.
I also let the MySQL select run twice to check for buffers that might come in but no better result.
A "stangl" already mentioned, the overhead produced by MySQL for querying, parsing, and returning is very big and slow compared to APC.

Conclusion

If you need only very few variables to store, try APC first. MEMORY TABLES might be handy when you need to save more than APC can handle effictively.

If anybody can find a mistake i did, please let me know. Maybe MEMORY tables are not that slow as my benchmark turned out.

PHP - APC oder MySQL MEMORY Table für temporären Cache?

Julius — Wed, 12 Aug 2009 08:45:33 +0000

Bei einem aktuellen Projekt wurde APC eingesetzt um tausende kleinere Variablen zu cachen da es sich nicht lohnen würde diese in einer persistenten Datenbank zu speichern. Da der 30MB große APC Cache jedoch recht schnell voll wurde habe ich ein paar Nachforschungen angestellt, dabei bin ich zu dem Schluss gekommen dass APC für das Speichern von einzelnen kleinen Variablen viel zu viel Speicher verschwendet.

Code - APC Test

Um zu testen wie viele Variablen in den 30 MB großen SHM Cache von APC passen haben ich in einer Schleife wie dieser einfach den ganzen Speicher vollgeschrieben:

$i = 0;

while($i++ &gt;= 0) {

  if(!apc_store('test_'.$i, $i)) {

    echo "Could save $i variables in 30 MB APC Cache\n";

    $i = -1;

  }

}

Das Script hat mir ausgegeben dass rund 151000 Variablen gespeichert werden konnten. Das heißt jede Variable hat rund 207 Byte Speicher verbraucht (!). Dafür dass nur ein simpler Integer gespeichert wurde ist dies verdammt viel.

Alternative: MySQL MEMORY Tabelle

Eine Mögliche Alternative die mir in den Sinn kam war die MySQL MEMORY Engine welche seine Daten im RAM des Computers lässt und keine Schreiboperationen auf der Festplatte ausführt. Diese MEMORY Tabellen sind auch in ihrer Größe beschränkt welche per Default meist bei 16 MB liegt.

Als Tabellenstruktur habe ich etwa folgende gewählt:

CREATE TABLE memory_test (

`user_id` integer(10) NOT NULL,

`user_data` integer(10) NOT NULL

} ENGINE=MEMORY;

Nach dem Einfügen des ersten Datensatzes wir die Tabelle 124 KB groß, doch dies ändert sich bis bei mir aktuell 3300 Einträge nicht. Die MySQL MEMORY Engine scheint Blöcke a 124 KB zu reservieren.
Nach dem Einfügen von 3000 Einträgen ist die Tabelle immernoch 124 KB groß was für mich bedeutet dass in der MEMORY Tabelle ein Datensatz weniger als 40 Byte verbraucht.

Vergleich

Der Vergleich zwischen 207 Byte in APC und < 40 Byte in MySQL MEMORY spricht für sich. Da die Zugriffsgeschwindigkeit in APC und MySQL MEMORY etwa gleich schnell ist sollte man wenn man die Möglichkeit hat MEMORY Tabellen zu benutzen dies auch machen.
Es wäre vielleicht ratsam um die apc_* Funktionen andere Wrapper Funktionen zu schreiben so dass man diese im Fall eines Wechsels von APC zu MEMORY einfach austauschen kann.

Stolpersteine

Es gibt jedoch auch kleine Stolpersteine die rumliegen können:

apc_store() bietet es an eine ttl (Time To Live) mitzugeben nach dem der Cache-Eintrag verfallen soll. Dies ist in einer MEMORY Tabelle mit einer extra Spalte mit einem Timestamp zu realisieren welche zwar wieder Speicher verbraucht, aber wir sicherlich immer noch unter den 207 Byte von APC bleiben.

Der Zugriff in einer MEMORY Tabelle ist auch ohne INDEX schnell, doch je nachdem wie viele Einträge gespeichert könnte es sinnvoll sein einen Index zu erzeugen welche dann jedoch den Speicherverbrauch der Tabelle schlagartig verdoppelt. Jeder 124 KB Speicherblock hat anscheinend einen weiteren 124 KB Index Speicherblock wenn ein Index benutzt wird.

Was jedoch für die Nutzung von MEMORY spricht ist dass der Inhalt einer MEMORY Tabelle nur bei einem MySQL Server Neustart zwangsläufig geleert wird. Der APC Cache wird bei einem Webserver-Neustart geleert.

Nachtrag zu APC

Zwar lassen meine Ausführungen die Nutzung von APC in einem nicht alzu guten Licht darstehen, doch dies spricht nicht gegen eine allgemeine Verwendung von APC da meine Tests sich nur auf das Speichern von Variablen beziehen. Als Opcode Cache ist es hervorragend und bietet dazu noch andere nützliche Funktionen.