PHP is the world’s most popular web development language. Started by Danish-Greenlandic programmer Rasmus Lerdorf in 1995 it is now installed on more than 20 million websites and 1 million web servers and counting.

It is estimated that for every 100 PHP developers, there are 42 Perl developers, 12 Python developers and 4 Ruby developers – PHPs popularity is the central reason why you should consider learning it above all others.

PHP is the basis of Content Management Systems such as Drupal, Joomla and WordPress so gaining a knowledge of PHP would help you in using these scripts.

Presumably your are already proficient with CSS and HTML and want to take your web creativity to another level. If you aren’t, then stop right here. It’s unthinkable to tackle PHP without a firm grounding in HTML and a good knowledge of CSS would be extremely useful.

You don’t have to have a complete knowledge of HTML in order to learn PHP but you certainly need to know the basics – the rest you will pick up in tandem with PHP. For instance, if you use Content Management Systems all the time you’ll unlikely to be that familiar with coding forms, but HTML forms are an essential part of PHP and you’ll need to be able to create them quickly and without fuss.

Learning PHP is as hard as you can imagine it to be. You need time and lots of patience and preferably a reality you need to escape from for an inordinate amount of time. It’s a good idea to pace yourself and set a two year framework in order to become familiar with the core of the language.

Prepare yourself for headaches and frustration and a slow, boring learning curve as it’s on about the same thrill level as a crossword or Sudokus puzzle.

You must be familiar with the multitude of Photoshop net tutorials out there – you know, the ones that engage you with a step-by-step guide and lots of pretty pictures. Well there is nothing comparable in PHP.

It may be unfair to compare photo manipulation software to a programming language, but even the Ruby crew manage to add a bit of bling to their learning process.

Of course, there is satisfaction at creating your first form or web application – to actually create a working item is a tremendous achievement when you are starting out.

So what makes a good PHP programmer? It is the ability to write effective, secure code quickly. Effective means using as little code as possible for the task at hand as well as learning which code is the least wasteful on your server resources (this is technically called refactoring). Secure means that your code is as safe as possible from malicious users and crackers.

To be a quick PHP coder means that you have a thorough knowledge of the syntax and functions as well as library of code which you have created and testing on live websites and that you can bring into new web developments.

You’ll often read a reference to “clean code” amongst PHP heads (and all other code writers for that matter) and above is essentially what they mean by this term.

If you really want to learn PHP though I can guarantee one thing: that you will succeed if you have enough time and are determined enough.

Nobody is born to code PHP – expertise will come about through you applying yourself.



By: Andy Johnson

About the Author:

Self-Taught PHP/MYSQL: a simple Page Counter

This article is a short introduction to PHP and MySQL using the example of a simple page counter. I will illustrate creating the database in MySQL, connecting to the database from the PHP script, querying the database for information, displaying the information in a web page, and writing the information back to the database. As always, the fastest way to master the process is to jump right in with the code, look it over and use it. We’ll make a MySQL database to store the page names and the number of page views, and use PHP to increment and display the count on a web page. First here is all of the code, and then I’ll go over it in detail:

This goes into a file called “pagecounter.php”



You’ll no doubt have noticed that the script “includes” another, so without further delay here is the “connect.php” file:



The pagecounter.php script needs a database to operate on. Just briefly, here’s how to create it.

Creating the database:

