[edit] Last updated: Mon, 01 Nov 2010

CXLIX. Fonctions SQLite

Introduction

Cette extension fait l'interface avec le moteur de base SQLite Embeddable SQL Database Engine. SQLite est une bibliothèque C qui implémente un moteur de bases de données SQL embarqué. Les programmes qui utilisent SQLite peuvent disposer d'un accès à une base de données SQL, sans avoir à faire tourner d'autre processus serveur.

SQLite n'est pas un logiciel client pour se connecter à un grand nom des bases de données. SQLite est le serveur. La bibliothèque SQLite lit et écrit directement dans les fichiers de bases de données sur le disque.

Note : Pour plus d'informations sur SQLite, voyez le site web http://sqlite.org/.

Installation

Lisez le fichier d'installation, qui est fourni avec la distribution. Ou bien, utilisez simplement l'installeur PEAR : pear install sqlite. SQLite est déjà fourni avec PHP et vous n'avez pas besoin de télécharger d'autres logiciels.

Les utilisateurs de Windows peuvent télécharger la version DLL de l'extension SQLite ici : php_sqlite.dll.

Dans la version 5 de PHP, l'extension SQLite ainsi que le moteur sont intégrés et compilés par défaut. Cependant, depuis PHP 5.1.0, vous devez activer manuellement cette extension dans le php.ini (parcequ'il est maintenant inclus en tant que partagé). De plus, depuis PHP 5.1.0, SQLite dépend de PDO, alors il doit être aussi activé, en ajoutant les lignes suivantes au php.ini (dans l'ordre) :

extension=php_pdo.dll
extension=php_sqlite.dll

Sous les systèmes Lunix ou Unix, si vous compilez PDO en tant qu'extension partagée, vous devez également compilez SQLite en tant qu'extension partagée en utilisant l'option de configuration --with-sqlite=shared.

SQLite 3 est supportée à travers PDO SQLite.

Installation sur Windows pour les comptes sans privilèges : Sur les systèmes d'exploitation Windows, les comptes sans privilèges n'ont pas la variable d'environnement TMP d'initialisée par défaut. Cela fera créer des fichiers temporaires par sqlite dans le dossier de windows, ce qui n'est pas voulu. Alors, vous devriez initialiser la variable d'environnement TMP pour le serveur web ou dans le compte utilisateur où le serveur web fonctionne. Si Apache est votre serveur web, vous pouvez accomplir cela via une directive SetEnv dans votre fichier httpd.conf. Par exemple :
SetEnv TMP c:/temp
Si vous êtes incapable d'établir cette configuration à ce niveau du serveur, vous pouvez implémenter cette configuration dans votre script :

putenv('TMP=C:/temp');
La configuration doit référer à un répertoire à l'intérieur duquel le serveur web a la permission de créer des fichiers et bien sûr d'y écrire et supprimer les fichiers créés. Autrement, vous recevrez le message d'erreur suivant : malformed database schema - unable to open a temporary database file for storing temporary tables

Pré-requis

Afin de disposer de ces fonctions, vous devez compiler PHP avec le support SQLite, ou charger dynamiquement l'extension SQLite depuis votre fichier php.ini.

Types de ressources

Il y a deux ressources, utilisées par l'extension SQLite. La première est une connexion à la base et la seconde est un résultat de requête.

Constantes pré-définies

Ces constantes sont définies par cette extension, et ne sont disponibles que si cette extension a été compilée avec PHP, ou bien chargée au moment de l'exécution.

Les fonctions sqlite_fetch_array() et sqlite_current() utilisent des constantes pour spécifier les différents types de résultats. Les constantes sont les suivantes :

Constantes de résultats SQLite

SQLITE_ASSOC (entier): Les colonnes sont retournées dans le tableau, en utilisant le nom de la colonne comme nom d'index.
SQLITE_BOTH (entier): Les colonnes sont retournées dans le tableau, en utilisant simultanément le nom de la colonne comme nom d'index et un index numérique.
SQLITE_NUM (entier): Les colonnes sont retournées dans le tableau, en utilisant une indexation numérique. L'index commence à 0, pour identifier le premier champ.

Un certain nombre de fonctions peuvent retourner des codes d'état. Les constantes suivantes sont définies :

Constantes codes d'état SQLite

SQLITE_OK (entier): Résultat réussi.
SQLITE_ERROR (entier): Erreur SQL ou base de données manquante.
SQLITE_INTERNAL (entier): Une erreur interne de logique dans SQLite.
SQLITE_PERM (entier): Permission d'accès refusée.
SQLITE_ABORT (entier): Routine de procédure de rappel a demandé un abandon.
SQLITE_BUSY (entier): Le fichier de base de données est verrouillé.
SQLITE_LOCKED (entier): Une table dans la base de données est verrouillée.
SQLITE_NOMEM (entier): Allocation de mémoire échouée.
SQLITE_READONLY (entier): Essai d'écrire dans une base de données en lecture seule.
SQLITE_INTERRUPT (entier): Opération terminée de manière interne.
SQLITE_IOERR (entier): Erreur disque I/O s'est produite.
SQLITE_CORRUPT (entier): L'image disque de la base de données est malformée.
SQLITE_NOTFOUND (entier): (Interne) Table ou enregistrement non trouvé.
SQLITE_FULL (entier): Insertion échouée car la base de données est pleine.
SQLITE_CANTOPEN (entier): Impossible d'ouvrir le fichier de base de données.
SQLITE_PROTOCOL (entier): Erreur du protocole de verrou de base de données.
SQLITE_EMPTY (entier): (Interne) Une table de la base de données est vide.
SQLITE_SCHEMA (entier): Le schéma de base de données a changé.
SQLITE_TOOBIG (entier): Trop de données pour une ligne de la table.
SQLITE_CONSTRAINT (entier): Arrêt dû à une violation de contrainte.
SQLITE_MISMATCH (entier): Type de données incorrect.
SQLITE_MISUSE (entier): Bibliothèque utilisée incorrectement.
SQLITE_NOLFS (entier): Utilisation de fonctionnalités de l'OS non supportées sur l'hôte.
SQLITE_AUTH (entier): Autorisation échouée.
SQLITE_ROW (entier): Processus interne a une autre ligne prête.
SQLITE_DONE (entier): Processus interne a terminé l'exécution.

Classes pré-définies

SQLiteDatabase

Représente une base de données SQLite ouverte.

Constructeur

__construct - construit un nouvel objet SQLiteDatabase

Méthodes

query - Exécute une requête
queryExec - Exécute une requête de résultat
arrayQuery - Exécute une requête et retourne les résultats dans un tableau
singleQuery - Exécute une requête et retourne soit un tableau pour une seule colonne, soit la valeur de la première ligne
unbufferedQuery - Exécute une requête non bufférisée
lastInsertRowid - Retourne l'identifiant de la dernière ligne insérée
changes - Retourne le nombre de lignes modifiées par la dernière requête
createAggregate - Enregistre une UDF agrégeante pour les requêtes SQLite
createFunction - Enregistre une fonction utilisateur "classique" UDF pour SQLite
busyTimeout - Configure ou désactive le délai d'attente d'une base SQLite occupée
lastErorr - Retourne le dernier code erreur de la dernière erreur rencontrée
fetchColumnTypes - Retourne un tableau de types de colonnes depuis une table particulière

SQLiteResult

Représente un jeu de résultats SQLite bufférisé.

Méthodes

fetch - Récupère la ligne suivante depuis un jeu de résultats en tant que tableau
fetchObject - Récupère la ligne suivante depuis un jeu de résultats en tant qu'objet
fetchSingle - Récupère la première ligne depuis le jeu de résultats en tant que chaîne de caractères
fetchAll - Récupère toutes les lignes depuis le jeu de résultats en tant que tableau de tableaux
column - Récupère une colonne depuis la ligne courante du jeu de résultats
numFields - Retourne le numéro du champ depuis un jeu de résultats
fieldName - Retourne le nom d'un champ particulier depuis le jeu de résultats
current - Récupère la ligne courante depuis le jeu de résultat en tant que tableau
key - Retourne l'index de la ligne courante
next - Déplace le pointeur sur le numéro de ligne suivante
valid - Retourne si oui ou non il reste des lignes de disponibles
rewind - Déplace le pointeur sur le numéro de la première ligne d'un jeu de résultats
prev - Déplace le pointeur sur le numéro de ligne précédent du jeu de résultats
hasPrev - Retourne si oui ou non une ligne précédente est disponible
numRows - Retourne le nombre de lignes dans le jeu de résultats
seek - Déplace le pointeur vers un numéro de ligne précis

SQLiteUnbuffered

Représente un jeu de résultats SQLite non-bufférisé. Les jeux de résultats non-bufférisés sont séquentiels, déplacement du pointeur uniquement vers le numéro suivant.

Méthodes

fetch - Récupère la ligne suivante depuis un jeu de résultats en tant que tableau
fetchObject - Récupère la ligne suivante depuis un jeu de résultats en tant qu'objet
fetchSingle - Récupère la première colonne depuis un jeu de résultats en tant que chaîne de caractères
fetchAll - Récupère toutes les lignes depuis le jeu de résultats en tant que tableau de tableaux
column - Récupère une colonne depuis la ligne courante d'un jeu de résultats
numFields - Retourne le nombre de champs dans le jeu de résultats
fieldName - Retourne le nom d'un champ en particulier depuis le jeu de résultats
current - Récupère la ligne courante depuis le jeu de résultats en tant que tableau
next - Déplace le pointeur vers un numéro de ligne suivant
valid - Retourne si oui ou non il reste des lignes de disponibles

Configuration à l'exécution

Le comportement de ces fonctions est affecté par la configuration dans le fichier php.ini.

Tableau 1. Options de configuration SQLite

Nom	Par défaut	Modifiable	Historique
sqlite.assoc_case	"0"	PHP_INI_ALL	Disponible depuis PHP 5.0.0.

Pour plus de détails sur les constantes PHP_INI_*, reportez-vous à Annexe G.

Voici un éclaircissement sur l'utilisation des directives de configuration.

sqlite.assoc_case int

Utilise des index à casse libre (0), majuscule (1) ou minuscule (2).

Cette option sert principalement lorsque vous avez besoin de la compatibilité avec d'autres systèmes de bases de données, où les noms des colonnes sont toujours retournés en majuscule ou en minuscule, indépendamment de la casse réelle de la colonne dans la base.

La bibliothèque SQLite retourne le nom de la colonne sans y toucher (c'est la casse qui sera utilisée dans votre base). Lorsque sqlite.assoc_case vaut 0 cette casse sera conservée. Lorsque cette option vaut 1 ou 2, PHP va modifier la casse des noms, et mettre le nom de la colonne respectivement en majuscules ou minuscules.

Utiliser cette option implique une légère perte de performances, mais c'est BEAUCOUP plus rapide que de faire la gestion des caractères vous-même.

Table des matières
sqlite_array_query -- Exécute une requête SQL avec SQLite et retourne un tableau
sqlite_busy_timeout -- Configure le délai d'attente d'une base SQLite occupée
sqlite_changes -- Retourne le nombre de lignes qui ont été modifiées par la dernière requête SQLite
sqlite_close -- Ferme la connexion à SQLite
sqlite_column -- Lit la valeur d'une colonne dans un résultat SQLite
sqlite_create_aggregate -- Enregistre une UDF agregeante pour les requêtes SQLite
sqlite_create_function -- Enregistre une fonction utilisateur "classique" UDF pour SQLite
sqlite_current -- Lit une ligne de résultat SQLite dans un tableau
sqlite_error_string -- Retourne le message d'erreur SQLite
sqlite_escape_string -- Protège une chaîne de caractères pour utilisation avec SQLite
sqlite_exec -- Exécute une requête sans résultats sur une base de données
sqlite_factory -- Ouvre une base SQLite et crée un objet pour elle
sqlite_fetch_all -- Retourne toutes les lignes d'un jeu de résultats en tant que tableau de tableaux
sqlite_fetch_array -- Lit la prochaine ligne de résultat SQLite dans un tableau
sqlite_fetch_column_types -- Retourne un tableau des types de colonnes d'une certaine table
sqlite_fetch_object -- Retourne la ligne suivante du jeu de résultats en tant qu'objet
sqlite_fetch_single -- Lit la première ligne d'un résultat SQLite sous forme de chaîne
sqlite_fetch_string -- Alias de sqlite_fetch_single()
sqlite_field_name -- Retourne le nom du champ SQLite
sqlite_has_more -- Indique s'il reste des lignes SQLite à lire
sqlite_has_prev -- Retourne si oui ou non une ligne précédente est disponible
sqlite_key -- Retourne l'index de la ligne courante
sqlite_last_error -- Retourne le dernier code d'erreur SQLite
sqlite_last_insert_rowid -- Retourne le numéro de ligne de la dernière ligne insérée
sqlite_libencoding -- Retourne l'encodage utilisé par la bibliothèque SQLite
sqlite_libversion -- Retourne la version de la bibliothèque SQLite
sqlite_next -- Déplace le pointeur SQLite vers la prochaine ligne
sqlite_num_fields -- Retourne le nombre de champs dans un résultat SQLite
sqlite_num_rows -- Retourne le nombre de lignes d'un résultat SQLite
sqlite_open -- Ouvre une base SQLite et la crée si elle n'existe pas
sqlite_popen -- Ouvre une connexion SQlite persistante et crée la base si elle n'existe pas
sqlite_prev -- Se positionne sur le numéro de ligne précédent du jeu de résultats
sqlite_query -- Exécute une requête SQLite et lit le résultat
sqlite_rewind -- Place le pointeur de résultat SQLite au début
sqlite_seek -- Déplace le pointeur de résultat SQLite vers une ligne
sqlite_single_query -- Exécute une requête et retourne soit un tableau pour une colonne unique, soit la valeur de la première ligne
sqlite_udf_decode_binary -- Décode des données binaires, passées à une UDF SQLite
sqlite_udf_encode_binary -- Encode les données binaires d'une UDF SQLite avant de les retourner
sqlite_unbuffered_query -- Exécute une requête SQLite non bufférisée
sqlite_valid -- Retourne si oui ou non il reste des lignes disponibles

sqlite_array_query

spl_classes

[edit] Last updated: Mon, 01 Nov 2010

add a note User Contributed Notes Fonctions SQLite

CraquePipe 16-Sep-2011 05:54


The SQLite manual mentions that queries are done in a case-sensitive way, this means your query must be the correct case. It also mentions that using the "LIKE" operator will do a case-insensitive selection. This is true, but this also introduces wildcard symbols which a user could enter without getting filtered by the SQLite escape function. I'm somewhat new to SQL and I didn't think of doing this before, even after looking for a decent way to do case-insensitive queries.



For case-insensitive queries, simply use the built in "lower" function.

<?php

// ... 

$name = 'bARbarA';

$rows = $db->arrayQuery('select * from blah where lower(name) = lower(\''.sqlite_escape_string($name).'\');');

// $rows might contain an entry for "Barbara" now.

?>

iphone at kkk ccc sss dot gr 06-Dec-2009 10:35


a simplier way to find out if a table exists:





<?php


$db=sqlite_open('mydb.sqlite', 0666, $sqliteerror); 


$query = sqlite_query($db, "SELECT name FROM sqlite_master WHERE type='table' and name='the_table_Im_looking_for'");


$totaltables = sqlite_num_rows($query);


    if ($totaltables<1){


/* table does not exist...create it or do something... */


}


else{


/* table exists...don't create again , do something else */ 


}


?>

vincent at tigroux dot net 10-Oct-2006 03:19


on win 32



the error "malformed database schema - unable to open a temporary database file for storing temporary tables" may happen if the temp and tmp env vars are typed like this : %WINDIR/Temp



Replace by C:/Windows/Temp and the error will disappear.

papafox888 at hotmail dot com 01-Jun-2006 09:05


If you get an error message:



     Warning: sqlite_open() [function.sqlite-open]: file is encrypted or is not a database



then most probably your code is accessing a SQLite3 database.



sqlite_open() only supports SQLite2.  Use PDO to access SQLite3.

Egon at example dot com 21-Feb-2006 05:15


<$php

public function set_by_db_with_join_to_users_department($col, $foo){

    $list = "da.ROWID, da.dept_id, da.script, da.action, da.description, ud.name";

    $query = "SELECT $list FROM dept_access AS da, users_department AS ud

        WHERE da.dept_id = ud.ROWID

        AND da.$col = '$foo';";



    $db = new SQLiteDatabase (dept_access::db_path, 0666, &$error)

        or die("Failed: $error");

    $db->queryExec("ATTACH DATABASE '".dept_access::db_users_path."' AS users");

    $row = $db->arrayQuery($query, SQLITE_ASSOC);

    unset($db);



echo $query."\n";

echo var_dump($row);

    $this->ROWID = $row[0]['da.ROWID'];

    $this->dept_id = $row[0]['da.dept_id'];

    $this->dept_name = $row[0]['ud.name'];

    $this->script = $row[0]['da.script'];

    $this->action = $row[0]['da.action'];

    $this->description = $row[0]['da.description'];

}

?>



For ATTACH DATABASE to work you need to run it in a $db->queryExec(ATTACH DATABASE...); before using $db->arrayQuery. This is most likly the case with other OO methods to. This on stumped me for a while.

heinemann.juergen AT t-online.de 11-Nov-2005 09:53


Simple Example for using SQLite for small Buffering Clipboard ;)



<?php



// $Id: SQLiteClipboard.php5,v 1.1 2005/09/09 10:15:26 heinemann Exp $



/**

 * @callgraph

 * @class      SQLiteClipboard

 * @short      Simple Read/Write Clipboard Class

 * @version    0.0.1

 * @since      Fr Sep  9 08:14:45 CEST 2005

 * @code

   $sqlite = new SQLiteClipboard( MY_TEMP_DIR );

   if ( $sqlite->INSERTING = time() )

      var_dump( $sqlite->INSERTING );

   else

      echo "Nothing done!";

 * @endcode

 */



final class SQLiteClipboard

{

   private $SQL;

   private $DB = "Clipboard.sqlite";

   private $TB = "Clipboard";

   private $ID = "ID";

   private $PA = "PARAM";

   private $VA = "VAL";



   function __construct( $path )

   {

      $this->DB = chop( $path . "/" . $this->DB );

      $this->sql_init();

   }



   private function sql_init()

   {

      $this->SQL = new SQLiteDatabase( $this->DB, 0660 );

      if ( ! file_exists( $this->DB ) )

         die( "Permission Denied!" );



      $q = $this->SQL->query("PRAGMA table_info(" . $this->TB . ")");

      if ( $q->numRows() == 0 ) {

         $this->SQL->query( "CREATE TABLE " . $this->TB . " ( " . $this->ID . " INTEGER PRIMARY KEY, " . $this->PA . " CHAR(255), " . $this->VA . " CHAR(255) );" );

      }

   }



   private function sql_check( $p )

   {

      $o = null;

      $q = $this->SQL->query( "SELECT " . $this->ID . " FROM " . $this->TB . " WHERE ( " . $this->PA . "='$p' ) ORDER BY " . $this->ID . " LIMIT 1" );

      while( $q->valid() ) {

         $r = $q->current();

         return $r[$this->ID];

         $q->next();

      }

      return false;

   }



   public function __get( $p )

   {

      $q = $this->SQL->query( "SELECT " . $this->VA . " FROM " . $this->TB . " WHERE ( " . $this->PA . "='$p' ) ORDER BY " . $this->ID );

      while( $q->valid() ) {

            $r = $q->current();

            $o = $r[$this->VA];

            $q->next();

      }

      return $o;

   }



   public function __set( $p, $v )

   {

      if ( $this->sql_check( $p ) && ! empty( $v ) )

         return $this->SQL->query( "UPDATE " . $this->TB . " SET " . $this->VA . "='$v' WHERE ( " . $this->PA . "='$p' );" );

      elseif  ( ! $this->sql_check( $p ) && ! empty( $v ) )

         return $this->SQL->query( "INSERT INTO " . $this->TB . " ( " . $this->PA . ", " . $this->VA . " ) VALUES ('$p', '$v' );" );

      elseif  ( $this->sql_check( $p ) && empty( $v ) )

         return $this->SQL->query( "DELETE FROM " . $this->TB . " WHERE ( " . $this->PA . "='$p' );" );

      else

         return false;

   }



} // end Class



?>

31-Aug-2005 04:21


A function to check whether a table exists:



<?php

function sqlite_table_exists(&$sqlite, $table)

{

    $result = $sqlite->query("SELECT name FROM sqlite_master WHERE type='table' AND name='$table'");

    return $result->numRows() > 0;

}

?>

bens at effortlessis dot com 14-Jul-2005 11:37


Sqlite by default allows for foreign keys, but doesn't enforce them. 



I found a nice article on how to enforce foreign keys  at http://www.justatheory.com/computers/databases/sqlite/ 



It would be nice if this could be handled with a wrapper class, so that adding foreign keys is done thru a wrapper API to automate the generation of the necessary enforcement triggers. If nobody's done this by the time I start coding against SqlLite/PHP5 in 6-12 months, I'll write one myself, possibly by modifying "jon at jenseng dot com"s alter table wrapper 



Anyway, it's not PHP specific, but anybody using Sqlite really should know this!

Stephen Leaf 30-Jun-2005 05:58


I think it would be good to point out that currently (as of 5.0.4) this extention does not support SQLite 3 databases.

So if your getting an error message like:

Error: file is encrypted or is not a database

That is why.

bart at mediawave dot nl 18-Apr-2005 07:30


SELECT tablename.columnname FROM table;



will cause SQLite to return an array having tablename.field_name as the array index. (e.g. $result['tablename.field_name'])



To let SQLite return an array having only field_name as the array index (e.g. $result['field_name']) you can issue a 'PRAGMA short_column_names = 1' query:



sqlite_query($connection_id, 'PRAGMA short_column_names = 1');



This behaviour is more consistent with the other database extensions.



For a full list of all pragmas visit: http://sqlite.org/pragma.html

dotwho at NOSPAM dot mac dot com 09-Feb-2005 06:03


This may have been obvious to others, but I had a tough time finding the info.



The default location for the actual database file is the same location of the php doc that created the database. You can alter this behavior by specifying the full path in the creation call:



<php

$db = sqlite_open("/absolute/path/my_sqlite.db");

?>



Note that if you used the default location, the db file may be served up by the webserver if it is in a the http document path. This is obviously a security risk that should be avoided.



//Max

hunreal+php at gmail dot com 16-Jan-2005 08:42


Check the db/table if exist



$db_name='db';

$db=new SQLiteDatabase($db_name, 0666, $error);

if ($error) exit($error);

$q=$db->query("PRAGMA table_info(test)");

if ($q->numRows()!=2) {

    if (!@$db->queryexec("

        CREATE TABLE test (

            id INTEGER NOT NULL PRIMARY KEY,

            text VARCHAR ( 255 ) NOT NULL

            )")

    ) exit ("Create SQLite Database Error\n");

}

nicolas dot toniazzi at free dot fr 16-Nov-2004 07:24


The same in 3 lines.



<?php

function sqlite_table_exists($db,$mytable) {

  /* counts the tables that match the name given */

  $result = sqlite_query($db,"SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='$mytable'");



  /* casts into integer */

  $count = intval(sqlite_fetch_single($result));



  /* returns true or false */

  return $count > 0;

}

?>

alexs at alphacomolex dot info 28-Oct-2004 03:41


the OO version.

<?php

function sqlite_table_exists($db,$mytable) {

    // ask the database kindly what tables is has.

    $result = $db->query("SELECT name FROM sqlite_master WHERE type='table'");

    $tables = $result->fetchAll();

    // if there's no items in the array then our taget is not going to exists.

    if (count($tables) == 0) {

        return FALSE ; 

    }

    // loop over the tables to see if there's a table we're looking for.

    foreach ($tables as $table) {

        if ($table['name'] == $mytable) {

            return(TRUE);

        }

    }    

    // there was no such table, informe the user the bad news. 

    return(FALSE);

}

?>

artooro at gmail dot com 21-Oct-2004 06:26


If you need to check if a table exists, you can use a function like this:

<?php

//Returns TRUE if table exists and FALSE otherwise

//  $mytable = table you want to check for



function sqlite_table_exists($mytable) {

$db = sqlite_open('mydb.sqlite', 0666, $sqliteerror);

    $query = sqlite_query($db, "SELECT name FROM sqlite_master WHERE type='table'");

    $tables = sqlite_fetch_array($query);

    if ($tables != '') {

        foreach ($tables as $table) {

            if ($table == $mytable) {

                return("TRUE");

            }

            else {

                return("FALSE");

            }

        }

    }

    else {

        return("FALSE");

    }

}

?>



A function like this could be used to create the table if it's not already created, etc.

j-pieper at NOSPAM dot web dot de 19-Oct-2004 03:18


If you want to create a table in your database which should have an integer primary key, you cannot declare the row like this:





id int(16) primary key


or


id integer(16) primary key





When you declare it like this it could be that the id isn't auto increment. You have to declare it like this:





id integer primary key

filip at filipdewaard dot com 09-Sep-2004 11:39


I've written a short article about the (lack of) use of SQLite in-memory databases: http://www.filipdewaard.com/21_SQLite_inmemory_databases.html . Hopefully it will help somebody out there ;)

philip 08-Aug-2004 02:59


SQLite tutorials:


 * http://www.zend.com/php5/articles/php5-sqlite.php


 * http://www.zend.com/php5/abs/php101-9.php


 * http://www.oreilly.com/catalog/upgradephp5/chapter/ch04.pdf

jon at jenseng dot com 20-Jul-2004 02:50


Since SQLite doesn't support ALTER TABLE statements or renaming tables, modifying an existing table is a bit cumbersome. You have to:



1. create a temporary table

2. copy the original table into the temporary table

3. delete the original

4. recreate the original with new column definitions

5. copy the contents back

6. delete the temporary table



As this is rather unwieldy, I've created a wrapper class that allows for ALTER TABLE queries and does the dirty work for you. It has integrated error handling to ensure that queries are completely valid and it allows for complex statements such as:



ALTER TABLE foo ADD bar VARCHAR(27), DROP bar2, CHANGE bar3 foobar INTEGER, ADD bar4 DATE



Documentation:

http://code.jenseng.com/db/



Source:

http://code.jenseng.com/db/sql.txt

david at acz dot org 14-Jul-2004 06:29


You can use the PECL SQLite extension as a static (built into the executable) PHP module with PHP 4.  Download the extension tarball and extract it.  Move it to ext/sqlite in the PHP source directory.  Delete configure and run buildconf.



Example below.  Change version numbers as appropriate:



$ tar -xzvf php-4.3.8.tar.gz

$ tar -xzvf SQLite-1.0.2.tgz

$ mv SQLite-1.0.2 php-4.3.8/ext/sqlite

$ cd php-4.3.8

$ rm configure

$ ./buildconf --force



If everything worked, then you should now be able to build PHP with SQLite support:



$ ./configure --help | grep sqlite

  --with-sqlite           Include sqlite support



I think this method will work for other PECL extensions.

13-May-2004 07:46


PHP5 compile time option --enable-sqlite-utf8



See the note about buggy utf-8 support http://uk.php.net/manual/en/function.sqlite-libencoding.php

csaba at alum dot mit dot edu 14-Apr-2004 08:16


If you want to get the list of all the columns in a table (and associated information), PRAGMA is helpful (see http://sqlite.org/lang.html#pragma for details):



if (!($db=@sqlite_open("delme.db",0666,$sqliteerror))) die("Can't open database");

@sqlite_query ($db, 'DROP TABLE foo;');

sqlite_query($db, "CREATE TABLE foo (bar INTEGER PRIMARY KEY, baz VARCHAR(5));");

$aTableStruct = sqlite_array_query($db, "PRAGMA table_info('foo');", SQLITE_ASSOC);

for ($i=0,$aNames=array();$i<sizeof($aTableStruct);++$i)

    $aNames[]=$aTableStruct[$i]['name'];

var_dump ($aNames);    // => ['bar', 'baz']



Note also that if you want to use more than one database in the same connection using "ATTACH DATABASE ..." then you should supply the complete database filename.



Csaba Gabor

cricket at djcricket dot com 31-Mar-2004 09:30


To elaborate on vpupkin at comcast dot net's post about the INSERT query problem, you will be unable to execute any manipulation queries (INSERT/UPDATE/DELETE/ect) on the SQLite database file unless the directory the SQLite database file resides in is writable by the webserver.



The reason for this is because SQLite needs to write a lock file to the hard drive. After a processes finishes writting, it deletes the lock file. Other processes check for the lock file before writting to the SQLite database file and if present, delay writting until the lock file is no longer present.

jlsalinas at spamsucks dot gmx dot net 13-Feb-2004 06:22


For those looking for a function similar to mysql_list_tables, here you have:



if (! function_exists ('sqlite_list_tables')) {

    function sqlite_list_tables (&$dblink) {

        $tables = array ();

        

        $sql = "SELECT name FROM sqlite_master WHERE (type = 'table')";

        if ($res = sqlite_query ($dblink, $sql)) {

            while (sqlite_has_more($res)) {

                $tables[] = sqlite_fetch_single($res);

            }

        }

        

        return $tables;

    }

}



And a related funtion, to test if a given table exists:



if (! function_exists ('sqlite_table_exists')) {

    function sqlite_table_exists (&$dblink, $table) {

        $sql = "SELECT count(name) FROM sqlite_master WHERE ((type = 'table') and (name = '$table'))";

        if ($res = sqlite_query ($dblink, $sql)) {

            return sqlite_fetch_single($res) > 0;

        } else {

            return false; // or throw exception

        }

    }

}



Of course it would be preferable to have these functions included in the library, to avoid potential changes internal to SQLite; but we'll have to stick to this method until then.

vpupkin at comcast dot net 30-Nov-2003 08:53


if you are going to send INSERT queries, you will need to make the folder, where you put your "file.db", writable by a web server user, otherwise you'll receive error message - "Unable to open database . . . ". File permissions are not enough (phpinfo - SQLite Lib 2.8.3)

Minots Estich <minots at D0X dot de> 21-Nov-2003 06:47


If you gone in trouble while/with installation of sqlite,


you can try the installation steps I've done at


RedHat9 with PHP4.3.4 and Apache 1.3.28


via the Linux shell:





# wget http://pecl.php.net/get/SQLite-1.0.tgz


# tar xzf SQLite-1.0.tgz


# cd sqlite


# export PHP_PREFIX="/usr"


# $PHP_PREFIX/bin/phpize


# ./configure


# make


# make install





After that add following to php.ini and restart Apache:





[sqlite]


extension="sqlite.so"

ng4rrjanbiah at rediffmail dot com 07-Nov-2003 07:19


Very nice MS PowerPoint presentation titled "SQLite and PHP" (author: Wez Furlong) can be downloaded at http://www.php.net/~wez/SQLite_and_PHP.ppt [134 KB]



HTH,

R. Rajesh Jeba Anbiah

add a note