Go to new addres >>

Every time you download sql countries list it will be up to date for that very minute. This is because it is fetched and parsed from ISO.org just for your pleasure, every time you download (well if you don’t mind a bit of caching :P)

Here’s a little script that should help you with that (and with similar tasks). Download.
Install:

gunzip unrarr.gz
sudo cp unrarr /usr/bin/
sudo chmod +x /usr/bin/unrarr

Usage:

unrarr /path/to/folder

Edit:
To check rar files (through svf files) for consistency CVF package must be installed (cfv.sourceforge.net)

A database abstraction layer is an application programming interface which unifies the communication between a computer application and databases such as MySQL, Oracle or SQLite. Traditionally, all database vendors provide their own interface tailored to their products which leaves it to the application programmer to implement code for all database interfaces he would like to support. Database abstraction layers reduce the amount of work by providing a consistent API to the developer and hide the database specifics behind this interface as much as possible.

I will try to guide you through creating your own database abstraction php class.

1. Creating database object

Define abstraction class.

class Dapc {
}

Next thing we will do is create class method which will allow you to load specific data into php object. This method we will name init(). This method will need primary key, table name and array with table fields. We will define them later, don’t worry about that.

class Dapc {

  function init() {
    global $mysqli; // db connection holder... object.
    $mysqli->stmt_init();
    $key = $this->primary_key; // primary key
    $sql = "SELECT * FROM ".$this->table_name." where ".$this->primary_key." = ".$this->$key;
    $stmt = $mysqli->query($sql) or trigger_error('SQL QUERY ERROR: '.$sql);
    $obj = $stmt->fetch_array();
    foreach($this->fields as $k=>$v) {
      $this->$k = $obj[$k];
    }
    $this->object_loaded = 'Y';
    return true;
  }
}

Now what we have done here? We created sql query which will select all fields from given table ($this->table_name) which primary key ($this->primary_key) has value $this->$key and then loaded all those fields in single object.

Abstraction Interface

Above we have created bottom layer of our db abstraction. To use this we will need another layer which I call “interface”. This layer will keep you away from database. Lets create it.

First say we have example mysql table looking like this:

CREATE TABLE email
(
   ID INT NOT NULL AUTO_INCREMENT,
   name VARCHAR(35) NOT NULL,
   email VARCHAR(35) NOT NULL,
   PRIMARY KEY (ID)
);

Now that we have mysql table we can create little interface class. This class will extend our Dapc class. We will name this class something like {table_name}DAPC and define some variables. First primary key of our table (email) which is ID, next table name and finally table fields array. Table fields should be exactly like our fields in DB table. Form is ‘field_name’=>’field_type’ finally we will define simple flag which will tell us if object is loaded or not.

class emailDAPC extends Dapc {
  var $primary_key = 'id';
  var $table_name = 'email';

  protected $fields = array(
   'id'=>'int',
   'name'=>'string',
   'email'=>'string'
  );
  var $object_loaded = 'N';
}

Next we will create method for emailDAPC class called initData(). It is very simple and will only call init method from our DAPC class.

function initData() {
    $this->init();
 }

And constructor…

 function emailDAPC($id=-1) {
    if ($id!=-1) {
      $key = $this->primary_key;
      $this->$key = $id;
      $this->initData($id);
    }
    return true;
  }

Lets see what have we done so far… If we load class with value 12, email object will load fields and values from table email.

$email = new emailDAPC(12);
print_r($email);
/*Output
email Object
(
    ...
    [object_loaded] => 'Y'
    [id] => 12
    [email] => 'person@example.com'
    [name] => 'Some Person'
    ...
)
*/

Inserting/Updating DB data

To insert data in table we will need to create another method in bottom layer. This method will be called insert(). We will do similar thing as with init() :

  function insert() {
    global $mysqli;
    unset($stmt);
    $i = 0;
    foreach($this->fields as $k=>$v) {
      if ($obj->$k != $this->$k) {
        if ($i==0) $a = '';
        else $a = ' , ';
        if ($v=='int') $this->sql_prep .= $a.$k.'='.$this->$k;
        else $this->sql_prep .= $a.$k.'="'.$this->$k.'"';
        $i++;
      }
    }
    $sql = "INSERT INTO ".$this->table_name." SET ".$this->sql_prep;

    trigger_error('--> INSERT');
    trigger_error('Executing SQL: '.$sql);
    $mysqli->stmt_init();

    $stmt = $mysqli->prepare($sql) or trigger_error('SQL QUERY ERROR: '.$sql);
    $stmt->execute();
  }

