PHP Tutorials By Kloplop321 » SQL

PHP & MySQL Tutorial 13: Posting on a Blog

Kloplop321 — Wed, 07 Jul 2010 23:51:14 +0000

This tutorial in essence goes over implementing posting and inserting data into a database, along with data validation for the blog. This one also extends on Tutorial 10, 11, 12, so please check those out if you have not.
Here’s the plan:

Make a page for posting
Make a form
Get the SQL for inserting
Prepare and validate data
Test page functionality
Finalize and clean up

Part 1:

Make sure to click on Read More so that you may see Part 2 and the sources.

Part 2:

So, back to the plan, I created the page to post from, and named it “put.php” and modeled the HTML from blog.php. I then put a form for posting in the put.php. At this point, I now have the static page done. By static, I mean that the part of the page that isn’t supposed to change. So, at this point, I need to put in the dynamic part into the page.
Here’s put.php so you may refer to it.
   1
   2    include(“connect.php”);
   3    if(isset($_POST['sub'])){
   4        $title = stripslashes(trim($_POST['title']));
   5        $content = stripslashes(trim($_POST['content']));
   6        $title2 = $title;
   7        $content2 = $content;
   8        $error = false;
   9        $reason = ”;
  10        if(strlen($title) < 3){
  11            $error = true;
  12            $reason .= “Bad Title.\n”;
  13        }
  14        if(strlen($content) < 3){
  15            $error = true;
  16            $reason .= “Bad Post Content.\n”;
  17        }
  18        if(!$error){
  19            $title = mysql_real_escape_string($title);
  20            $content = mysql_real_escape_string($content);
  21            $sql = “INSERT INTO `posts` (`ID`, `username`, `title`, `content`, `date`) VALUES
  22    (NULL, ”.$_SESSION['userid'].“, ’$title‘, ’$content‘, ”.time().“)”;
  23            mysql_query($sql);
  24            if(mysql_errno()){
  25                $reason .= mysql_error();
  26            }else{
  27                header(“location: blog.php”);
  28            }
  29        }else{
  30
  31        }
  32
  33    }
  34
  35    echo ‘’;
  36    ?>
  37
  38    <html xmlns=“http://www.w3.org/1999/xhtml” xml:lang=“en” lang=“en”>
  39    <head>
  40        <title>Blog titletitle>
  41        <link href=“main.css” type=“text/css” media=“screen” rel=“stylesheet” />
  42    head>
  43    <body>
  44        <div class=“maincontent”>
  45            <div class=“top”>
  46                Blog titlediv>
  47            <div class=“postform”>
  48                <form method=“POST” action=“?”>
  49                    Title: <input type=“text” name=“title” id=“postformtitle” value=“
  50                    if(isset($title2)){
  51                        echo htmlentities($title2);
  52                    }
  53                    ?>“ /><br />
  54                    Main Content:<br />
  55                    <textarea name=“content” id=“postformcontent” cols=“40″ rows=“4″>
  56                    if(isset($content2)){
  57                        echo htmlentities($content2);
  58                    }
  59                    ?>textarea><br />
  60                    <input type=“submit” value=“Send!” />
  61                    <input type=“hidden” name=“sub” value=“1″ />
  62                form>
  63                <div class=“errors”>
  64
  65                    if(isset($reason)){
  66                        echo $reason;
  67                    }
  68                    ?>
  69                    div>
  70            div>
  71        div>
  72    body>
  73    html>

As you see, I am using the isset((some form variable here)) thing to see if any data is being submitted. Within the code block (lines 4-32), I prepare the data by using both trim and stripslashes to clean up the content. The most important part is the strip slashes. For if I do not use it, a statement like
Hello “My Dear”
Will end up in the variable as
Hello \”My Dear\”