Log in to MySQL at your Unix prompt (which might be #):

# mysql –uYourUserName –pYourPassword

At the MySQL prompt enter these commands:

mysql> create database pages;

mysql> use pages;

mysql> create table counter (pagename varchar(60),hits int, stamp timestamp);

mysql> quit;

Naturally you can create the database and table with utilities or web-based interfaces, but doesn’t it seem simpler to just enter three commands?

If you just wanted some code for a simple counter, this is all you need. Put this text into an SHTML web page, or this text into a php web page, copy the above two files into the same directory, and you’re done.

The first thing you’ll have noticed about the scripts are the dollar signs ($). All variables in PHP scripts start with a $. Anything starting with a $ is a variable. Instructions – statements and functions – end with a semicolon (;). starts the script and it ends with . When your script is hosed, look at these first.

Details about the pagecounter.php script

Line 1

include_once “connect.php”;

The first line in the script is just what it appears to be. It includes whatever is in the file “connect.php”. The “_once” means that it’s only included once, even if you had the line twice in the script. The reason I’ve separated it out is that it’s all the connection stuff to the database. All the php/Mysql scripts will need it, it’s always the same, so you can just put it by itself and use the include function.

Line 2

$pagename=$_SERVER["REQUEST_URI"];

The next line creates a variable called $pagename and sets the value to a special pre-defined variable $_SERVER["REQUEST_URI"]. The brackets [ ] are used by arrays in php. $_SERVER is a pre-defined array of headers and paths. This particular one is the name of the file that accesses the script, i.e., the name of the page that the counter is in.

Line 3

$result=mysql_query(“Select * from counter where pagename=’$pagename’”);

All the database work is done with mysql_query, which sends an SQL command string to MySQL, after you’ve already logged in and connected to the database with the connect.php script. “Select * from counter where pagename=’$pagename’” replaces $pagename with its value. But there’s a quirk here – the single quotes have to be inside the double quotes. If I had it the other way around, with the single quotes outside, the query would be for the text “$pagename” instead of the value. $result is the result set. It can be any name but in tutorial scripts it’s always $result, so it is here.

Line 4

if (mysql_num_rows($result)==0){

The fourth line is the php version of “if-then”. It simply checks whether there are any results from the query in line 3. The syntax is representative of php coding in general so it’s a good place to start. The curly brackets { } are used to group instructions. The curved brackets ( ) are used for the “if” condition. Everything inside the curly brackets will be executed if the “if” condition is true. PHP uses double equals == for comparison; if I had used only a single equal sign it would try to set mysql_num_rows to 0, which wouldn’t work for our purposes. A missing equal sign is the second thing to look for when your script is hosed and it’s not missing a $ or ;.

Line 5

mysql_query(“insert into counter (pagename,hits) values (‘$pagename’,'0′)”); }

Inside the brackets, which only happens when line 4 finds no records of the page we searched for, the instruction creates a new record with the page’s name and zero for the hit count. Although mysql_query is a function, it doesn’t necessarily need a variable $result= in front of it. That’s optional in PHP if you don’t care about the return value.

The closing curly bracket } from the “if” statement comes here, since we only needed one statement to create our record.

Line 6

$count=mysql_result($result, 0, “hits”);

mysql_result fetches the actual data from the result set. You specify the result set (from mysql_query), the row number (0), and the column name (“hits”). This is a little confusing at first since to get here took four steps: 1) log into MySQL, 2) connect to the database, 3) select data from the table, and 4) fetch a particular piece of the data. Putting the repetitive first two steps into an include file where you can more or less forget about them makes it more intuitive: use SQL to select data with mysql_query, and then retrieve data with mysql_result.

Line 7

$count=$count + 1;

Just adds one to the count variable. This is the count of the page views of the page requesting the script.

Line 8

mysql_query (“update counter set hits=$count where pagename=’$pagename’”);

As with Line 5 we send an SQL command directly to MySQL. This one updates the count for just the page matching the variable $pagename.

Line 9

echo “Page Count: “.$count;

The echo function writes text to a web page, in this case the text “Page Count: “ followed by whatever value is in $count. The period in between is the PHP concatenation operator: it simply adds the two strings together. Echo sees it as one string and outputs it.

Details about the connect.php script:

All this script does is connect to the MySQL server and select the Database.

Line 1

$host=”localhost”;$user=”YourUserName”;$password=”YourPassword”;$dbase=”pages”;

These are the inputs for the connect and select_db functions. Naturally you can insert the values into the functions on line 3 and 4 and eliminate this line, but it’s simpler to change later (when you re-use this code for example) if you just list them out at the top. The host and dbase won’t need to be changed in this example. The user and password are specific to your MySQL setup. As shown here you can put as many statements on one line as you want; PHP doesn’t care.

