397 lines
11 KiB
PHP
397 lines
11 KiB
PHP
<?php
|
|
/**
|
|
* This script is the SQLite database abstraction layer, see http://www.organicdesign.co.nz/Extension_talk:MediaWikiLite.php
|
|
* - Licenced under LGPL (http://www.gnu.org/copyleft/lesser.html){{php}}
|
|
* - Author: [http://www.organicdesign.co.nz/nad User:Nad]
|
|
* - Started: 2007-12-17
|
|
* - Last update: 2008-01-20
|
|
*
|
|
* {{php}}{{category:Extensions|DatabaseSqlite.php}}
|
|
*/
|
|
|
|
/**
|
|
* @addtogroup Database
|
|
*/
|
|
class DatabaseSqlite extends Database {
|
|
|
|
var $mAffectedRows;
|
|
var $mLastResult;
|
|
var $mDatabaseFile;
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
function __construct($server = false, $user = false, $password = false, $dbName = false, $failFunction = false, $flags = 0) {
|
|
global $wgOut,$wgSQLiteDataDir;
|
|
if ("$wgSQLiteDataDir" == '') $wgSQLiteDataDir = dirname($_SERVER['DOCUMENT_ROOT']).'/data';
|
|
if (!is_dir($wgSQLiteDataDir)) mkdir($wgSQLiteDataDir,0700);
|
|
if (!isset($wgOut)) $wgOut = NULL; # Can't get a reference if it hasn't been set yet
|
|
$this->mOut =& $wgOut;
|
|
$this->mFailFunction = $failFunction;
|
|
$this->mFlags = $flags;
|
|
$this->mDatabaseFile = "$wgSQLiteDataDir/$dbName.sqlite";
|
|
$this->open($server, $user, $password, $dbName);
|
|
}
|
|
|
|
/**
|
|
* todo: check if these should be true like parent class
|
|
*/
|
|
function implicitGroupby() { return false; }
|
|
function implicitOrderby() { return false; }
|
|
|
|
static function newFromParams($server, $user, $password, $dbName, $failFunction = false, $flags = 0) {
|
|
return new DatabaseSqlite($server, $user, $password, $dbName, $failFunction, $flags);
|
|
}
|
|
|
|
/** Open an SQLite database and return a resource handle to it
|
|
* NOTE: only $dbName is used, the other parameters are irrelevant for SQLite databases
|
|
*/
|
|
function open($server,$user,$pass,$dbName) {
|
|
$this->mConn = false;
|
|
if ($dbName) {
|
|
$file = $this->mDatabaseFile;
|
|
if ($this->mFlags & DBO_PERSISTENT) $this->mConn = new PDO("sqlite:$file",$user,$pass,array(PDO::ATTR_PERSISTENT => true));
|
|
else $this->mConn = new PDO("sqlite:$file",$user,$pass);
|
|
if ($this->mConn === false) wfDebug("DB connection error: $err\n");;
|
|
$this->mOpened = $this->mConn;
|
|
$this->mConn->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_SILENT); # set error codes only, dont raise exceptions
|
|
}
|
|
return $this->mConn;
|
|
}
|
|
|
|
/**
|
|
* Close an SQLite database
|
|
*/
|
|
function close() {
|
|
$this->mOpened = false;
|
|
if (is_object($this->mConn)) {
|
|
if ($this->trxLevel()) $this->immediateCommit();
|
|
$this->mConn = null;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* SQLite doesn't allow buffered results or data seeking etc, so we'll use fetchAll as the result
|
|
*/
|
|
function doQuery($sql) {
|
|
$res = $this->mConn->query($sql);
|
|
if ($res === false) $this->reportQueryError($this->lastError(),$this->lastErrno(),$sql,__FUNCTION__);
|
|
else {
|
|
$r = $res instanceof ResultWrapper ? $res->result : $res;
|
|
$this->mAffectedRows = $r->rowCount();
|
|
$res = new ResultWrapper($this,$r->fetchAll());
|
|
}
|
|
return $res;
|
|
}
|
|
|
|
function freeResult(&$res) {
|
|
if ($res instanceof ResultWrapper) $res->result = NULL; else $res = NULL;
|
|
}
|
|
|
|
function fetchObject(&$res) {
|
|
if ($res instanceof ResultWrapper) $r =& $res->result; else $r =& $res;
|
|
$cur = current($r);
|
|
if (is_array($cur)) {
|
|
next($r);
|
|
$obj = new stdClass;
|
|
foreach ($cur as $k => $v) if (!is_numeric($k)) $obj->$k = $v;
|
|
return $obj;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function fetchRow(&$res) {
|
|
if ($res instanceof ResultWrapper) $r =& $res->result; else $r =& $res;
|
|
$cur = current($r);
|
|
if (is_array($cur)) {
|
|
next($r);
|
|
return $cur;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* The PDO::Statement class implements the array interface so count() will work
|
|
*/
|
|
function numRows(&$res) {
|
|
$r = $res instanceof ResultWrapper ? $res->result : $res;
|
|
return count($r);
|
|
}
|
|
|
|
function numFields(&$res) {
|
|
$r = $res instanceof ResultWrapper ? $res->result : $res;
|
|
return is_array($r) ? count($r[0]) : 0;
|
|
}
|
|
|
|
function fieldName(&$res,$n) {
|
|
$r = $res instanceof ResultWrapper ? $res->result : $res;
|
|
if (is_array($r)) {
|
|
$keys = array_keys($r[0]);
|
|
return $keys[$n];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Use MySQL's naming (accounts for prefix etc) but remove surrounding backticks
|
|
*/
|
|
function tableName($name) {
|
|
return str_replace('`','',parent::tableName($name));
|
|
}
|
|
|
|
/**
|
|
* This must be called after nextSequenceVal
|
|
*/
|
|
function insertId() {
|
|
return $this->mConn->lastInsertId();
|
|
}
|
|
|
|
function dataSeek(&$res,$row) {
|
|
if ($res instanceof ResultWrapper) $r =& $res->result; else $r =& $res;
|
|
reset($r);
|
|
if ($row > 0) for ($i = 0; $i < $row; $i++) next($r);
|
|
}
|
|
|
|
function lastError() {
|
|
if (!is_object($this->mConn)) return "Cannot return last error, no db connection";
|
|
$e = $this->mConn->errorInfo();
|
|
return isset($e[2]) ? $e[2] : '';
|
|
}
|
|
|
|
function lastErrno() {
|
|
if (!is_object($this->mConn)) return "Cannot return last error, no db connection";
|
|
return $this->mConn->errorCode();
|
|
}
|
|
|
|
function affectedRows() {
|
|
return $this->mAffectedRows;
|
|
}
|
|
|
|
/**
|
|
* Returns information about an index
|
|
* - if errors are explicitly ignored, returns NULL on failure
|
|
*/
|
|
function indexInfo($table, $index, $fname = 'Database::indexExists') {
|
|
return false;
|
|
}
|
|
|
|
function indexUnique($table, $index, $fname = 'Database::indexUnique') {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Filter the options used in SELECT statements
|
|
*/
|
|
function makeSelectOptions($options) {
|
|
foreach ($options as $k => $v) if (is_numeric($k) && $v == 'FOR UPDATE') $options[$k] = '';
|
|
return parent::makeSelectOptions($options);
|
|
}
|
|
|
|
/**
|
|
* Based on MySQL method (parent) with some prior SQLite-sepcific adjustments
|
|
*/
|
|
function insert($table, $a, $fname = 'DatabaseSqlite::insert', $options = array()) {
|
|
if (!count($a)) return true;
|
|
if (!is_array($options)) $options = array($options);
|
|
|
|
# SQLite uses OR IGNORE not just IGNORE
|
|
foreach ($options as $k => $v) if ($v == 'IGNORE') $options[$k] = 'OR IGNORE';
|
|
|
|
# SQLite can't handle multi-row inserts, so divide up into multiple single-row inserts
|
|
if (isset($a[0]) && is_array($a[0])) {
|
|
$ret = true;
|
|
foreach ($a as $k => $v) if (!parent::insert($table,$v,"$fname/multi-row",$options)) $ret = false;
|
|
}
|
|
else $ret = parent::insert($table,$a,"$fname/single-row",$options);
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* SQLite does not have a "USE INDEX" clause, so return an empty string
|
|
*/
|
|
function useIndexClause($index) {
|
|
return '';
|
|
}
|
|
|
|
# Returns the size of a text field, or -1 for "unlimited"
|
|
function textFieldSize($table, $field) {
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* No low priority option in SQLite
|
|
*/
|
|
function lowPriorityOption() {
|
|
return '';
|
|
}
|
|
|
|
/**
|
|
* Returns an SQL expression for a simple conditional.
|
|
* - uses CASE on SQLite
|
|
*/
|
|
function conditional($cond, $trueVal, $falseVal) {
|
|
return " (CASE WHEN $cond THEN $trueVal ELSE $falseVal END) ";
|
|
}
|
|
|
|
function wasDeadlock() {
|
|
return $this->lastErrno() == SQLITE_BUSY;
|
|
}
|
|
|
|
/**
|
|
* @return string wikitext of a link to the server software's web site
|
|
*/
|
|
function getSoftwareLink() {
|
|
return "[http://sqlite.org/ SQLite]";
|
|
}
|
|
|
|
/**
|
|
* @return string Version information from the database
|
|
*/
|
|
function getServerVersion() {
|
|
global $wgContLang;
|
|
$ver = $this->mConn->getAttribute(PDO::ATTR_SERVER_VERSION);
|
|
$size = $wgContLang->formatSize(filesize($this->mDatabaseFile));
|
|
$file = basename($this->mDatabaseFile);
|
|
return $ver." ($file: $size)";
|
|
}
|
|
|
|
/**
|
|
* Query whether a given column exists in the mediawiki schema
|
|
*/
|
|
function fieldExists($table, $field) { return true; }
|
|
|
|
function fieldInfo($table, $field) { return SQLiteField::fromText($this, $table, $field); }
|
|
|
|
function begin() {
|
|
if ($this->mTrxLevel == 1) $this->commit();
|
|
$this->mConn->beginTransaction();
|
|
$this->mTrxLevel = 1;
|
|
}
|
|
|
|
function commit() {
|
|
if ($this->mTrxLevel == 0) return;
|
|
$this->mConn->commit();
|
|
$this->mTrxLevel = 0;
|
|
}
|
|
|
|
function rollback() {
|
|
if ($this->mTrxLevel == 0) return;
|
|
$this->mConn->rollBack();
|
|
$this->mTrxLevel = 0;
|
|
}
|
|
|
|
function limitResultForUpdate($sql, $num) {
|
|
return $sql;
|
|
}
|
|
|
|
function strencode($s) {
|
|
return substr($this->addQuotes($s),1,-1);
|
|
}
|
|
|
|
function encodeBlob($b) {
|
|
return $this->strencode($b);
|
|
}
|
|
|
|
function decodeBlob($b) {
|
|
return $b;
|
|
}
|
|
|
|
function addQuotes($s) {
|
|
return $this->mConn->quote($s);
|
|
}
|
|
|
|
function quote_ident($s) { return $s; }
|
|
|
|
/**
|
|
* For now, does nothing
|
|
*/
|
|
function selectDB($db) { return true; }
|
|
|
|
/**
|
|
* not done
|
|
*/
|
|
public function setTimeout($timeout) { return; }
|
|
|
|
function ping() {
|
|
wfDebug("Function ping() not written for SQLite yet");
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* How lagged is this slave?
|
|
*/
|
|
public function getLag() {
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Called by the installer script (when modified according to the MediaWikiLite installation instructions)
|
|
* - this is the same way PostgreSQL works, MySQL reads in tables.sql and interwiki.sql using dbsource (which calls db->sourceFile)
|
|
*/
|
|
public function setup_database() {
|
|
global $IP,$wgSQLiteDataDir,$wgDBTableOptions;
|
|
$wgDBTableOptions = '';
|
|
$mysql_tmpl = "$IP/maintenance/tables.sql";
|
|
$mysql_iw = "$IP/maintenance/interwiki.sql";
|
|
$sqlite_tmpl = "$IP/maintenance/sqlite/tables.sql";
|
|
|
|
# Make an SQLite template file if it doesn't exist (based on the same one MySQL uses to create a new wiki db)
|
|
if (!file_exists($sqlite_tmpl)) {
|
|
$sql = file_get_contents($mysql_tmpl);
|
|
$sql = preg_replace('/^\s*--.*?$/m','',$sql); # strip comments
|
|
$sql = preg_replace('/^\s*(UNIQUE)?\s*(PRIMARY)?\s*KEY.+?$/m','',$sql);
|
|
$sql = preg_replace('/^\s*(UNIQUE )?INDEX.+?$/m','',$sql); # These indexes should be created with a CREATE INDEX query
|
|
$sql = preg_replace('/^\s*FULLTEXT.+?$/m','',$sql); # Full text indexes
|
|
$sql = preg_replace('/ENUM\(.+?\)/','TEXT',$sql); # Make ENUM's into TEXT's
|
|
$sql = preg_replace('/binary\(\d+\)/','BLOB',$sql);
|
|
$sql = preg_replace('/(TYPE|MAX_ROWS|AVG_ROW_LENGTH)=\w+/','',$sql);
|
|
$sql = preg_replace('/,\s*\)/s',')',$sql); # removing previous items may leave a trailing comma
|
|
$sql = str_replace('binary','',$sql);
|
|
$sql = str_replace('auto_increment','PRIMARY KEY AUTOINCREMENT',$sql);
|
|
$sql = str_replace(' unsigned','',$sql);
|
|
$sql = str_replace(' int ',' INTEGER ',$sql);
|
|
$sql = str_replace('NOT NULL','',$sql);
|
|
|
|
# Tidy up and write file
|
|
$sql = preg_replace('/^\s*^/m','',$sql); # Remove empty lines
|
|
$sql = preg_replace('/;$/m',";\n",$sql); # Separate each statement with an empty line
|
|
file_put_contents($sqlite_tmpl,$sql);
|
|
}
|
|
|
|
# Parse the SQLite template replacing inline variables such as /*$wgDBprefix*/
|
|
$err = $this->sourceFile($sqlite_tmpl);
|
|
if ($err !== true) $this->reportQueryError($err,0,$sql,__FUNCTION__);
|
|
|
|
# Use DatabasePostgres's code to populate interwiki from MySQL template
|
|
$f = fopen($mysql_iw,'r');
|
|
if ($f == false) dieout("<li>Could not find the interwiki.sql file");
|
|
$sql = "INSERT INTO interwiki(iw_prefix,iw_url,iw_local) VALUES ";
|
|
while (!feof($f)) {
|
|
$line = fgets($f,1024);
|
|
$matches = array();
|
|
if (!preg_match('/^\s*(\(.+?),(\d)\)/', $line, $matches)) continue;
|
|
$this->query("$sql $matches[1],$matches[2])");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* @addtogroup Database
|
|
*/
|
|
class SQLiteField extends MySQLField {
|
|
|
|
function __construct() {
|
|
}
|
|
|
|
static function fromText($db, $table, $field) {
|
|
$n = new SQLiteField;
|
|
$n->name = $field;
|
|
$n->tablename = $table;
|
|
return $n;
|
|
}
|
|
|
|
} // end DatabaseSqlite class
|
|
|