Obviously, a dirty escape is not what we want to show the user. Handling data like this can be very infuriating if you do not initially handle issues like this.
Furthermore, I duplicate the title and content variables so that the now-unescaped content could be fed back into the form if an error occurred. Then I do further data validation. In my case, I don’t want a post without any content, or a title. Therefore, preventative action is used so I will not end up with an undesired result.
Next, if all my tests are good, then I try to post the content using SQL INSERT. I grabbed the SQL to base it on from a table export, which uses similar syntax, I just needed to modify the example to fit my needs for new dynamic content.

However, when an error has occurred, I need to feed the data back in so the user doesn’t have to type everything back in. Ever had that happen? If you have had that happen because of something like “Oh noes, your session is over!”, I bet you found it really disheartening. Well, don’t make it happen to your users because a database problem happened, or they made a mistake on their side by forgetting a title. Make your systems forgiving!
So, this is why I had those duplicate variables. I can safely put these back into the page by using htmlentities to convert all special characters to their HTML form, as to act as text, and not literal text. Literal text can have other effects, like putting in Friendly cute puppies into the post, if it did not have htmlentities, it would allow problematic issues to arise.

Other than that, all I did to any other file, was add a link in blog.php
59 <li><a href=“put.php”>Posta>li>

So, anyway, You may download the Zip Archive that contains the sources so that you may experiment with them.
The Next tutorial will be going over editing, and the next will most likely be going over changing to a visual editor for the post.

PHP & MySQL Tutorial 11: Extending a Basic Blog

Kloplop321 — Tue, 29 Jun 2010 20:30:33 +0000

This tutorial goes over an inner join SQL query and extending the basic blog from tutorial 10 to have a link to a single-post page.
First of all, I am basing this tutorial on the last tutorial(10), which established a basic blog. Here we are going to compound the original statement that looks like
SELECT * FROM posts ORDER BY date DESC
What we are trying to do however, is to remove the statement that looks like
"SELECT postname FROM users WHERE ID = ”.$row['username']
and preserve the information on “Who posted it.”
The Second objective of this tutorial is to simply make the titles of the blog posts linked to a page that shows that post exclusively.
Here is Part 1 out of three, please watch all in their entirety so that you may understand them to the fullest.
Part 1:

Click on Read More to view the sources along with Part 2 and 3 of the video

Part 2:

Part 3:

First of all, I’m going to regurgitate the sources of this project and then explain what everything new means.
File: blog.php

   1
   2    include(“connect.php”);
   3
   4    echo ‘’;
   5    ?>
   6
   7    <html xmlns=“http://www.w3.org/1999/xhtml” xml:lang=“en” lang=“en”>
   8    <head>
   9        <title>Blog titletitle>
  10        <link href=“main.css” type=“text/css” media=“screen” rel=“stylesheet” />
  11    head>
  12    <body>
  13        <div class=“maincontent”>
  14            <div class=“top”>
  15                Blog titlediv>
  16            <div class=“posts”>
  17
  18                $sql = “SELECT posts.ID as `ID`,
  19    users.postname as `postname`,
  20    posts.title as `title`,
  21    posts.content as `content`,
  22    posts.date as `date`
  23
  24    FROM posts
  25
  26    INNER JOIN users
  27
  28    ON users.ID = posts.username
  29
  30    ORDER BY date DESC”;
  31                $result = mysql_query($sql);
  32                while($row=mysql_fetch_array($result)){
  33                ?>
  34                <div class=“post”>
  35                    <span class=“author”>
  36                    echo $row['postname'];
  37                    ?>span> Wrote
  38                    <a class=“title” href=“post.php?post=
  39                    echo htmlentities($row['ID']);
  40                    echo ‘”>’;
  41                    echo htmlentities($row['title']);
  42                    ?> at
  43                    echo date(‘l jS \of F Y h:i:s A’,(int)$row['date']);
  44                    ?>
  45                    <div class=“content”>
  46                    echo htmlentities($row['content']);
  47                    ?>div>
  48                div>
  49
  50                }
  51                ?>
  52            div>
  53        div>
  54    body>
  55    html>

