Don't be fooled by seeming simplicity. A lot of developers get comfortable with a certain way of designing a database for their web applications that they miss out on techniques they should rather employ to make things run faster and more efficiently. A lot of developers don't bear in mnd that the small site they are creating now might grow into something incredibly large and complex, and the database they designed has become bloated and doesn't scale well to meet the demands of the increased traffic.

This article hopes to provide web developers with a few techniques to help make their database and queries faster and more efficient.

1. Avoid Character Types

When you are designing a database, it is so easy to set all data types to the VARCHAR type as it can then contain any data you want; numbers or text. But character data is amongst the most inefficient data type you can get. If a field is only going to contain numbers, then make it one of the appropriate types (INT, DOUBLE, etc).

Also, wherever possible in your web development code, try to use numeric data types as opposed to characters. One of the most common things a script has to store are flags like whether someone answered yes or no to a question, etc. You could of course store it as 'Y' or 'N' but why not store it as 0 and 1?

The reason this makes a difference is when you have a database, for example, with over 500 000 entries, and are running a SELECT on that field, comparisons are processed a lot faster for numeric data types than character types. Also, if you need to return data to the calling script, numeric data is less memory intensive than character data. In addition, your web development language (PHP, ASP, etc) would also be able to process and perform functions on numeric data better than character data.

I am not trying to convince you never to use character data types. Sometimes it is a necessity, but if you can find ways to reduce the amount of character data processed by your SQL database, the better your server will cope.

2. Normalization

Normalizing a database is really quite a complex process. It is a process that describes a way to design a database structure to avoid repetition of data in your database and can lead to significant performance benefits if employed correctly. However, the entire process of normalisation is a bit beyond the scope of this article as it can fill books on its own, but any developer designing a database should seriously consider becoming knowledgable about normalisation and employing it in their own designs.

For a good tutorial on this process: http://www.keithjbrown.co.uk/vworks/mysql/mysql_p7.php

3. DateTime vs Timestamp fields

This actually relates to 1. a bit. The big difference to bear in mind here is that a field of type DATETIME is actually stored as a series of characters. A field of type TIMESTAMP is actually stored as an integer. So therefore, a more efficient way of storing dates is using the timestamp method. The timestamp has its drawbacks however. For one, you cannot store a date early than 1 January, 1970. Also, timestamps in your script will need recalculating to get to the character format. Because of this recalculation, it may not be better to store as timestamp. It really is a case of testing which format works better for your needs.

4. Use LIMIT where possible

In your queries, if you are doing a SELECT to a database and you only expect a certain number of results, using the LIMIT statement can speed your query up incredibly.

For example, if you have a table of users and you need to run a query to search for one users record, you can use a query like:

SELECT user_name FROM users WHERE user_id = 453;

This query is perfectly valid and will return the right result. But you also know there will only be ONE result. The query above will search the database, find what you want, but then still continue searching after that. It would run a lot faster if you could tell the query that once it has found what you are looking for to stop searching. LIMIT can do this, as this query shows:

SELECT user_name FROM users WHERE user_id = 453 LIMIT 1;

Imagine this scenario. You have a table called logins, that records every login from a user. It currently contains over 2 000 000 records, and you want to find the first time a user logged in. Now bear in mind that because this table inserts data over time, it is already sorted for by date. You could do the following query:

SELECT MIN(login_date) FROM logins WHERE user_id = 4876;

This will return the record you want, but SQL will now have to get all dates for that user, sort them and then return the lowest value to you. Our table is already date sorted simply because of the way it records data for us. So using LIMIT can be more effective:

SELECT login_date FROM logins WHERE user_id = 4876 LIMIT 1;

Because it is sorted, the first one will always be a users first login.

5. Avoid using LIKE

If you have tried to employ 1. above, then hopefully you will be in a scenario where you do not need to use LIKE all that much. LIKE is one of the most inefficient ways of searching a table. LIKE performs a text comparison search in a field and with no wildcards is as efficient as a direct comparison; i.e. WHERE name = 'Jane' is equivalent to WHERE name LIKE 'Jane'. It is when you start introducing the wildcard characters like '%' that things get really hairy.

If you do have to use LIKE, then at least try and make efficient use of the wildcards. These are '_' (underscore) and '%'. Let me explain all this with a real world example.

In a project I was involved in, we had a SQL database storing logs generated automatically from a mail server. Unfortunately, the mail server pretty much just dumped a very long string of text data into a field that contained the data we wanted. A script had to be written to find all logs that referred to a login by a user into the POP server. The only way we could do this was to search every record for a string in the msg field that had the text "User logged in" in it. The first query developed was something like this:

SELECT msg FROM logs WHERE msg LIKE '%User logged in%';

This query took on average of about 35 minutes to process. Obviously not an ideal situation. The way the LIKE worked here was that it had to parse through every single portion of each and every record in the msg field looking for text that matched "User logged in" anywhere in the text. We were able to determine eventually that the text "User logged in" occured at the end of that text in the msg field and so we altered the query:

SELECT msg FROM logs WHERE msg LIKE '%User logged in';

The '%' at the end was removed as we do not want to worry about text after because there is none. The query now only compares text to our string in the msg field at the end of the field and no longer parses through the entire piece of text stored in msg. The query now ran in under 2 minutes. (This was actually still too long, but how we optimised from there is a little beyond the scope of this article.)

Hopefully with all these elements put into practice on your next web development project, you can have a database that runs quickly, efficiently, uses as little resources as possible and wont grind to a halt when the load suddenly increases.

For newbie's starting out with an online venture the notion of building a site can be a challenging one. There is so much information out there it's hard to know where to start. What direction should you go in to yield the best results?

Where you really need to start is with yourself. Write down what you wish to accomplish and put together some form of outline that will help you stay focused. One thing is for sure when doing anything online and that is you will find yourself getting distracted here and there when seeking out information.

This happens to us all but if you have an outline posted in front of you then it will be easier to stay focused. To make life easier on yourself you can use a site builder to build your site.

The advantage of a site builder is that it will help you to construct your site without having to worry about the technical details. The good site builders will also help you to construct your web pages properly so that your reader can understand your message and the search engines can figure out what your pages are about.

This will help your site to get indexed and into the search engines which overtime will provide you with free targeted traffic and if your webpage's are set up right this traffic will make you money.

In some cases site builders come with hosting as well. Once again this provides you with less to worry about and you can get on with the task of building your site around your favorite topic.

To conclude keep it simple, stay focused and you will achieve your goals.

What is PHP?

PHP stands for PHP: HyperText Preprocessor, it is a server-side scripting language, and as the name goes, it is to create dynamic and interactive Websites for your visitors. Maybe you currently make your Websites in HTML? HTML alone cannot create dynamic Web pages, HTML is clearly defined as a static language, as it is always static and mainly is used for structuring (or styling, in some cases) a document (or a Web page, if you like).

What do we mean by server-side scripting?

You may already know, but HTML is a client-side language, so the browser translates the HTML code into "bytecode" that the computer can understand, and so the computer translates bytecode into what we can clearly understand, text, for example. Server-side scripting is a little different, a little bit more added to the story. As with PHP, server-side scripting languages have an interpreter inside a machine, that translates the code (in our case, PHP code) to HTML code (that the browser can understand), and then the same process will take place with the browser translating the HTML code to bytecode, and so forth. With server-side scripting languages, you don't need anything adding to your browser or computer, as the interpreter inside the machine that hosts the particular Website does most of the work.

What's the fuss with server-side scripting languages, then?

The thing that makes server-side scripting a must nowadays is because it can generate dynamic Web pages, but what do we mean by dynamic Web pages? Well, imagine you wanted to start a forum, and you used HTML. Okay, you used a form to submit the data and it is sent to your e-mail address, and you have to edit the static Web page every time you want a new post added. That, to me, would be the most annoying job of creating a Website. However, with PHP (or any other server-side scripting language, for that matter), can be completely automated, and you'd not have to edit your file even once! The thing that PHP does, is sends the form data to a different page, saves it in "pre-defined" variables (things that store a value), and using something called a "while loop" that continually loops all the posts saved in the Web page - and that's it! PHP stores the posts in a MySQL database (something that holds data, if you like, like member accounts, etc) and uses that as long-term memory.

But if we're talking about server-side scripting languages, what makes PHP different from the rest? Well, simply put, PHP is probably the best thing that has come into the server-side scripting genre. If you have heard about other scripting languages like Perl or ASP/ASP.NET, you'll come to find that they are extremely hard to learn from. Put it this way, the majority of Web developers that use ASP.NET, for example, are those who have come from a different programming background, like have known VBScript, or other languages that's in relation to ASP.NET, the same with Perl. The difference between PHP and the rest, is PHP is incredibly easy to learn, especially for the newbies towards this industry, and PHP has took several steps to ensure an easy introduction to those newbies to the world of programming. Let's do an example, lets see which is the easiest to understand, out of PHP, VBScript and Perl, by doing a simple "Hello World" program, that outputs text to a Web page:

PHP:

echo "This is some text that'll be shown in a Web page...";

VBScript/ASP.NET:

Response.Write("This is some text that'll be shown in a Web page...");

Perl:

#!/usr/bin/perl

print "content-type: text/html nn";

print "This is some text that'll be shown in a Web page...";

Okay, now I am not going to say things like "well, obviously PHP is the easiest to understand" - as obviously, we all have different preferences, but what I can say is, that they all do the same thing. Which seems the most logical to you? In my opinion, the two most logical ones for me is PHP and VBScript/(ASP.NET).

Now it's up to you which one you want to go ahead with, experiment which one is best for you, after all, we all have dfferent tastes.

Good luck!

Below are a few resources to get started with PHP:

# - w3schools.com

# - php.net

# - mysql.com