Line 2

// change the user and password to your MySQL user and password

The double slashes // denote a comment line that is ignored by php. Each comment line needs the slashes.

Line 3

$connect = mysql_connect($host,$user,$password);

You log into your MySQL with the mysql_connect command. You would change the host from “localhost” to the database server if you were accessing MySQL from another server, provided you’ve set up the access rights for the specified user/

Line 4

mysql_select_db($dbase,$connect);

Since we can have multiple databases in the MySQL server, we have to select one before sending SQL statements to it. As I mentioned earlier, this part is repetitive, and once it’s in this file and working you can forget about it.

In this tutorial we’ve examined a simple but functional web page counter implemented with PHP/MySQL. We examined the basic syntax of PHP statements and variables, the PHP “include” function and “if” control function, and the fundamental PHP MySQL functions mysql_connect, mysql_select_db, mysql_query, mysql_num_rows, and mysql_result. For further reference the reader should bookmark http://dev.mysql.com/doc/refman/6.0/en/index.html and http://us.php.net/manual/en/funcref.php .

Bill Hamilton is a former Database Administrator for United News and Media, and VNU inc. He currently operates several php/mysql driven websites including Gemstones and Beads



By: Bill Hamilton

About the Author:

Crop Images Contextually

Crop images contextually for faster downloads and higher impact. By cropping maximally and resizing you can convey meaning without slowing down your web pages.

However, we’ve seen many sites that either use HTML’s width and height attributes to resize larger images, or minimally crop and resize images to lose vital information. A better way to create images optimized for the Web is to crop them contextually.



Contextually Cropping

What is cropping contextually? Many times digital images shot for Web use have a border of useless space around the object(s) of interest. Rather than crop to just the film or chip’s border, crop contextually down to the minimum dimensions that still convey the meaning or context of your image.

Note how the author is now more recognizable in the cropped version (behind the sunscreen) and the lettering is larger and more legible. Most importantly, the image has more impact, with the subject taking up more of the frame. This cropped image could be shown with a smaller dimension, saving file size.

Resize to a Smaller Thumbnail

Once you’ve got your image maximally cropped, resize and sharpen it to create a smaller thumbnail image. To give the reader more detail, you can provide a larger version (cropped or uncropped) of the image linked to that thumbnail.

This two-step process of cropping maximally and resizing is what Jakob Nielsen calls “relevance-enhanced image reduction.” Nielsen writes that by combining cropping and scaling you can “preserve both content and detail, even at very small sizes.” (Nielsen 2000)

Extreme Closeup for a Sneak Preview

Some high fashion sites actually use only the important part of an image as a thumbnail. For example, just the shoulder or neckline of a style – click and you get the full shots with details. This “image tease” technique can add an artistic feel to a site. Let’s get up close and personal with our intrepid traveler.

Extreme Cropping through Rearrangement

In extreme cases you could rearrange the target objects and reshoot, or move them closer together in your favorite image editing program. The idea is to use the smallest possible image that still conveys the information you want to display. You may need to bump up font sizes to withstand more extreme image reductions.

JPEG Cropping Caution

Be careful when resaving JPEG images. Reoptimizing an existing JPEG can compound compression artifacts. It is possible to transform JPEGs losslessly, however. Lossless transformations (like 90-degree rotations and flips) require the dimensions of the JPEG to be a multiple of the block size (16×16, 16×8, or 8×8 pixels for color JPEGs). Lossless crops are also possible by cropping to block boundaries with specialized software, like JPEG Wizard.



By: Asif Khalyani

About the Author:

‘Adobe Photoshop, or simply Photoshop, is a graphics editing program developed and published by Adobe Systems. It is the current and primary market leader for commercial bitmap and image manipulation, and is the flagship product of Adobe Systems. It has been described as “an industry standard for graphics professionals”[1] and was one of the early “killer applications” on the Macintosh’

This was the first tutorial I ever did!

