CODEWITHSUNDEEP
phpfor-loop
Aayush Aarwal
Aayush Aarwal

Reputation: 704

Optimizing for loop in php

I have been running a foreach loop 1000 times on php page. The code inside the foreach loop looks like below:

$first          = mysql_query("SELECT givenname FROM first_names order by rand() LIMIT 1");
$first_n        = mysql_fetch_array($first);
$first_name     = $first_n['givenname'];
$last           = mysql_query("SELECT surname FROM last_name order by rand() LIMIT 1");
$last_n         = mysql_fetch_array($last);
$last_name      = $last_n['surname'];
$first_lastname = $first_name . " " . $last_name;


$add     = mysql_query("SELECT streetaddress FROM user_addresss order by rand() LIMIT 1");  
$addr    = mysql_fetch_array($add);
$address = $addr['streetaddress'];

$unlisted  = "unlisted";
$available = "available";

$arr = array(
    $first_lastname,
    $address,
    $unlisted,
    $available
);

Then I have been using array_rand function to get a randomized value each time the loop runs:

<td><?php echo $arr[array_rand($arr)] ?></td>

So loading the php page is taking a really long time. Is there a way I could optimize this code. As I need a unique value each time the loop runs

Upvotes: 0

Views: 163

Answers (3)

Orangepill
Orangepill

Reputation: 24645

You should switch to using either mysqli or pdo if your host supports it but something like this should work. You will have to determine what you want to do if you don't have a enough record in either of the tables though (array_pad or wrap the indexes and restart)

function getRandomNames($qty){
    $qty = (int)$qty;
    $fnames = array();
    $lnames = array();
    $address = array();

    $sel =mysql_query("SELECT givenname FROM first_names order by rand() LIMIT ".$qty);
    while ($rec = mysql_fetch_array($sel)){$fnames[] = $rec[0]; }

    $sel =mysql_query("SELECT surname FROM last_name order by rand() LIMIT ".$qty);
    while ($rec = mysql_fetch_array($sel)){ $lnames[] = $rec[0]; }

    $sel =mysql_query("SELECT streetaddress FROM user_addresss order by rand() LIMIT ".$qty);
    while ($rec = mysql_fetch_array($sel)){ $address[] = $rec[0]; }

    // lets stitch the results together
    $results = array();
    for($x = 0; $x < $qty; $x++){
       $results[] = array("given_name"=>$fnames[$x], "surname"=>$lnames[$x], "streetaddress"=>$address[$x]);
    }
    return $results;
}

Hope this helps

UPDATE

Based on Sébastien Renauld's answer a more complete solution may be to structure the queries more like 

"SELECT givenname from first_names where id in (select id from first_names order by rand() limit ".$qty.")";

Upvotes: 0

Atle
Atle

Reputation: 5447

It has already been explained why ORDER BY RAND() should be avoided, so I simply provide a way to do it with some faster queries.

First get a random number based on your table size:

SELECT FLOOR(RAND()*COUNT(*)) FROM first_names

Second use the random number in a limit

SELECT * FROM first_names $pos,1

Unfortunately I don't think there is any way to combine the two queries into one.

Also you can do a SELECT COUNT(*) FROM first_names, store the number, and generate random $pos in PHP as many times as you like.

Upvotes: 0

S&#233;bastien Renauld
S&#233;bastien Renauld

Reputation: 19662

The problem is not your PHP foreach loop. If you order your MySQL table by RAND(), you are making a serious mistake. Let me explain to you what happens when you do this.

Every time you make a MySQL request, MySQL will attempt to map your search parameters (WHERE, ORDER BY) to indices to cut down on the data read. It will then load the relevant info in memory for processing. If the info is too large, it will default to writing it to disk and reading from disk to perform the comparison. You want to avoid disk reads at all costs as they are inefficient, slow, repetitive and can sometimes be flat-out wrong under specific circumstances.

When MySQL finds an index that is possible to be used, it will load the index table instead. An index table is a hash table between memory location and the value of the index. So, for instance, the index table for a primary key looks like this:

  id      location
  1         0 bytes in
  2         17 bytes in
  3         34 bytes in

This is extremely efficient as even very large index tables can fit in tiny amounts of memory.

Why am I talking about indices? Because by using RAND(), you are preventing MySQL from using them. ORDER BY RAND() forces MySQL to create a new random value for each row. This requires MySQL to copy all your table data in what is called a temporary table, and to add a new field with the RAND() value. This table will be too big to store in memory, so it will be stored to disk.

When you tell MySQL to ORDER BY RAND(), and the table is created, MySQL will then compare every single row by pairs (MySQL sorting uses quicksort). Since the rows are too big, you're looking at quite a few disk reads for this operation. When it is done, it returns, and you get your data -at a huge cost.

There are plenty of ways to prevent this massive overhead SNAFU. One of them is to select ID from RAND() to maximum index and limit by 1. This does not require the creation of an extra field. There are plenty of similar Stack questions.

Upvotes: 2

Related Questions