Creating a user with SELECT privileges only on a specific database, Part 3

Part 3 of 3. This part covers using Dreamhost‘s web panel for creating a user with SELECT privileges only for use while displaying data on a webpage. See Protecting Your Data from an SQL Injection Attack for more. Part 1 covered the actual SQL commands. Part 2 covered using phpMyAdmin.

Using Dreamhost‘s interface.

I picked Dreamhost because they host conlang.org and most of the subdomains of conlang.org. Also, they disallow using the methods in part 1 and part 2.

After logging in to Dreamhost‘s panel, click on Databases under Let’s Get Started!

Let's Get Started screenshot

Under the list of databases, click Add a New User on the right.

List of databases screenshot

Select “Create a new user now…” from the select menu, then fill in the username and password. Click Add new user now! Note that the instructions say: “This will grant a user full access to your “database_name” database. To limit this user’s database access privileges to “terjemar_newdict”, simply click their username on the screen that follows. ”

adding a new user screenshot

Now we get our success message: “User “selectonly_user” has been granted access to your “terjemar_newdict” database! If you’d like to fine-tune their permissions or set where they can connect from, do so from here.” You can also click on the username listed by the database.

selecting the user for editing screenshot

Make sure only Select is checked. The other options are Insert, Update, Delete, Create, Drop, Index, and Alter. The first three allow the use of those statements, so INSERT statements, UPDATE statements, and DELETE statements. Create allows for CREATE TABLE statements, Drop for DROP TABLE statements, Index for CREATE INDEX and DROP INDEX statements, and Alter for ALTER TABLE statements.

modifying privileges screenshot

Click on “Modify selectonly_user now!”.

final success message

And we have our success statement.

Creating a user with SELECT privileges only on a specific database, Part 2

Part 2 of 3. This part covers using phpMyAdmin for creating a user with SELECT privileges only for use while displaying data on a webpage. See Protecting Your Data from an SQL Injection Attack for more. Part 1 covered the actual SQL commands. Part 3 will cover using Dreamhost‘s web panel. I picked Dreamhost because they host conlang.org and most of the subdomains of conlang.org. Also, they disallow using the methods in part 1 and part 2.

Using phpMyAdmin:

From the homepage, go to the Privileges tab.

phpMyAdmin homepage

There you will find an “add a new user” link.

add a new user link screenshot

Click that for the Add a New User form.

add a new user form screenshot

Fill this out. Make sure None is the option under Database for user, and do not check anything under Global privileges. Click GO.

success screenshot

This display the green success checkmark and gives the SQL for what has been done:

CREATE USER 'username'@'%' IDENTIFIED BY '***';
GRANT USAGE ON *.* TO  'username'@'%' IDENTIFIED BY '***' ...;

GRANT USAGE does not grant anything at all.

Underneath is the Edit User form (also reachable through the list of users).

Edit user form screenshot

Note that the first part is labelled Global privileges. We don’t want those, we want privileges for a specific database (‘test’). That is under the Global Privileges part. We select the database from the select box and get to the database’s privileges page:

database specific edit form screenshot

Here we check the box marked SELECT and click GO.

final success screenshot

And Success!. The SQL here reads:

GRANT SELECT ON test.* TO 'username'@'%';

Creating a user with SELECT privileges only on a specific database, Part 1

Part 1 of 3. This part covers the actual SQL commands for creating a user with SELECT privileges only for use while displaying data on a webpage. See Protecting Your Data from an SQL Injection Attack for more. Part 2 will cover using phpMyAdmin. Part 3 will cover using Dreamhost‘s web panel. I picked Dreamhost because they host conlang.org and most of the subdomains of conlang.org. Also, they disallow using the methods in part 1 and part 2.

Using SQL:

First, you have to have GRANT privileges yourself to do this. If so, use the CREATE USER statement, like so:

CREATE USER 'username'@'hostname';