I created it originally for another site, so sorry for any irregular references.

Hey guys, this is a tutorial for pen tooling, present on my current signature. I hope you enjoy this and would love to see some results Pen tooling is a great tool in any graphic artist’s arsenal.

This should be done on a new layer, for every line you do

Generally you should use relevant colours to the piece, if you can add a white or black with it. I will use blue just so you can see clearly what I’m doing.

Step 1:

Set your brush tool to a hard brush, 3-12 pixels depending on the thickness of the line you are aiming for.

Image cannot be shown in this article.

Step 2:

Make sure you’re using the ‘paths’ version of the pen tool. (top left corner)

Select the pen tool and click twice, forming a ‘straight line’, as shown.

Image cannot be shown in this article.

Step 3:

Click and hold the line anywhere you like, you’ll see you can now bend the line around. Do this until you have something you like (not on the same click and hold)

Image cannot be shown in this article.

…

…

For the full tutorial, visit this page; http://signatureshelf.com/forum/viewtopic.php?f=25&t=11



By: Liam Hayman

About the Author:

In today’s world of computers, it would seem so impossible if you have not even heard of Adobe Photo Shop. It hails among the most important programs of today, being the leading photo-processing and graphics software in the market. Learning how to use this program is already a prerequisite for anyone who wants to venture into digital visual arts. It is therefore not surprising why there are tons of photo shop tutorials out there. People really want to learn how to use the program. But among tutorials, the best type for learning is probably the photo shop video tutorial.

In all fairness to other types of photo shop tutorials, normal photo shop instructional resources are indeed very useful. They teach people a wide range ways to use photo shop to their advantage. However, most of these usual tutorial versions can be hard to follow since they only tell people what to do, but not necessarily show them how to do it. When such is the case, it would really be helpful to see what is being taught. This is normally something that people taking photo shop classes can enjoy, but now even people at home can learn photo shop and see how it is down with the help of a photo shop video tutorial.

What a Photo Shop Video Tutorial Can Teach You

There are many specific types of photo shop video tutorials available, some very specialized while others very simple. However, they have a common goal of making you understand the capabilities of photo shop better and make use of them for your own projects. Some photo shop video tutorials teach basic stuff about the program. This type of tutorial instructs users in making themselves familiar with software – its regular menus, common tools and basic functionalities.

There are also photo shop video tutorials that teach more specific functions of the program. Some specifically teach the color enhancing and manipulation capabilities of photo shop that help adjust the tints or hues of photos. There are also photo shop video tutorials that teach users how to scan pictures for optimum quality. While other tutorials instruct the various ways of editing pictures to make them even more interesting than they already are. These tutorials are very useful for photographers, both digital and film users.

Other photo shop video tutorials teach more advanced functionalities of the program. There are tutorials that teach how to make effects out text, making them even more interesting and very catchy. Others show how to make special effects out of images to make them even more appealing, exciting, or fascinating to viewers. There are some that how to come up with textures that make pictures pop out into real life. These tutorials are very useful for the more advanced graphics designers and visual artists.

Where to Look for Photo Shop Video Tutorials

There are many places to look for photo shop video tutorials. Most software stores have them on stock together with video tutorials for other software. Tutorials can also be found online through various instructional websites sites that offer those who want to learn how to use the program. The good thing about them is that they can easily be reached via the Internet and some of them are even for free.

Here are some websites that offer photo shop video tutorials:

http://video-tutes.com/packages/PSDesign1.php

http://www.photoshopsupport.com/tutorials.html

http://www.tutorialized.com/tutorials/Photoshop/1

http://www.photoshop-tutorials-4-you.com/

Learning photo shop is now very easy thanks to video tutorials.



By: Mario Churchill

About the Author:

PHP – In this section we discuss miscellaneous tools and techniques for using SQL and MySQL. We introduce:

Choosing keys and indexes for fast searching

Elementary database-tuning techniques

Adding and deleting users of a DBMS, and changing user permissions

Limitations of MySQL

