Volume Number: 20 (2004)
Issue Number: 3
Column Tag: Programming
by Kevin Hemenway, Imitating Conspirator
Modifying our MySQL database with the shell and PHP.
We finally added information into our MySQL database last issue, but in a rather infantile way: by writing all the SQL statements (like those seen in Listing 1) into a text file and then passing them to MySQL with a command line, mysql mactech < mactech-insert.sql, which completes silently when successful. This is certainly helpful if we're passing default information to be initialized in newly created databases, but not very useful if we want to programmatically access the information within.
Listing 1: Three new SQL INSERT statements for our database.
mactech-insert.sql
INSERT INTO books
SET publication = "2000-00-00",
title = "Object Oriented Perl";
INSERT INTO books
SET publication = "1999-00-00",
title = "MyEssQueEll";
INSERT INTO books
SET publication = "2003-00-00",
title = "PHP and MySQL Web Development";
In this article, we'll talk about two more ways to manipulate data: through the MySQL interactive shell, and via PHP's built in database functions. First up, let's walkthrough the interactive shell, which is quite helpful for quickly testing out new SQL statements or applying immediate fixes without new code overhead and development.
Starting up the MySQL interactive shell is mindlessly simple. Just type mysql and you'll be shown a mysql> prompt, similar to the shell prompt you see when you first enter the Terminal. Since we've yet to specify a database, we're in a sort of limbo: MySQL knows we're here, but we've yet to tell it anything of import. First we'll show which databases have been configured, choose which one we'd like to work with, and then ask for a table listing:
:~ > mysql Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 2 to server version: 4.0.15 Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql> SHOW DATABASES; +--------------------+ | Database | +--------------------+ | mactech | | mysql | | test | +--------------------+ 3 rows in set (0.26 sec) mysql> USE mactech; Reading table information for completion of table and column names. You can turn off this feature to get a quicker startup with -A. Database changed mysql> SHOW TABLES; +------------------------------------------+ | Tables_in_mactech | +------------------------------------------+ | books | | person | | relationships | +------------------------------------------+ 3 rows in set (0.05 sec)
The most obvious fact from the above is that all SQL commands must end with a semi-colon. If you happen to forget that termination, MySQL will change its shell prompt to show you it's waiting patiently for a complete command. The following is the same command as before, only split with new lines. Notice the prompt indicating an incomplete statement:
mysql> SHOW
-> TABLES
-> ;
A good portion of readers will know that the shell opened by the Terminal gives you command line history (press the UP arrow to see commands you've previously typed) as well as file or directory completion (press TAB after typing the first few letters). MySQL also supports these time-savers: pressing UP will show you SQLs you've typed previously, and pressing TAB when typing a table or column name will auto-complete the nearest match.
In our previous work with SQL, we've touched on the INSERT, UPDATE, and DELETE commands. We've yet to touch on the most often used, however, which is SELECT. While our previous statements have focused on adding, modifying, or deleting data, the sole purpose of SELECT is for displaying:
mysql> SELECT * FROM books; +----+-------------------------------+-------------+ | id | title | publication | +----+-------------------------------+-------------+ | 1 | Spidering Hacks | 2003-11-01 | | 2 | Mac OS X Hacks | 2003-04-01 | | 3 | Object Oriented Perl | 2000-00-00 | | 4 | MyEssQueEll | 1999-00-00 | | 5 | PHP and MySQL Web Development | 2003-00-00 | +----+-------------------------------+-------------+ 5 rows in set (0.00 sec) mysql> SELECT title, name FROM person; +-------+----------------+ | title | name | +-------+----------------+ | Mr. | Kevin Hemenway | +-------+----------------+ 1 row in set (0.00 sec) mysql> SELECT * FROM relationships WHERE book_id = '2'; +-----------+----------+ | person_id | book_id | +-----------+----------+ | 1 | 2 | +-----------+----------+ 1 row in set (0.05 sec)
The above shows three different variants of a SELECT statement--many more are possible. The first is the easiest to understand: "select everything from the books table". The second is an example of specifying only the columns you want to see, in any order. Even though title came after name in our original CREATE statement (last issue), SELECT allows us to reorder things however we decide best. The third statement is an example of more intimately specifying which exact rows you'd like to retrieve.
Comparing the above walkthrough to the command line we entered last issue (mysql mactech < mactech-insert.sql) gives us a better understanding of what's going on. We specify the database to connect to (mactech; similar to USE mactech in the MySQL shell), and then send a bunch of SQL commands in a batch, as opposed to manually entering them one at a time. It doesn't take a giant leap of faith to realize that we can save the USE database step by specifying it on the command line:
~ > mysql mactech
Reading table information for completion of
table and column names. You can turn off this
feature to get a quicker startup with -A.
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 2 to server version: 4.0.15
Type 'help;' or '\h' for help.
Type '\c' to clear the buffer.
mysql> UPdAtE books SET title = "MySQL"
-> where title = "MyEssQueEll";
Query OK, 1 row affected (0.02 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> SeLeCT id, title FRoM
-> books WHERE title LIKE '%SQL%';
+----+-------------------------------+
| id | title |
+----+-------------------------------+
| 4 | MySQL |
| 5 | PHP and MySQL Web Development |
+----+-------------------------------+
2 rows in set (0.30 sec)
The previous listing shows an example of entering the MySQL interactive shell with a database already selected, updating a row of misspelling in our previous INSERT (Listing 1), and then getting a pattern match with LIKE. The % characters are boundary placeholders for "anything or nothing", so our final statement finds the letters "SQL" in the beginning, middle, or end of a title. Changing "SQL" to "my" would return the same set of results, confirming that LIKE searches are case-insensitive.
Up until now, all our SQL commands have used capital letters, but you'll notice that they too are case-insensitive. For clarity, I prefer uppercase SQL: it just makes things easier to mentally and visually parse after long hours of fevered coding.
Our next step is to access our mactech database programmatically with PHP. You'll notice some similarities with the above interactive shell process: we connect to MySQL, choose a database, and issue some SQL queries. You'll note that we're passing the MySQL username and password we created with mysql_setpermission a few columns back. This is important for security: just like you don't want your sister messing with your personal files, you don't want to make it too easy for web interlopers to affect the various databases you maintain. In most cases, once you're finished developing an application, you'd tighten the user's permission even further (say, to restrict DELETE and DROP access).
Save the contents of Listing 2 into /Library/WebServer/Documents:
Listing 2: PHP code for accessing our MySQL database.
db_access.php
<h1>MySQL Database Access in PHP</h1>
<?php
$dbh = mysql_connect("localhost","favemarksman","***")
or die ("There was an error connecting to MySQL.");
?>
Before we delve deeper into our code, I wanted to show you a one-character-difference that can be used to improve security. Astute readers will notice that even though I meant davemarksman (the MySQL user created a few issues ago) I mistyped as favemarksman:
Figure 1: An error occurred during the database connection.
Here's the problem: if someone comes to our site and triggers this error message, we've freely given them four pieces of valuable information that can be used against us for exploitive purposes. We've told them we're using MySQL as a database, that it's installed on the same machine as the web server, that there's (possibly) a user named favemarksman (a similar error would occur if the username was correct, but not the password), and revealed a directory path (which, in this case, infers we're using OS X, a fifth fact).
Listing 3 contains a much stronger version of our code, which removes any mention of the technology being used, and stops MySQL from spitting useful information to our visitors. The real magic happens with the @ symbol before our function name: using it will silence any automatically visible errors. This makes for more secure code, as well as a more professional web site (i.e., what impression does it leave visitors if they see nothing but errors?)
Listing 3: Revised PHP code for accessing our MySQL database.
db_access.php, revised
<h1>Database Access in PHP</h1>
<?php
$dbh = @mysql_connect("localhost","favemarksman","***")
or die ("An error has occurred. Please report this.");
?>
The revised output is shown in Figure 2:
Figure 2: No more information disclosure. Much better.
With that out of the way, we can now accomplish something. Listing 4 contains complete (but simple) PHP code to insert some information into the mactech database, view it, and then DELETE a bit. As with most programming, there are many ways this can be done: more information about the different mysql_ functions we've not shown can be found at the PHP web site: http://www.php.net/manual/en/ref.mysql.php.
Listing 4: Finished PHP code for accessing our MySQL database.
db_access.php, finished
<h1>Database Access in PHP</h1>
<?php
// connect to the database server.
$dbh = @mysql_connect("localhost","davemarksman","***")
or die ("ERROR: Could not connect to the database!");
// choose our database.
@mysql_select_db( "mactech" )
or die ("ERROR: Could not select our database!");
// create a SQL statement. Notice that through
// PHP, the SQL terminating semi-colon is optional.
$statement = "INSERT INTO person SET
name = 'Dave Mark',
date_of_birth = '1901-03-31',
title = 'Intern',
designation = 'Bullseye Hole Filler'";
// standard way of executing SQL through PHP.
$response = @mysql_query( $statement, $dbh );
// mysql_error() would give too much information for
// a production site, but this is just an example.
if (!$response) { print mysql_error () . "\n"; }
// create and execute another SQL statement.
$sg_made_out_of = "SELECT * FROM person;";
$response = @mysql_query( $sg_made_out_of, $dbh );
// this is one of a few ways to iterate through rows.
print "<h3>People, List #1</h3>";
while ( $person = @mysql_fetch_array( $response ) ) {
// column name is array key.
print "$person[id], $person[title],
$person[name], $person[designation]<br />";
}
// one more SQL statement, this time a delete.
$freedom = "DELETE FROM person WHERE name LIKE '%Mar%'";
$response = @mysql_query( $freedom, $dbh );
// and make sure he's really gone.
$sg_made_out_of = "SELECT * FROM person;";
$response = @mysql_query( $sg_made_out_of, $dbh );
// another way of iterating through rows, only
// as variables, not hash keys. Could get messy.
print "<h3>People, List #2</h3>";
while ( $person = @mysql_fetch_array( $response ) ) {
extract ( $person ); // make columns variables.
print "$id, $title $name, $designation<br />";
}
?>
The results of running this script are in Figure 3. Since we're inserting a new record, then deleting it, successive loads will assign the new record an ever-increasing sequential ID, even though the data we're entering is exactly the same.
Figure 3: The final results of our database access in PHP.
As is typical in a four-page article, we've barely touched the surface of what PHP can do in regards to database access and handling. Next month, we'll change gears and see how Perl handles the same logic. Until then, contact the teacher at morbus@disobey.com.
Kevin Hemenway, coauthor of Mac OS X Hacks and Spidering Hacks, is better known as Morbus Iff, the creator of disobey.com, which bills itself as "content for the discontented." Publisher and developer of more home cooking than you could ever imagine (like the popular open-sourced aggregator AmphetaDesk, the best-kept gaming secret Gamegrene.com, the ever ignorable Nonsense Network, etc.), he'd rather be nursing his wounds with a swift kick to the head. Contact him at morbus@disobey.com.
