There are several useful QoS parameters, although not all are as easily measured as e.g. 99.98% uptime, which is easily derived – 99.98% of the time, your server is available.
Some other useful metrics:
What sort of bandwidth do they support? How about if it’s a shared pipe and they’ve multiple high-volume clients? You’re unlikely to get an honest answer to this from the vendor.
If you’re on a shared host, what sort of competition for resources will you have on the box? Again, this is competitive information, so you’re unlikely to get an honest response.
How independent is each application? i.e. if another application on a co-hosted box loops MySQL, will your app suffer?
How often do they upgrade dependencies, and does that affect their 99.98% uptime?
Then there are the fluffy not-entirely-QoS related hosting problems:
Will they do your backups etc.?
How responsive are they to queries? Do they have a guaranteed response time e.g. 3 hours from first email to first response, 24/7?
Are they efficient? Have they resolved issues within a useful timeframe? A quick response-time is nice and feelgood, but if they don’t fix the problem, that’s not quite so good!
Are they patient with you when you suggest issues, but due to your own technical background are slightly off-base?
I’ve come across a lot of people having a problem when representing data from their databases; hierarchical data provides us with a particular problem when displaying the relationships and containers required.
An example of hierarchical data
As an example, let’s say you have forums within categories. The category “Web Programming” may have forums like “PHP”, “JavaScript” and so on, so we want to list each forum under each category. The problem here is that you’ll have:
a table for categories
one for forums (with a foreign key for categories)
one for posts, with a foreign key for forums
and probably one for comments.
This fits quite neatly into a hierarchy: each comment belongs to a post, which belongs to a forum, which belongs to a category.
Using multiple resultsets
If you want to display the Categories with Forums under them in your page, one way to do this is by setting up multiple resultsets, each focusing on one level of the hierarchy. To achieve this, you’d need to get a resultset for the categories first, and then iterate over this list with another loop for your forum list.
The following code is an example of iterating using nested queries:
$cat_rs=mysql_query("select id, name from categories");while($cat_row=mysql_fetch_array($cat_rs)){// print category name from $cat_row[1]$forum_rs=mysql_query("select name... "."from forums "."where cat_id = '".$cat_row[0]."'");while($forum_row=mysql_fetch_array($forum_rs)){//print forum stuff}}
Although this matches the hierarchical nature of the data, and is pretty straightforward and intuitive to understand, it is somewhat inefficient; it issues a select statement for each category, plus one to list the categories in the first place. If there are many categories, the page might take some time to load as all queries are issued and processed.
Using a SQL JOIN: a single resultset
Another way to solve the problem would be to retrieve all relevant data in a single resultset, and use PHP to iterate over the rows, deciding on when to print each individual section.
A join will give you a single recordset with the category in one column, and the forum in another, giving you many rows for a single category.
$join_rs=mysql_query("select c.id, c.name, f.name,... "."from categories c inner join forums f "."on c.id = f.cat_id "."order by c.id");// this line is crucial$current_category="";while($join_row=mysql_fetch_array($join_rs)){if($join_row[0]!=$current_category){//set up new category headings here$current_category=$join_row[0];}//print the forum stuff in the current category}
The PHP is a bit more complex, because you have to close divs or tables correctly, within the loop. The order by line in the above example is vital, because without it, the categories may be dotted throughout the resultset. As we want all forum data related to a single category to appear together, we want rows belonging to that category to be adjacent in the resultset. The order by clause achieves this.
Despite the complexity, there are still benefits to this approach. The earlier example was simple and intuitive, using nested queries for each parent element. On the other hand, in this example we’ve only issued one select statement, so the page is likely to load more quickly, given that the number of round trips to MySQL will be substantially fewer.
“Asynchronous Javascript And XML” is a mouthful for a web technology that’s in wide use these days. Simply put, it lets a web page download more content without reloading the page, and relies on a magic Javascript object called an XmlHttpRequest to do the work of requesting more data in the background, so it can fill in things on the page.
So, fiddling with AJAX, let’s do a little Hello Worlding:
Here’s a button, that when clicked, calls the “startRequest()” function in some javascript behind the entry:
<divid="ajaxtest"><em>(although you can't see it as a separate div,
this text will be replaced)</em></div>
(although you can’t see it as a separate div, this text will be replaced)
Go on, watch the div text above, and click the button.
Here’s the javascript:
var xhr;if(window.XMLHttpRequest){
xhr =new XMLHttpRequest();}elseif(window.ActiveXObject){// in case it's IE
xhr =new ActiveXObject("Microsoft.XMLHTTP");}// set up the callback
xhr.onreadystatechange=function(){
myDiv = document.getElementById("ajaxtest");if(xhr.readyState== 4){if(xhr.status==200){
myDiv.style.background="green";
myDiv.innerHTML= xhr.responseText;}else{
myDiv.innerHTML="Error: "+ xhr.status;}}}function startRequest(){
xhr.open('GET','ajaxtest.php',true);
xhr.send(null);}
Firstly, the code sets up a variable xhr, which contains the magical object. This is the XmlHttpRequest object, and is responsible for communicating from the live Javascript to the back end server.
The request object is first set up at the script’s execution, but the only thing we do with it is tell it what to do when its “ready state” changes; that is, when the request shifts from not initialised, to set up, to having been sent, to being in process, to completion.
These states are numbered 0-4 respectively. Hold that thought; we’ll use it later. Suffice to say that, on the script’s execution, we now have an otherwise anonymous function that will be called when the ready state changes.
Now, in order for something interesting to happen, we click the button. That kicks off startRequest(), which in turn sets up a asynchronous request to ajaxtest.php, and submits it with no parameters (that’s the null). Asynchronous means we don’t sit around waiting for a response, and that’s why we need the readystatechange callback function.
So, when something interesting happens to the xhr object, the ready state changes (e.g. when we get a response back after sending our request). The browser then executes the anonymous function: first, the function checks that the request is complete – remember Ready State 4 above? don’t forget the ready state changes several times per request. We only want to read the response text once, at completion. Once the function has checked the request has been successfully completed, it then uses the xhr’s response-text to fill in the div called “ajaxtest”.