3.10.1 Keys, Primary Keys, and Indexes

As discussed earlier in our introduction to SQL, each table should have a PRIMARY KEY definition as part of the CREATE TABLE statement. A primary key is an attribute—or set of attributes—that uniquely identifies a row in a table. Storing two rows with the same primary key isn’t permitted and, indeed, an attempt to INSERT duplicate primary keys produces an error.

In MySQL, the attribute values of the primary key are stored in an index to allow fast access to a row. The default MySQL index type is fast for queries that find a specific row, a range of rows, for joins between tables, grouping data, ordering data, and finding minimum and maximum values. Indexes don’t provide any speed improvement for retrieving all the rows in a table or for other query types.

Indexes are also useful for fast access to rows by values other than those that are associated with attributes in the primary key. For example, in the customer table, you might define an index by adding the clause:

KEY namecity (surname,firstname,city)

to the CREATE TABLE statement. After you define this index, some queries that select a particular customer through a WHERE clause can use it. Consider an example:

SELECT * FROM customer

WHERE surname = ‘Marzalla’ AND

firstname = ‘Dimitria’ AND

city = ‘St Albans’;

This query can use the new index to locate—in at most a few disk accesses—the row that matches the search criteria. Without the index, the DBMS must scan all the rows in the customer table and compare each row to the WHERE clause. This might be quite slow and certainly requires significantly more disk accesses than the index-based approach (assuming the table has more than a few rows).

A particular feature of DBMSs is that they develop a query evaluation strategy and optimize it without any interaction from the user or programmer. If an index is available, and it makes sense to use it in the context of a query, the DBMS does this automatically. All you need to do is identify which queries are common, and make an index available for those common queries by adding the KEY clause to the CREATE TABLE statement or using ALTER TABLE on an existing table.

Careful index design is important. The namecity index we have defined can also speed queries other than those that supply a complete surname, firstname, and city. For example, consider a query:

SELECT * FROM customer

WHERE surname = ‘LaTrobe’ AND

firstname = ‘Anthony’;

This query can also use the index namecity, because the index permits access to rows in sorted order first by surname, then firstname, and then city. With this sorting, all “LaTrobe, Anthony” index entries are clustered together in the index. Indeed, the index can also be used for the query:

SELECT * FROM customer

WHERE surname LIKE ‘Mar%’;

Again, all surnames beginning with “Mar” are clustered together in the index. However, the index can’t be used for a query such as:

SELECT * FROM customer

WHERE firstname = ‘Dimitria’ AND

city = ‘St Albans’;

The index can’t be used because the leftmost attribute named in the index, surname, isn’t part of the WHERE clause. In this case, all rows in the customer table must be scanned and the query is much slower (again assuming there are more than a few rows in the customer table, and assuming there is no other index).

Careful choice of the order of attributes in a KEY clause is important. For an index to be usable in a query, the leftmost attribute must appear in a WHERE clause.

There are other cases in which an index can’t be used, such as when a query contains an OR that isn’t on an indexed attribute:

SELECT * FROM customer

WHERE surname = ‘Marzalla’ OR

email = ‘dimitria@lucaston.com’;

Again, the customer table must be completely scanned, because the second condition, email=’dimitria@lucaston.com’, requires all rows to be retrieved as there is no index available on the attribute email. Also, the case where the ORed attribute isn’t the leftmost attribute in an index requires a complete scan of the customer table. The following example requires a complete scan:

SELECT * FROM customer

WHERE firstname = ‘Dimitria’ OR

surname = ‘Marzalla’;

If all the attributes in the index are used in all the queries, to optimize index size, the leftmost attribute in the KEY clause should be the attribute with the highest number of duplicate entries.

Because indexes speed up queries, why not create indexes on all the attributes you can possibly search on? The answer is that while indexes are fast for searching, they consume space and require updates each time rows are added or deleted, or key attributes are changed. So, if a database is largely static, additional indexes have low overheads, but if a database changes frequently, each additional index slows the update process significantly. In either case, indexes consume additional space, and unnecessary indexes should be avoided.