The above creates a user without a password. (Not a good idea.)

CREATE USER 'username'@'hostname' IDENTIFIED BY 'password';

This creates the user and the password. The main issue with this syntax is that the password is right there in plain text. There is a MySQL function which creates an encoded password. That is the PASSWORD() function. Like so:

SELECT PASSWORD('badpwd');

returns ‘*AAB3E285149C0135D51A520E1940DD3263DC008C’. You can then use that encoded string in the CREATE USER statement:

CREATE USER 'username'@'hostname' IDENTIFIED BY 
PASSWORD '*AAB3E285149C0135D51A520E1940DD3263DC008C';

Make sure to include that PASSWORD after IDENTIFIED BY.  You can also use the ‘%’ wildcard for the hostname so that the given user can log on from any host:

CREATE USER 'username'@'%' IDENTIFIED BY 
PASSWORD '*AAB3E285149C0135D51A520E1940DD3263DC008C';

Specifying privileges is done using a GRANT statement:

GRANT SELECT ON database_name.table_name TO 'username'@'%';

This allows the user access only to the specified database and table and only for use of SELECT statements.

GRANT SELECT ON database_name.* TO 'username'@'%';

allows usage on all tables in the named database.

So, two statements will do it:

CREATE USER 'username'@'%' IDENTIFIED BY 
PASSWORD '*AAB3E285149C0135D51A520E1940DD3263DC008C';
GRANT SELECT ON database_name.* TO 'username'@'%';

Do you speak SQL? (Part 2: Creating tables)

Most SQL tutorials start with SELECT statements and then go into all sorts of detail about the various functions and elaborations available. These are really cool, and I will go into them eventually, but I have found that aside from basic syntax and a handful of functions most conlangers do not need to know all that in order to display a dictionary entry or list of entries. So I am going to skip all that for now and talk about creating tables.

The SQL for creating tables starts with an obvious CREATE TABLE followed by the name of the table and then a list of the column names with descriptive material in parentheses. Like so:

CREATE TABLE IF NOT EXISTS `definitions` (
  `definitionID` INT(11) NOT NULL AUTO_INCREMENT,
  `wordID` INT(11) NOT NULL,
  `definition_number` INT(2) NOT NULL DEFAULT '1',
  `part_of_speech` VARCHAR(25) COLLATE utf8_general_ci 
          DEFAULT NULL,
  `definition_text` TEXT COLLATE utf8_general_ci,
  PRIMARY KEY (`definitionID`),
  CONSTRAINT `fk_defword` FOREIGN KEY (`wordID`)
  REFERENCES `dictionary_word` (`wordID`)
);

The statement above creates the table named “definitions”. The phrase IF NOT EXISTS means that if a table by that name already exists, then nothing happens. If a table by that name does not exist, then the table is created with 5 columns, a primary key, and a foreign key constraint.

Let’s take this column by column. The first column created is called “definitionID”, it is described as an integer of 11 places maximum. (That’s the default for MySQL’s INT datatype.) It cannot be NULL, and the value is automatically incremented every time an entry is added to this table.

The next column is “wordID”, which is also an integer of 11 places maximum and also cannot be null. The third column is “definition_number”, which is an integer of 2 places maximum. That means its value cannot go above “99”. It also has a default value of “1”.

The fourth column “part_of_speech” has a description of VARCHAR(25). CHAR and VARCHAR are common datatypes for strings. CHAR has a fixed width, and VARCHAR has a variable width. In this column, VARCHAR’s maximum width or number of characters is 25. This column also has a defined collation of utf8_general_ci and a default of NULL. Actually, DEFAULT NULL is optional, since NULL is already the default of any column not designated as NOT NULL. Collations I will discuss some other time.

The fifth column “definition_text” has a datatype of TEXT. In many ways TEXT is simply VARCHAR without a maximum size. It used to be (MySQL version 5.0.3 and earlier) that VARCHAR was limited to a maximum size of 255 characters while TEXT could store up to 65536 bytes*. TEXT types have no stated size or default values.