File: Post.php

   1
   2    include(“connect.php”);
   3    $postid = (int)trim($_GET['post']);
   4    $sql = “SELECT posts.ID as `ID`,
   5    users.postname as `postname`,
   6    posts.title as `title`,
   7    posts.content as `content`,
   8    posts.date as `date`
   9
  10    FROM posts
  11
  12    INNER JOIN users
  13
  14    ON users.ID = posts.username
  15
  16    WHERE posts.ID = $postid
  17    ORDER BY date DESC”;
  18    $result = mysql_query($sql);
  19    $postdata = array();
  20    while($row=mysql_fetch_array($result)){
  21            $postdata = $row;
  22    }
  23
  24    echo ‘’;
  25    ?>
  26
  27    <html xmlns=“http://www.w3.org/1999/xhtml” xml:lang=“en” lang=“en”>
  28    <head>
  29        <title>Blog title ->
  30        echo htmlentities($postdata['title']);
  31        ?>title>
  32        <link href=“main.css” type=“text/css” media=“screen” rel=“stylesheet” />
  33    head>
  34    <body>
  35        <div class=“maincontent”>
  36            <div class=“top”>
  37                <a href=“blog.php”>Blog titlea>div>
  38            <div class=“posts”>
  39                <div class=“post”>
  40                    <span class=“author”> echo htmlentities($postdata['postname']); ?>span> Wrote
  41                    <span class=“title”> echo htmlentities($postdata['title']); ?>span> at
  42                    echo date(‘l jS \of F Y h:i:s A’,(int)$postdata['date']);
  43                    ?>
  44                    <div class=“content”> echo htmlentities($postdata['content']); ?>div>
  45                div>
  46            div>
  47        div>
  48    body>
  49    html>

File: Connect.php

   1
   2    $link = mysql_connect(‘localhost’, ‘phpuser’, ‘phppass’);
   3    if (!$link) {
   4        die(‘Could not connect: ’ . mysql_error());
   5    }
   6    //WE NEED to select the database!
   7    mysql_selectdb(“tutorials_blog”);
   8    ?>

The new INNER JOIN query:
   1
   2    SELECT posts.ID as `ID`,
   3    users.postname as `postname`,
   4    posts.title as `title`,
   5    posts.content as `content`,
   6    posts.date as `date`
   7
   8    FROM posts
   9
  10    INNER JOIN users
  11
  12    ON users.ID = posts.username
  13
  14    ORDER BY date DESC

There are major differences between this query and the last one.

Not selecting *(anything and everything in the tables)
Use of tableName.field
Use of the AS term
Use of INNER JOIN … ON (test of truth)

First of all in this query, we are no longer selecting * (anything and everything), because we have information in the second table that we do not want to bother with. Because of this need for specification, we can consider it adding power to our SQL. We select only what we need, and that includes information from both the user table and the posts table. So, we use the format tableName.fieldName, for a real example, in our “ON” matching case, we use posts.username and users.ID. However, We want to replace the username field in posts with the postname field from the user table. As you can see, this requires some sort of matching and complexity. This is where the INNER JOIN comes in.
We say INNER JOIN and then the table name, in our case users. Then, the most important part, the table data matching. We use ON and then a test of truth, or rather, does Column C from Table A match or satisfy the value in Column A in Table B.
I use ON users.ID = posts.username, however the users.ID and posts.username can be switched. Obviously, this is the most important part because it specifies what we are matching so we get the correct data from both tables.
Please see the video for how I implement this further, as it better show the process of how I compound the process.

Now for the second part, we wanted to put a link from the title of the posts, to a page that has only the post. Now, if you are reading this, you have already used that feature to get to that information. We may in the future implement a “read more” link system. Now, what I do is swap the span tag around the title, with an anchor tag (a). Then I put in a URL, this is where the
  38                    <a class=“title” href=“post.php?post=
  39                    echo htmlentities($row['ID']);
  40                    echo ‘”>’;
  41                    echo htmlentities($row['title']);
  42                    ?> at