One way to reduce the size of an index and speed updates is to create an index on a prefix of an attribute. Our namecity index uses considerable space: for each row in the customer table, an index entry is up to 120 characters in length because it is created from the combined values of the surname, firstname, and city attributes.[2] To reduce space, you can define the index as:

[2] This isn’t the space actually required by an index entry, because the data is compressed for storage. However, even with compression, the fewer characters indexed, the more compact the representation, the more space saved, and—depending on the usability of the index—the faster searching and updates are.

KEY namecity (surname(10),firstname(3),city(2));

This uses only the first 10 characters of surname, 3 of firstname, and the first 2 characters of city to distinguish index entries. This is quite reasonable, because 10 characters from a surname distinguishes between most surnames, and the addition of a few characters from a first name and the prefix of their city should be sufficient to uniquely identify almost all customers. Having a smaller index with less information can also mean that queries are actually faster, because more index information can be retrieved from disk per second, and disk retrieval speed is almost always the bottleneck in query performance.

The space saving is significant with a reduced index. A new index entry requires only 15 characters, a saving of up to 105 characters, so index insertions, deletions, and modifications are now likely to be much faster. Note that for TEXT and BLOB attribute types, a prefix must be taken when indexing, because indexing the entire attribute is impractical and isn’t permitted by the MySQL DBMS.

3.10.2 Tuning the Database System

Careful index design is one technique that improves the speed of a DBMS and can reduce the resource requirements of a database. However, comprehensive database tuning is a complex topic that fills many books. We include in this section only a few additional practical ideas to begin to improve the performance of a database system.

As discussed previously, accessing a hard disk is slow and is usually the bottleneck in DBMS performance. More specifically, disk seeking—moving the disk head to get information from another location of the disk—is the slowest component of disk access. Therefore, most techniques described in this section are also techniques that improve performance by minimizing disk space requirements.[3]

[3] Reducing disk space requirements improves both disk seek and read performance. Disk read performance is improved because less data is required to be transferred, while seek performance is improved because the disk head has to move less on average when randomly accessing a smaller file than when accessing a larger file.

Here are some ways to improve DBMS performance:

Carefully choose attribute types and lengths. Where possible, use small variants such as SMALLINT or MEDIUMINT rather than the regular choice INT. When using fixed-length attributes, such as CHAR, specify a length that is as short as practical.

Use fixed-length attributes; that is, try to avoid types such as VARCHAR or BLOB. While fixed-length text attributes may waste space, scanning fixed-length rows in a query is much faster than scanning variable-length rows.

Design indexes with care. As discussed in the last section, keep the primary key index as small as possible, create only indexes that are needed, and use prefixes of attributes where possible. Ensure that the leftmost attribute in the index is the most frequently used in queries and, if all attributes are used, make sure the leftmost attribute is the one with the highest number of duplicate entries.

Create a statistics table if aggregate functions such as COUNT( ) or SUM( ) are frequently used in queries on large tables. A statistics table stores only one row that is manually updated with the aggregate values of another table. For example, if the statistics table maintains the count of rows in a large customer table, each time a row is inserted or deleted in the customer table, the count is updated in the statistics table. For large tables, this is often faster than calculating aggregate functions with the slow built-in functions that require complete processing of all rows.

If large numbers of rows are deleted from a table, or a table containing variable-length attributes is frequently modified, disk space may be wasted. MySQL doesn’t usually remove deleted or modified data; it only marks the location as being no longer in use. Wasted space can affect access speed.

To reorganize a table—by copying data to a temporary location and back again—MySQL provides the OPTIMIZE TABLE command, which should be used periodically. For example:

OPTIMIZE TABLE customer;

The OPTIMIZE command should be run when the DBMS is offline for scheduled maintenance. The command is nonstandard SQL.

It is possible to create different table types for specific tasks. The default in MySQL is the MyISAM type, and all the tables described so far are this table type. For small, temporary, frequently used lookup tables, a different type, the heap table type, can be used. There are other types, and we briefly discuss alternatives in Chapter 6. More details are provided in Section 9.4 of the MySQL user manual.