We looped fields array (remember that we defined it in interface class) and create query. Very simple.

To be able to update rows we will create update method:

  function update() {
    global $mysqli;
    $mysqli->stmt_init();
    $key = $this->primary_key;
    $sql = "SELECT * FROM ".$this->table_name." where ".$this->primary_key." = ".$this->$key;
    $stmt = $mysqli->query($sql) or trigger_error('SQL QUERY ERROR: '.$sql);;
    $obj = $stmt->fetch_array();
    $i = 0;
    foreach($this->fields as $k=>$v) {
      if ($obj->$k != $this->$k) {
        if ($i==0) $a = '';
        else $a = ' , ';
        if ($v=='int') $this->sql_prep .= $a.$k.'='.$this->$k;
        else $this->sql_prep .= $a.$k.'="'.$this->$k.'"';
        $i++;
        trigger_error('PREPARE: '.$obj->$k.'!='.$this->$k.' ('.$key.'='.$this->$key.')');
      }
    }
    unset($stmt);
    $mysqli->stmt_init();
    $sql = 'UPDATE '.$this->table_name.' SET '.$this->sql_prep.' WHERE '.$this->primary_key.'='.$this->$key;
    trigger_error('--> UPDATE');
    trigger_error('Executing SQL: '.$sql);
    $stmt = $mysqli->prepare($sql) or trigger_error('SQL QUERY ERROR: '.$sql);
    $stmt->execute();
  }

Again same thing, build query from fields array and exec.

Now to simplify… we will create another method called saveDapc() If you remember we defined that flag $this->object_loaded we will use this flag so we can know what action is needed (insert or update). If object is loaded and saveDapc() method is called we will assume that update is needed and thus call update method and vice versa.

  function saveDapc() {
    if ($this->object_loaded=='Y') {
      $this->update();
    } else {
      $this->insert();
    }
  }

Saving from interface

With all this now it is very easy to insert/update database from interface. All we need to do is make another method called save() in our email table interface.

  function save() {
    if (!$this->validate()) {
      return false;
    }
    $this->saveDapc();
  }
 function validate() {
  return true;
 }

Here is how you will save data:

Insert

$email = new emailDAPC();
$email->name='Some person';
$email->email='name@example.com';
$email->save();
// That's all! Data inserted in DB

Now say we want to change email for some record. We will simply load it with it’s id:

$email = new emailDAPC(12);
$email->email='newmail@example.com';
$email->save();
// That's all! Email is changed!

Data delete can be done the same way as, say… update. Simply load object and call method delete().

As you see with db abstraction it is much easier/faster to work. Beside speed this will also allow to migrate to another sql server with only changing bottom level class.

I searched the way to get both on out-of-the-box mysql but failed (this can be enabled with use of sphinx mysql plugin). The best thing I could think of were triggers.

What are triggers?

Trigger is simple peace of sql code that is executed when predefined event happens. Most commonly they are used after insert or before insert.

General Idea

I we can’t have one table with full text and referential integrity then we need two tables one InnoDB and one MyIsam. It would be really stupid to create two identical tables, so I created new MyIsam table with only those columns I wanted to search and key which connects these two tables.
After this I needed a After Insert Trigger to execute so both tables would have identical content. Problem with this is that MySQL introduced triggers in version 5, which is still considered to be an very exotic peace of software.

Here is a sample Before Insert trigger:

mysql> CREATE TRIGGER test
-> AFTER INSERT ON t
-> FOR EACH ROW
-> BEGIN
->   INSERT INTO test2 SET column1 = NEW.column1;
->   INSERT INTO test3 SET column1 = NEW.column1 + 4;
->   END;//
Query OK, 0 rows affected (0.00 sec)

This feature is not to be confused with the LIKE function in MySQL. LIKE works more along the lines of a regular expression. On the other hand, FULLTEXT indices are fully indexed fields which support stopwords, boolean searches, and relevancy ratings.

How does it work ?

Adding Full Text to your table is very easy it will remind you of adding regular keys or indexes. We will begin with creating a simple news table and fill it with some content:

CREATE TABLE news
(
ID INT(9) UNSIGNED NOT NULL DEFAULT '0' AUTO_INCREMENT,
title CHAR(255) NOT NULL DEFAULT '',
body TEXT NOT NULL DEFAULT '',
PRIMARY KEY (ID),
FULLTEXT(title,body)
);