is implemented.

Then, we simply need to make that post.php.
Simply stated, we needed to use the base.html(included in the source download, and shown in the last tutorial), add the date back in, and prepare the SQL environment and change the SQL just a bit.
The only change in the post page SQL is adding the WHERE clause in the correct place and not being ambiguous with what ID we are referring to. Hence, we end up with “WHERE posts.ID = $postid”
We also need to get the $postid, and as shown above in the blog.php, the link is using the post variable inside of GET(note, I am not referring to the POST variable, the GET is used in the URL). I can safely use this without mysql_real_escape_string or the like because I am casting(forcing the variable type) to a number.
Also, in the process of adding a post.php, I moved the MySQL connect information to connect.php which I am including now in both my blog.php and my post.php.
The rest of the post.php was really just filling in the information into the base template.

This zip Archive contains

connect.php
joining.sql(the join query by itself)
base.html
blog.php
main.css
post.php
tutorials_blog.sql(the database dump, you can just import this)

Remember, when you try to implement this tutorial on your end, you will need to change the MySQL connect information to work with your server or localhost settings.

Another thing, I forgot to show how to debug your SQL as I first mentioned(sorry), what you can do if you find out that something is not working or selecting the data correctly, after you do the query, you can do
echo mysql_error();
and it will tell you something if something is wrong. If nothing shows up, then it is your logic that is wrong, or you are not using the correct variables with the mysql_fetch_array

PHP & MySQL Tutorial 09: File Upload system with records in MySQL

Kloplop321 — Tue, 06 Apr 2010 01:15:55 +0000

This tutorial goes over the concept of uploading files, and keeping records in a MySQL database.
So lets try this
When: I need to upload files and keep long term records on who uploaded and where it is.
Why: I don’t know, you make up the reasons.
What: Exactly do you need to keep record of? Time, who sent it, where is it?
Who: Depends on how you implement
Where: On the Internet!
How: I’ll show you.

There are two parts, so pay attention closely. (The last part is always the most important) Don’t forget to see more of this post for the sources and part two!

So first we need to make our uploading page. It is pretty much an XHTML template base with an uploading form

<html>
<head>
<link href=“main.css” type=“text/css” media=“screen” rel=“stylesheet”/>
<title>Upload Indextitle>
head>

<body>
<form enctype=“multipart/form-data” action=“upload.php” method=“post”>
        Choose your file to upload!
        <input name=“uploadedfile” type=“file” />
        <br />
        And what would you like to call it? <input name=“title” type=“text” />
        <br />
        <input type=“submit” value=“upload file”/>
        form>

body>
html>

The most important part is the input for the file, the submit button and the form itself. In this case we have to say that there are multiple parts(the text, and the file) for this file upload so we set the enctype to “multipart/form-data”.
Since we are sending to another page(upload.php), we need to process it.
In upload.php, the basic way to save the file to the uploads directory is like the following(not final)

//time to see if the file is uploaded. $putItAt = "uploads/".basename($_FILES['uploadedfile']['name']); //hmm, will they try uploading a script or a page that might be a security risk? //lets prevent any .php from getting in, and rename with .txt $putItAt = str_replace("php","txt", $putItAt); if(move_uploaded_file($_FILES['uploadedfile']['tmp_name'],$putItAt)){ //we could echo, but why don't we just go to the file list now? savedata(); header("location: listfiles.php");//redirect them to the listfiles.php page }else{ //we failed. Lets try a slightly different method here. instead of moving, try copying if(copy($_FILES['uploadedfile']['tmp_name'],$putItAt)){ //we have success! savedata(); header("location: listfiles.php"); }else{ //we totally failed... so lets tell them. echo 'You totally failed. click here to go back and try again.'; } } ?>

Next it is noticed that we aren’t saving any information in the database. Here comes the MySQL part.
Make your table in the database, call it what ever you want, in my case I named it ‘thefiles’. The requirement is that we connect to the database and set our script up to be able to query in and for information.
$link = mysql_connect('localhost', 'phpuser', 'phppass'); if (!$link) { die('Could not connect: ' . mysql_error()); } //WE NEED to select the database! mysql_selectdb("tutorials_upload");
By putting that at the top of our script, we now have a connection to the database so now we want to insert our information when it is uploaded. Now the question is: do we want to be redundant and have the inserting code twice(for copy and move), or do we want to make a function and refer to that function twice? Honestly I choose the later, it makes the code cleaner.
//function time! function savedata(){ global $_FILES, $_POST, $putItAt; $sql = "INSERT INTO `tutorials_upload`.`thefiles` ( `ID` , `Time` , `FileLocation` , `IP` , `Title` ) VALUES ( NULL , UNIX_TIMESTAMP( ) , '".mysql_real_escape_string($putItAt)."', '".$_SERVER['REMOTE_ADDR']."', '".mysql_real_escape_string($_POST['title'])."' );"; mysql_query($sql); }

So now that I have this function, I need to implement it into the uploading code.
So, now my code finally for upload.php is
$link = mysql_connect('localhost', 'phpuser', 'phppass'); if (!$link) { die('Could not connect: ' . mysql_error()); } //WE NEED to select the database! mysql_selectdb("tutorials_upload"); if(!is_dir("uploads")){//do we need to make the uploads directory for the files? mkdir("uploads");//make the rest of the script safe, though this will only be done once } //function time! function savedata(){ global $_FILES, $_POST, $putItAt; $sql = "INSERT INTO `tutorials_upload`.`thefiles` ( `ID` , `Time` , `FileLocation` , `IP` , `Title` ) VALUES ( NULL , UNIX_TIMESTAMP( ) , '".mysql_real_escape_string($putItAt)."', '".$_SERVER['REMOTE_ADDR']."', '".mysql_real_escape_string($_POST['title'])."' );"; mysql_query($sql); } //time to see if the file is uploaded. $putItAt = "uploads/".basename($_FILES['uploadedfile']['name']); //hmm, will they try uploading a script or a page that might be a security risk? //lets prevent any .php from getting in, and rename with .txt $putItAt = str_replace("php","txt", $putItAt); if(move_uploaded_file($_FILES['uploadedfile']['tmp_name'],$putItAt)){ //we could echo, but why don't we just go to the file list now? savedata(); header("location: listfiles.php");//redirect them to the listfiles.php page }else{ //we failed. Lets try a slightly different method here. instead of moving, try copying if(copy($_FILES['uploadedfile']['tmp_name'],$putItAt)){ //we have success! savedata(); header("location: listfiles.php"); }else{ //we totally failed... so lets tell them. echo 'You totally failed. click here to go back and try again.'; } } ?>

Next, we have our file list page. We will start off with a basic XHTML template and have a CSS file linked in.

< !DOCTYPE HTML PUBLIC ”-//W3C//DTD HTML 4.0 Transitional//EN”>
<html>
<head>
<link href=“main.css” type=“text/css” media=“screen” rel=“stylesheet”/>
<title>Uploaded Filestitle>
head>

<body>

<br />
<a href=“index.php”>Go back to the indexa>
body>
html>

The main.css has

ul li {
    display: block;
    width: 160px;
    min-height: 160px;
    border: thin dashed black;
    float: left;
    padding: 8px;
}
ul {
    clear: both;
}
br {
    clear: left;
}

in it, which pretty much makes our list items boxes with a dashed border around them.

So the format I want to use is something like

<ul>
<li>
    <h1>YYYYYYYh1><br />
    <h3>Uploaded By: XXX.XXX.XXX.XXXh3><br />
    <a href=“uploads/ZZZZZZZ.jpg”>YYYYYYYa>
li>
ul>

So, in php, I would query the database for ‘thefiles’ and display the information in the like format.
//time to get our info $sql = "SELECT * FROM `thefiles`"; $result = mysql_query($sql); while($file = mysql_fetch_array($result)){ echo '

';
    echo ''.$file['Title'].'
';
    //now the file info and link
    echo 'Uploaded By: '.$file['IP'].'
';
    echo '.$file['FileLocation'].'">'.$file['Title'].'';
    echo '

';
}

?>

So, finally, our listfiles.php looks like (along with the MySQL connection section) this:



$link = mysql_connect('localhost', 'phpuser', 'phppass');
if (!$link) {
    die('Could not connect: ' . mysql_error());
}
//WE NEED to select the database!
mysql_selectdb("tutorials_upload");
?>



        
    Uploaded Files




//time to get our info
$sql = "SELECT * FROM `thefiles`";
$result = mysql_query($sql);
while($file = mysql_fetch_array($result)){
    echo '';
    echo ''.$file['Title'].'
';
    //now the file info and link
    echo 'Uploaded By: '.$file['IP'].'
';
    echo '.$file['FileLocation'].'">'.$file['Title'].'';
    echo '
';
}

?>




Go back to the index

All that put together provides something that looks like

and ends with

MySQL and PHPMyAdmin Introduction with PHP 07: A basic Guestbook

Kloplop321 — Mon, 15 Feb 2010 16:05:36 +0000

This is pretty much a basic “How to” for making a very basic guestbook that uses a database instead of text. I go over everything from making the database to the table, the html form and actual posting. If you watch this video you will pretty much see the basic idea of what a guestbook is, how they work, and how to make a basic one yourself.

This video has two parts, so to understand fully, please watch both.

Part 2 and the source after the jump

$link = mysql_connect('localhost', 'phpuser', 'phppass');
if (!$link) {
    die('Not connected : ' . mysql_error());
}else{
    //echo "I am connected. ";
}

// make foo the current db
$db_selected = mysql_select_db('guestbook', $link);
if (!$db_selected) {
    die ('Can\'t use guestbook DB : ' . mysql_error());
}
$name = trim($_REQUEST['name']);
$comment = trim($_REQUEST['comment']);
if(strlen($name)> 0){
    if(strlen($comment)> 0){
        $name = mysql_real_escape_string($name);
        $comment = mysql_real_escape_string($comment);

        $sql = "INSERT INTO `guestbook`.`entries` (
`ID` ,
`name` ,
`date` ,
`comment`
)
VALUES (
NULL , '$name', UNIX_TIMESTAMP( ) , '$comment'
);";
mysql_query($sql);
    }else{
        echo "You did not put in a comment.";
    }
}else{
    if(strlen($comment)> 0){
        echo "you got a comment, but not a name;";
    }
}
$sql = "SELECT *
FROM `entries` ORDER BY `ID` DESC
LIMIT 3";
$result = mysql_query($sql);
while($row = mysql_fetch_array($result)){
    echo $row['name']." Said: ".$row['comment']."

";
}
?>
<form action="?" method="post">
Name:
<input type="text" name="name" /><br />
Comment: <br />
<textarea name="comment">textarea><br />
<input type="submit" value="Submit" />
form>

PHP Tutorial: Databases in general

Kloplop321 — Sun, 14 Feb 2010 08:00:16 +0000

Developers often use the handy features included with databases to create solutions in PHP for what ever needs to be satisfied. Databases have functions like quickly matching data to Identifications, searching large sums of data, holding user information and much more that developers can utilize. There are many ways to use a database, or in this case, to interface with a database. Most databases use a rough standard of a Structured Querying Language, which is like code that the SQL server or application interprets. In PHP, developers have the following options to interface with a database:

Some of these methods use the same database type, such as MySQL and Mysqli. However I will only be focusing on the most common methods, which incude MySQL, SQLite, and OBCD.

Most PHP developers use MySQL due to its support, popularity, cross-platform, and universal capabilities. It is not proprietary like Microsoft Access Databases, and it has a really handy tool called PHPMyAdmin.

SQL looks like this

INSERT INTO My_table
(field1, field2, field3)
VALUES
(‘test’, ‘N’, NULL);

In PHP, we can wrap this in double quotes like so

$sql = "INSERT INTO My_table
 (field1, field2, field3)
 VALUES
 ('test', 'N', NULL);";

and then execute it with what ever database method we choose.

MySQL:
mysql_query($sql);
SQLite:
sqlite_query($db,$sql);
OBCD:
odbc_exec($db, $sql);

As I have only had personal experience with two of the above, I will not cover OBCD any more than the above.

Back to MySQL and SQLite:
Both MySQL and SQLite require an initiation at the beginning of each script execution. In MySQL’s case an example would be:

$link = mysql_connect('localhost', 'mysql_user', 'mysql_password'); if (!$link) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully'; mysql_close($link); ?>

The mysql_connect function is what initiates MySQL for use in future code execution. The $link variable in this example can be used in almost all mysql_* functions in the case of multiple connections (Which I do not recommend). If a developer wants to manually close the connection, they may do so by using mysql_close() which terminates the connection and frees the MySQL server’s resources.

For SQLite, we are using a local file instead of a server. Essentially, PHP, or rather the SQLite plugin for PHP handles the SQL execution and data manipulation. This is a great solution if a developer wants to make backups easily through more direct measures. Also, if a developer is in a situation like I am in with my school’s server, then this is a great solution. If you don’t care to understand my situation, skip to the next paragraph. My situation was where the Web Hoster (will remain un-named, for they do not deserve to be advertised) had it so there was no “localhost” mysql connection, but rather a single server dedicated for MySQL execution. Great idea in theory if you want to make use of idle hardware, but in reality it is horrid. My pages were stuck with a 2(rare) to 40 second (most common in the middle) delay because it had to wait to connect to the central server. This obviously would not do, so I tried to find a file-based solution without having to make my own with CSV and other hacked-up jobs. The result: instant execution, no noticeable delay.

SQLite, as aforementioned, uses a file as the database. SQLite has both its pros and cons.

Pros:

Fast
Simple
Not heavy on server load
Easy to copy

Cons:

People from the “other side” can download it if you put it in a public folder
It can be erased without a trace
it isn’t as flexible as MySQL

I prefer to MySQL because of PHPMyAdmin, but I can deal with SQLite thanks to this conversion code I came up with (Not bi-directional, only MySQL to SQLite)

$link = mysql_connect(‘localhost’, ‘USER’, ‘PASS’);
mysql_selectdb(“DB_NAME”);
$name = “TABLE_NAME”;
$sql = “SELECT *
FROM `$name` LIMIT 1″;
$res = mysql_query($sql);
$row = mysql_fetch_array($res);
$cols = mysql_num_fields($res);
$sql = “SELECT *
FROM `$name`”;
$res = mysql_query($sql);
$rowsdone = 0;
if ($db = sqlite_open(‘SQLITE_FILE_LOCATION’, 0666, $sqliteerror)) {
$res = mysql_query($sql);
while($row = mysql_fetch_array($res)){
$sqli = “INSERT INTO $name VALUES(“;
for($x = 0; $x < $cols; $x++){
$sqli .= “‘”.sqlite_escape_string($row[$x]).”‘”;
if($x != $cols -1){
$sqli .= ” , “;
}
}
$sqli .= “);”;
$result = sqlite_query($db,$sqli);
if(sqlite_last_error($db) != 1){
echo sqlite_error_string(sqlite_last_error($db)).”\n”;
//echo strip_tags($sqli);
echo “
\n “;
}
}
} else {
die ($sqliteerror);
}
?>

The above script is only for transferring rows not for adding the tables to SQLite.

As seen above, in order to “connect” or open the SQLite Database, we use the line:

if ($db = sqlite_open(‘SQLITE_FILE_LOCATION’, 0666, $sqliteerror)) {

0666 being the permissions code (no reference to satanic anything).

One note is that in MySQL, a developer would use mysql_real_escape_string to prepare strings for data entry, however in SQLite, a developer would use sqlite_escape_string (not the missing “real_” as there is no function named that).

A developer can use MySQL SQL in SQLite with a few adaptations:

A developer may not:

use ` in the SQL
use fieldnames that also are keywords like order, by, count, etc…

(I doubt that my suggestion is full and complete)

My method is to make everything through PHPMyAdmin, export it without comments, and use the table creation section in SQLite.

SQLite functions and MySQL functions are nearly interchangeable with just a text replacement and SQL checking, so I will from now on only cover MySQL (with possible exceptions).

A developer can make a database in MySQL with “CREATE DATABASE `DB_NAME_HERE` ;" and then in php select that database for future use through

mysql_selectdb(“DB_NAME_HERE“);

Next, if a developer so desire, he may create a table with SQL like the following

CREATE TABLE `DB_NAME_HERE`.`tablename` (

`id` INT( 8 ) UNSIGNED NOT NULL AUTO_INCREMENT ,
`description` TEXT NOT NULL ,
PRIMARY KEY ( `id` ) ,
INDEX ( `id` )

) ENGINE = MYISAM ;

Now that this intangible developer has a table, he can put information in like so:

INSERT INTO `DB_NAME_HERE`.`tablename` (

`id` ,
`description`

)
VALUES (

NULL , ‘Beans do not taste like fruit.’

);

A developer can use NULL as a value when the field has a default value or has an auto_increment property (like above).

Because I have set the id to be a primary key and index, there can be no duplicate keys(or identifications) in this table. Any developer who tries to force it will get an error.

If a developer is having an error in his code, he may use

echo mysql_error();

to find out what is wrong. In SQLite’s case he would need to use

echo sqlite_error_string(sqlite_last_error($db));

to find out what is wrong. In SQLite it isn’t as descriptive, so it takes more effort to find out what the issue is.

Next, in order to get information, a developer can do

$sql = “SELECT * FROM `TABLE_NAME`”;

$result = mysql_query($sql);

and there are various ways to get the information like

while($row = mysql_fetch_array($result)){

while($row = mysql_fetch_assoc($result)){

Either may be used, but I prefer array to assoc.

Next, the developer can get the information row by row by using the variable $row in this case

while($row = mysql_fetch_array($result)){

print_r($row);

}

The above code will print out the array that the mysql_fetch_array function returns for every row that is in the $result.

A Developer may also update a row by referring to an identification in the SQL as such

UPDATE `DB_NAME`.`tablename` SET `description` = 'Beans do not taste like fruit. Yet they are supposed to be magical...' WHERE `tablename`.`id` =1;

MySQL can also be compounded in terms of having multiple inserts (not selects) and updates, but they must be separated by a “;” and usually a new line.

If a developer would like to know if his current php interpreter has database connection functionality, use phpinfo(); and go to the page in the browser and search for “sql”. In my case, I have “–with-mysql” and “–with-sqlite” in my “Configure Command” section near the top.

This is only an introduction to the core and most useful features of Databases using Sequential Querying Languages. Further reading can be done at mysql.com php mysql sqlite.org and php sqlite.

MySQL and PHPMyAdmin Introduction with PHP 06

Kloplop321 — Wed, 10 Feb 2010 19:51:16 +0000

Want to dump your database? This video goes over the export feature of PHPMyAdmin which allows you to create and save file dumps of your database. You can use these dumps to make a duplicate database or update a pre-existing database. Or simply to backup regularly in case of database failure. I also marginally go over importing and how to import.