Section 10.7 of the MySQL manual includes other excellent ideas for simple performance improvement.

Another aspect of database tuning is optimizing the performance of the DBMS itself. Included with the MySQL installation is the mysqladmin tool for database administration. Details of the system setup can be found by running the following command from a Linux shell:

% mysqladmin -ppassword variables

This shows, in part, the following selected system parameters:

join_buffer current value: 131072

key_buffer current value: 8388600

net_buffer_length current value: 16384

record_buffer current value: 131072

sort_buffer current value: 2097144

table_cache current value: 64

The important parameters are those that impact disk use. MySQL has several main-memory buffer parameters that control how much data is kept in memory for processing. These include:

The record_buffer for scanning all rows in a table

The sort_buffer for ORDER BY and GROUP BY operations

The key_buffer for storing indexes in main memory

The join_buffer for joins that don’t use indexes

In general, the larger these buffers, the more data from disk is cached or stored in memory and the fewer disk accesses are required. However, if the sum of these parameters is near to exceeding the size of the memory installed in the server, the underlying operating system will start to swap data between disk and memory, and the DBMS will be slow. In any case, careful experimentation based on the application is likely to improve DBMS performance.

Section 10.2.3 of the MySQL manual suggests parameter settings when starting the MySQL server. First, for machines with at least 64 MB of memory, large tables in the DBMS, and a moderate number of users, use:

safe_mysqld -O key_buffer=16M -O table_cache=128 \

-O sort_buffer=4M -O record_buffer=1M &

Second, if there is less than 64 MB of memory available, and there are many users, try the following:

safe_mysqld -O key_buffer=512k -O sort_buffer=100k \

-O record_buffer=100k &

The following setting might be appropriate for the winestore, because many users are expected, the queries are largely index-based, and the database is small:

safe_mysqld -O key_buffer=512k -O sort_buffer=16k \

-O table_cache=32 -O record_buffer=8k

-O net_buffer=1K &

Even more conservative settings might also be acceptable.

There are two other parameters we have not discussed. The table_cache parameter manages the maximum number of open tables per user connection, while the net_buffer parameter sets the minimum size of the network query buffer in which incoming queries are kept before they are executed.

The mysqladmin utility can report the status of the DBMS:

% mysqladmin -ppassword status

The output has the following format:

Uptime: 5721024 Threads: 14 Questions: 7874982

Slow queries: 6 Opens: 115136 Flush tables: 1

Open tables: 62

This gives a brief point-in-time summary of the DBMS status and can help find more about the number of user connections, queries, and table use. Similar output can be generated by running the commands SHOW STATUS and SHOW VARIABLES through the MySQL command interpreter.

Information about query performance can be gained with the benchmark( ) function, which can be used iteratively for tuning when altering table design or DBMS system parameters. The following statement illustrates benchmarking:

SELECT benchmark(10000, COUNT(*))

FROM items;

This statement reports the time taken to evaluate 10,000 calls to COUNT( ) on the items table.

3.10.3 Adding and Deleting Users

We have not yet discussed adding and deleting users from the MySQL DBMS. Our rationale in leaving this topic until this final section is that DBMS users aren’t as important in a web database application as in other applications. Because access to the database and DBMS is generally controlled in the application logic of the middle tier, usually only one or two DBMS users are needed.

A user, hugh, who has full control over all aspects of the DBMS and can access the DBMS from the machine that hosts the DBMS, can be created with the statement:

GRANT ALL PRIVILEGES ON *.* TO hugh@localhost

IDENTIFIED BY ‘password’ WITH GRANT OPTION;

Allowing access over a network can be added with:

GRANT ALL PRIVILEGES ON *.* TO hugh@”%”

IDENTIFIED BY ‘password’ WITH GRANT OPTION;

There is no need to allow network access for a web database application if the middle-tier components—the web server and scripting engine—are installed on the same machine as the DBMS.