After that comes the PRIMARY KEY definition. Each table ought to have a primary key, and it is best that the primary key is not derived from the data in the other columns. And auto-incremented integer is the usual form of a primary key, but the only requirements are that all values be unique and never null. Defining a primary key tells the database how to index the data in the table so it can be found in a query. Here we have declared “definitionID” to be the primary key.

The foreign key constraint (here arbitrarily named “fk_defword”) tells the database that one (or more, sometimes) of the columns in the table references a key (usually the primary key) in another table. This is how one connects data in one table to data in another table. Here the column “wordID” references the key “wordID” in the “dictionary_word” table.

Here’s another create table statement for you. If you have any questions, ask them in the comments.

CREATE TABLE `dictionary_word` (
 `wordID` int(11) NOT NULL AUTO_INCREMENT,
 `word` varchar(45) NOT NULL,
 `pronunciation` varchar(45) DEFAULT NULL,
 `etymology` text,
 PRIMARY KEY (`wordID`)
);

*but only if a TEXT column is the only thing in the table. Otherwise the maximum size of a TEXT column is 65536 bytes minus the number of bytes needed for all the other columns in the table.

 

Using mysqli and parameterized statements

mysqli is the PHP extension that is recommended for use with current versions (4.1.3 and later) of MySQL. The way to connect to a MySQL database using mysqli is:

$host = "my_host"; //"localhost" or "http://mysql.host.com"
$user = "my_username"; //an authorized user of the MySQL database
$password = "my_password"; //my_username's password
$database = "my_database"; //the database we want to use.

$mysqli = new mysqli($host, $user, $password, $database);

if ($mysqli->connect_error) {
    die('Connect Error (' . $mysqli->connect_errno . ') '
            . $mysqli->connect_error);
}

Keep note of that $mysqli variable. It gets used a lot.

Querying the database can be as simple as:

$mysqli->query("some valid SQL statement");

This will return TRUE if the SQL statement was successful. So, if you are not expecting any data to be returned from the server, this bit of code will work fine:

if ($mysqli->query("some valid SQL statement") === TRUE) {
    //do stuff, or not, like print a success statement
}
$mysqli->close();

If you are using a SELECT statement to get data from the server, then you can do so:

if ($result = $mysqli->query("some valid SQL statement")) {
    //do stuff with the data
    while ($row = $result->fetch_row()) {
        //do stuff with the data in the $row array
    }
    $result->close();
}
$mysqli->close();

In addition to fetch_row(), there is also fetch_array() and fetch_assoc(). The full list of $result functions is here.

But the true wonderfulness of mysqli comes from the parameterized queries.

$stmt = $mysqli->stmt_init();
if ($stmt->prepare("some valid SQL query")) {
    $stmt->bind_params("s...", $vars);
    $stmt->execute();
    $stmt->bind_result($vars);
    while ($stmt->fetch()) {
        //do stuff with the data
    }
    $stmt->close();
}
$mysqli->close();

Yeah, right, you say. It looks complicated, but really, it isn’t. And some parts are optional.

I mentioned earlier that parameterized queries were one line of defense against sql injection attacks because they force the database to interpret anything within the bound variable as data and not as SQL instructions. So, here is how that works.

First, we initialize the statement with $stmt = $mysqli->stmt_init();. This step is optional, but it is good practice. By initializing, the next function called on $stmt has to be $stmt->prepare().

$stmt->prepare() takes a query (either directly or as a variable) and prepares it for the server. If the query requires data input, such as in a WHERE clause or in an INSERT statement, then one uses ‘?’ markers as placeholders for the data. Like so:

SELECT FirstName, LastName FROM Friends WHERE FavoriteColor = ?;

In PHP:

$stmt = $mysqli->stmt_init();
if ($stmt->prepare("SELECT FirstName, LastName
    FROM Friends WHERE FavoriteColor = ?")) {
    ...

So far, so good. Make sure not to include the normal final semi-colon in the SQL statement.

The next step is to bind the parameters, or tell the database what value the ? has. This is done using $stmt->bind_param(); This function takes a minimum of two arguments. The first is a string with information on the type of data. The second is the variable that holds the data. The information string can consist of the following characters only: b, d, i, and s. These stand for blob, double, integer, and string. Since FavoriteColor is a word, we use ‘s’ to identify the input as a string. The number and sequence of characters in the string must correspond to the number and sequence of ?s in the query. The number and sequence of the data- holding variables must correspond to the same number and sequence.

$color = "purple";
$stmt = $mysqli->stmt_init();
if ($stmt->prepare("SELECT FirstName, LastName
    FROM Friends WHERE FavoriteColor = ?")) {
       $stmt->bind_param("s", $color);
       ...

OK so far? Want another example? How about:

INSERT INTO Friends (FirstName, LastName, FavoriteColor)
     VALUES (?, ?, ?);
//the data
$firstname = "David";
$lastname = "Peterson";
$color = "orange";

$stmt = $mysqli->stmt_init();
if ($stmt->prepare("INSERT INTO Friends (FirstName, LastName,
    FavoriteColor) VALUES (?, ?, ?)")) {
       $stmt->bind_param("sss", $firstname, $lastname, $color);
       ...

See, three ?s, three characters in the first argument, and three variables with our data.

Then we execute the statement, using $stmt->execute(), which sends our query to the database.

$color = "purple";
$stmt = $mysqli->stmt_init();
if ($stmt->prepare("SELECT FirstName, LastName FROM Friends
    WHERE FavoriteColor = ?")) {
       $stmt->bind_param("s", $color);
       $stmt->execute();
       ...

Since this SELECT statement is returning two values (FirstName and LastName), we can also bind the results. This part is optional, though still a good idea.

$color = "purple";
$stmt = $mysqli->stmt_init();
if ($stmt->prepare("SELECT FirstName, LastName FROM Friends
    WHERE FavoriteColor = ?")) {
       $stmt->bind_param("s", $color);
       $stmt->execute();
       $stmt->bind_result($firstname, $lastname);
       ...

After binding the results, we can use $stmt->fetch() to get the data from the result set. All that’s left to do is close the statement with $stmt->close(), freeing up resources, and close the connection with $mysqli->close().

$color = "purple";
$stmt = $mysqli->stmt_init();
if ($stmt->prepare("SELECT FirstName, LastName FROM Friends
    WHERE FavoriteColor = ?")) {
       $stmt->bind_param("s", $color);
       $stmt->execute();
       $stmt->bind_result($firstname, $lastname);
       while ($stmt->fetch()) {
           //do stuff with the data
           echo "$firstname $lastname";
       }
       $stmt->close();
}
$mysqli->close();

The other example:

//the data
$firstname = "David";
$lastname = "Peterson";
$color = "orange";

$stmt = $mysqli->stmt_init();
if ($stmt->prepare("INSERT INTO Friends (FirstName, LastName,
    FavoriteColor) VALUES (?, ?, ?)")) {
       $stmt->bind_param("sss", $firstname, $lastname, $color);
       $stmt->execute();
       $stmt->close();
}
$mysqli->close();

INSERT does not return any results for binding. If you want information regarding the success of the query, you can use $mysqli->affected_rows to get back a count of affected rows. Even more useful is $mysqli->insert_id which returns the auto-incremented ID for the new row (if there is one, and if you call it right away before inserting or updating anything else.)

If you chose to skip binding the results, then you cannot use $stmt->fetch(). Instead, you must use  $stmt->get_result() and then $result->fetch_row() or an equivalent. Like so:

$color = "purple";
$stmt = $mysqli->stmt_init();
if ($stmt->prepare("SELECT FirstName, LastName FROM Friends
    WHERE FavoriteColor = ?")) {
       $stmt->bind_param("s", $color);
       $stmt->execute();
       $result = $stmt->get_result();
       while ($row = $result->fetch_row()) {
           //do stuff with the data in the $row array
       }
       $result->close();
}
$mysqli->close();

And that’s how you use mysqli and parameterized statements.

Oct 19, 2011: Updated to fix typos in the method name.
Apr 19, 2014: Updated to add missing commas in the code.

Do you speak SQL? (Part 1)

SQL stands for Structured Query Language and it is used to talk to relational databases. While there is a standard for SQL, many databases also have their own dialects, so to speak. This is a quick intro to basic SQL, nothing fancy. In the examples, I will use the following sample data:

Friends table:

FirstName LastName FavoriteColor
James Smith blue
Mary Johnson green
David Williams red
Linda Jones purple
Daniel Brown green
Jenny Davis blue
Nancy Smith orange

SELECT

This is the most common statement used, as it gets data from the database. The basic syntax of a SELECT statement is:

SELECT FirstName, LastName, FavoriteColor FROM Friends;

Multiple fields are generally separated by commas, as are multiple tables in more advanced SELECT statements. The SELECT statement may also have optional WHERE and ORDER BY clauses and other refinements.

One of those refinements is the asterisk (*) used in place of the fields:

SELECT * FROM Friends;

* stands for all fields in the table. This certainly saves time, but can cause issues if the fields returned are not the fields expected, say because someone has changed the structure of the table. I generally never use * in my applications for that reason.

Another refinement is the DISTINCT keyword:

SELECT DISTINCT FavoriteColor FROM Friends;

This will return:

FavoriteColor
blue
green
red
purple
orange

Without the DISTINCT keyword, we would get:

FavoriteColor
blue
green
red
purple
green
blue
orange

WHERE limits the data returned to that which matches the expression in the WHERE clause.

SELECT FirstName, LastName FROM Friends WHERE FavoriteColor = 'purple';

FirstName LastName
Linda Jones

‘purple’ needs to be quoted because it is a string rather than a number. Numbers are not quoted.

Multiple conditions in a WHERE clause can be joined by the AND keyword. There is also an OR keyword.

SELECT FavoriteColor FROM Friends WHERE FirstName = 'Jenny' AND LastName = 'Davis';

FavoriteColor
blue

LIKE looks for data that matches a certain condition. LIKE has two wildcard characters: ‘_’ which matches any single character in a string, and ‘%’ which matches any number of characters in a string.

SELECT FirstName, LastName FROM Friends WHERE FirstName LIKE 'J%';

FirstName LastName
James Smith
Jenny Davis

ORDER BY sorts the returned data. ASC specifies ascending order and DESC specifies descending order.

SELECT FirstName, LastName FROM Friends ORDER BY LastName ASC;

FirstName LastName
Jenny Davis
Daniel Brown
Mary Johnson
Linda Jones
James Smith
Nancy Smith
David Williams

INSERT, UPDATE, DELETE

These are used to add, change, and delete rows in tables.

An INSERT statement adds a row to a table.  The syntax for an INSERT statement is:

INSERT INTO Friends (FirstName, LastName, FavoriteColor) VALUES ('David', 'Peterson', 'orange');

An UPDATE statement changes an existing row in a table.

UPDATE Friends SET LastName = 'Anderson' WHERE FirstName = 'Nancy';

A DELETE statement deletes a row from a table.

DELETE FROM Friends WHERE FirstName = 'David' AND LastName = 'Williams';

After executing these INSERT, UPDATE, and DELETE statements, our data looks like so:

Friends table:

FirstName LastName FavoriteColor
James Smith blue
Mary Johnson green
Linda Jones purple
Daniel Brown green
Jenny Davis blue
Nancy Anderson orange
David Peterson orange