INSERT INTO news
VALUES (1,
'Pellentesque mauris',
'Pellentesque mauris turpis, porta vel, euismod sed,
pulvinar vitae, tortor. Duis accumsan. Suspendisse facilisis blandit mauris.');

INSERT INTO news
VALUES (2,
'Mauris eu massa',
'Praesent varius orci sit amet erat. Suspendisse sed quam non sapien
consectetuer scelerisque. Aliquam mauris pede, vestibulum vitae,
dapibus vel, cursus at, sapien. Nullam vel purus sit amet quam placerat
suscipit.');

INSERT INTO news
VALUES (3,
'Cum sociis',
'Ut auctor eleifend magna. Morbi porttitor, felis nec accumsan
elementum, lectus justo interdum sapien, non volutpat felis est quis
felis. Vestibulum nulla.');

INSERT INTO news
VALUES (4,
'Quisque dolor!',
'Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Sed sapien
nunc, feugiat et, ultrices eget, aliquam non, nulla. Cras mollis. Duis
eget eros. In mauris. Mauris purus massa, mollis at, malesuada in,
vulputate vitae, odio. Duis ut dolor. Phasellus id nunc non est dictum
porttitor.');

Getting results

Now that we have filled our table with some news we can start doing some queries.

SELECT ID,title
FROM news
WHERE MATCH (title,body) AGAINST('sociis');

Ok this is simplest full text search query. There are few things you must know tho.
Columns in match() must always be the same ones that we defined as fulltext.

With fulltext you will get results sorted by their relevance aka score, lets display that score.

SELECT ID,title
FROM news
WHERE MATCH (title,body) AGAINST('sociis') as score;

Using full text search doesn’t not forbid you to use other sql statements, for example limit etc.

Boolean mode

SELECT ID,title
FROM news
WHERE MATCH (title,body) AGAINST('+sed -mauris') as score;

You can filter results given by searching with boolean query. Look at against(), you will notice + and – signs in front of keywords, + sign means that word will be included in search and minus sign means that all results containing this keyword will be excluded from search.

And at the end I must warn you that Full Text search is not supported on InnoDB table engine. (so referential integiry and full text don’t stack)

Just to give you all a hint in the right direction here is the simplest “pagination” query used on Oracle.

(select * from emp
where rownum <=var)
minus
(select * from emp
where rownum<=(var-100))

ex.
var = 100 Will give first 100 results and var = 200 will give next 100 results.

Our database is receiving data over serial port so there was Alot of garbage. Sice it’s such a huge table and there was so much invalid date formats I was forced to create decent Oracle replacement for VB function IsDate:

CREATE FUNCTION ISDATE( ip_date in varchar2 )
return date
is
begin
return to_date(ip_date,'dd-mm-yyyy');
exception
when others
then return null;
end isdate;

Only flaw I found was that you need to predefine date type you need… but we already knew that so it was not a problem.

Hope this helps someone!

CREATE TABLE news (id TINYINT NOT NULL AUTO_INCREMENT,
title VARCHAR(50), body VARCHAR(255) NOT NULL, PRIMARY KEY(id)) ENGINE=INNODB;
Query OK, 0 rows affected (0.11 sec)

INSERT INTO novosti VALUES (1, 'Some title, 'Testing body'), (2, 'Another title', 'Again some body for news');
Query OK, 4 rows affected (0.06 sec)
Records: 4  Duplicates: 0  Warnings: 0

To show example of referential integrity we will create another table called ‘comments’

CREATE TABLE comments (
id INT(4) NOT NULL,
title VARCHAR(50) NOT NULL,
comment VARCHAR(255) NOT NULL,
id_news TINYINT(4) NOT NULL,
INDEX (id_news),
FOREIGN KEY (id_news) REFERENCES novosti (id),
PRIMARY KEY(id)
) ENGINE=INNODB;

In table comments we defined foreign key id_news and referred it to id field in table news. I we tried to insert random rows in comments table it would look something like this:

INSERT INTO comments VALUES (1, 'Comment title', 'Some comment text', 91);
ERROR 1216 (23000): Cannot add or update a child row: a foreign key
constraint fails

Note: look at first and last value of this insert, note that it does not match any news so this comment would be just junk data.
So we are protected on database level from junk data. Even tho this is highly recommended don’t try to dump your application level validation, since you need error handling (so you users don’t get ugly errors) and also mysql is not able to validate data for example E-mail addresses.

Hope it helps.