This user can then connect to the database from the shell with the command:

% mysql -ppassword -uhugh

The user information is stored in the mysql database in the user table, which can be explored with:

USE mysql;

SELECT * FROM user;

The mysql database and the user table can be managed in the same way as any other database. For example, you can update the password of the new user with the UPDATE statement:

UPDATE user

SET password=password(‘newpwd’)

WHERE user=’hugh’;

Note the use of the password( ) function we described earlier to encrypt the password for storage in the user table.

3.10.3.1 Permissions

Users can be added to the system with an INSERT INTO the user table in the mysql database or, as previously illustrated, you can use the GRANT statement. Moreover, privileges can be adjusted with an UPDATE, added with GRANT, or removed with REVOKE.

Consider the following example:

GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP

ON winestore.*

TO dave@localhost

IDENTIFIED BY ‘password’;

This adds a new user dave and allows him to use only the SQL statements listed in the winestore database. The parameter winestore.* means all tables within the winestore database.

Privileges can be removed with the REVOKE statement. For example:

REVOKE DROP,CREATE ON winestore.* FROM dave@localhost;

If the privilege or privileges are to be revoked for all databases in the DBMS, not just a single database, winestore.* can be replaced with *.*.

The following privileges can be used in GRANT and REVOKE statements:

ALL PRIVILEGES, FILE, RELOAD, ALTER, INDEX, SELECT,

CREATE, INSERT, SHUTDOWN, DELETE, PROCESS, UPDATE,

DROP, REFERENCES, USAGE

3.10.4 Limitations of MySQL

The most significant limitation of MySQL is that it doesn’t support nested queries. However, support is planned in MySQL Version 4. Nested queries are those that contain another query. Consider an example nested query to find the wines that have inventory stock:

SELECT DISTINCT wine_id FROM wine

WHERE wine_id IN

(SELECT wine_id from inventory);

The query returns the wine_id values from the wine table that are found in the inventory table. Nested queries use the IN, NOT IN, EXISTS, and NOT EXISTS operators.

In many cases, a nested query can be rewritten as a join query. For example, to find the wines that are in stock, you can use the following join query:

SELECT DISTINCT wine.wine_id FROM wine, inventory

WHERE wine.wine_id = inventory.wine_id;

However, some nested queries can’t be rewritten as join queries; for difficult queries, temporary tables are often a useful workaround.

A limitation of DELETE and UPDATE is that only one table can be specified in the FROM clause. This problem is particular to MySQL and related to the lack of support for nested queries. This limitation can make modifications of data difficult. For example, it prevents data being deleted or updated using the properties of another table. A solution involves data being copied to a temporary table using a combined INSERT and SELECT statement that joins together data from more than one table. Then, the data can be deleted or updated in the temporary table and then transferred back to the original table. Another approach, using the concat( ) string function, is discussed in Section 1.4.4.1 in the MySQL manual.

To avoid UPDATE and DELETE problems, consider adding additional attributes to tables at design time. For example, in the winestore we added a DATE attribute to the items table so that shopping-cart items can be removed easily if they aren’t purchased within one day. Removing rows from the items table based on the DATE in the orders table is difficult without support for nested queries.

MySQL doesn’t support stored procedures or triggers. Stored procedures are queries that are compiled and stored in the DBMS. They are then invoked by the middle-tier application logic, with the benefit that the query is parsed only once and there is less communication overhead between the middle and database tiers. Triggers are similar to stored procedures but are invoked by the DBMS when a condition is met. Stored-procedure support is planned for MySQL, but trigger support isn’t.

Views aren’t supported in MySQL. Views consolidate read-only access to several tables based on a join condition. For example, a view might allow a user to browse the sales made up to April without the need to create a temporary table, as we did in the example in Section 3.8. View support is planned for the future.

Limitations that we don’t discuss here include the lack of support for foreign keys and cursors. More detail on the limitations of MySQL can be found in Section 1.4 of the manual distributed with MySQL.

More PHP Tutorial



By: alimox

About the Author: