MediaWiki  REL1_31
DatabaseSqlite.php
Go to the documentation of this file.
1 <?php
24 namespace Wikimedia\Rdbms;
25 
26 use PDO;
27 use PDOException;
30 use InvalidArgumentException;
31 use RuntimeException;
32 use stdClass;
33 
37 class DatabaseSqlite extends Database {
39  private static $fulltextEnabled = null;
40 
42  protected $dbDir;
44  protected $dbPath;
46  protected $trxMode;
47 
51  protected $lastResultHandle;
52 
54  protected $conn;
55 
57  protected $lockMgr;
58 
60  private $alreadyAttached = [];
61 
70  function __construct( array $p ) {
71  if ( isset( $p['dbFilePath'] ) ) {
72  $this->dbPath = $p['dbFilePath'];
73  $lockDomain = md5( $this->dbPath );
74  } elseif ( isset( $p['dbDirectory'] ) ) {
75  $this->dbDir = $p['dbDirectory'];
76  $lockDomain = $p['dbname'];
77  } else {
78  throw new InvalidArgumentException( "Need 'dbDirectory' or 'dbFilePath' parameter." );
79  }
80 
81  $this->trxMode = isset( $p['trxMode'] ) ? strtoupper( $p['trxMode'] ) : null;
82  if ( $this->trxMode &&
83  !in_array( $this->trxMode, [ 'DEFERRED', 'IMMEDIATE', 'EXCLUSIVE' ] )
84  ) {
85  $this->trxMode = null;
86  $this->queryLogger->warning( "Invalid SQLite transaction mode provided." );
87  }
88 
89  $this->lockMgr = new FSLockManager( [
90  'domain' => $lockDomain,
91  'lockDirectory' => "{$this->dbDir}/locks"
92  ] );
93 
94  parent::__construct( $p );
95  }
96 
97  protected static function getAttributes() {
98  return [ self::ATTR_DB_LEVEL_LOCKING => true ];
99  }
100 
110  public static function newStandaloneInstance( $filename, array $p = [] ) {
111  $p['dbFilePath'] = $filename;
112  $p['schema'] = false;
113  $p['tablePrefix'] = '';
115  $db = Database::factory( 'sqlite', $p );
116 
117  return $db;
118  }
119 
120  protected function doInitConnection() {
121  if ( $this->dbPath !== null ) {
122  // Standalone .sqlite file mode.
123  $this->openFile( $this->dbPath, $this->connectionParams['dbname'] );
124  } elseif ( $this->dbDir !== null ) {
125  // Stock wiki mode using standard file names per DB
126  if ( strlen( $this->connectionParams['dbname'] ) ) {
127  $this->open(
128  $this->connectionParams['host'],
129  $this->connectionParams['user'],
130  $this->connectionParams['password'],
131  $this->connectionParams['dbname']
132  );
133  } else {
134  // Caller will manually call open() later?
135  $this->connLogger->debug( __METHOD__ . ': no database opened.' );
136  }
137  } else {
138  throw new InvalidArgumentException( "Need 'dbDirectory' or 'dbFilePath' parameter." );
139  }
140  }
141 
145  function getType() {
146  return 'sqlite';
147  }
148 
154  function implicitGroupby() {
155  return false;
156  }
157 
169  function open( $server, $user, $pass, $dbName ) {
170  $this->close();
171  $fileName = self::generateFileName( $this->dbDir, $dbName );
172  if ( !is_readable( $fileName ) ) {
173  $this->conn = false;
174  throw new DBConnectionError( $this, "SQLite database not accessible" );
175  }
176  $this->openFile( $fileName, $dbName );
177 
178  return (bool)$this->conn;
179  }
180 
189  protected function openFile( $fileName, $dbName ) {
190  $err = false;
191 
192  $this->dbPath = $fileName;
193  try {
194  if ( $this->flags & self::DBO_PERSISTENT ) {
195  $this->conn = new PDO( "sqlite:$fileName", '', '',
196  [ PDO::ATTR_PERSISTENT => true ] );
197  } else {
198  $this->conn = new PDO( "sqlite:$fileName", '', '' );
199  }
200  } catch ( PDOException $e ) {
201  $err = $e->getMessage();
202  }
203 
204  if ( !$this->conn ) {
205  $this->queryLogger->debug( "DB connection error: $err\n" );
206  throw new DBConnectionError( $this, $err );
207  }
208 
209  $this->opened = is_object( $this->conn );
210  if ( $this->opened ) {
211  $this->dbName = $dbName;
212  # Set error codes only, don't raise exceptions
213  $this->conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT );
214  # Enforce LIKE to be case sensitive, just like MySQL
215  $this->query( 'PRAGMA case_sensitive_like = 1' );
216 
217  return $this->conn;
218  }
219 
220  return false;
221  }
222 
227  public function getDbFilePath() {
228  return $this->dbPath;
229  }
230 
235  protected function closeConnection() {
236  $this->conn = null;
237 
238  return true;
239  }
240 
247  public static function generateFileName( $dir, $dbName ) {
248  return "$dir/$dbName.sqlite";
249  }
250 
256  if ( self::$fulltextEnabled === null ) {
257  self::$fulltextEnabled = false;
258  $table = $this->tableName( 'searchindex' );
259  $res = $this->query( "SELECT sql FROM sqlite_master WHERE tbl_name = '$table'", __METHOD__ );
260  if ( $res ) {
261  $row = $res->fetchRow();
262  self::$fulltextEnabled = stristr( $row['sql'], 'fts' ) !== false;
263  }
264  }
265 
266  return self::$fulltextEnabled;
267  }
268 
273  static function getFulltextSearchModule() {
274  static $cachedResult = null;
275  if ( $cachedResult !== null ) {
276  return $cachedResult;
277  }
278  $cachedResult = false;
279  $table = 'dummy_search_test';
280 
281  $db = self::newStandaloneInstance( ':memory:' );
282  if ( $db->query( "CREATE VIRTUAL TABLE $table USING FTS3(dummy_field)", __METHOD__, true ) ) {
283  $cachedResult = 'FTS3';
284  }
285  $db->close();
286 
287  return $cachedResult;
288  }
289 
301  function attachDatabase( $name, $file = false, $fname = __METHOD__ ) {
302  if ( !$file ) {
303  $file = self::generateFileName( $this->dbDir, $name );
304  }
305  $file = $this->addQuotes( $file );
306 
307  return $this->query( "ATTACH DATABASE $file AS $name", $fname );
308  }
309 
310  function isWriteQuery( $sql ) {
311  return parent::isWriteQuery( $sql ) && !preg_match( '/^(ATTACH|PRAGMA)\b/i', $sql );
312  }
313 
314  protected function isTransactableQuery( $sql ) {
315  return parent::isTransactableQuery( $sql ) && !in_array(
316  $this->getQueryVerb( $sql ),
317  [ 'ATTACH', 'PRAGMA' ],
318  true
319  );
320  }
321 
328  protected function doQuery( $sql ) {
329  $res = $this->getBindingHandle()->query( $sql );
330  if ( $res === false ) {
331  return false;
332  }
333 
334  $r = $res instanceof ResultWrapper ? $res->result : $res;
335  $this->lastAffectedRowCount = $r->rowCount();
336  $res = new ResultWrapper( $this, $r->fetchAll() );
337 
338  return $res;
339  }
340 
344  function freeResult( $res ) {
345  if ( $res instanceof ResultWrapper ) {
346  $res->result = null;
347  } else {
348  $res = null;
349  }
350  }
351 
356  function fetchObject( $res ) {
357  if ( $res instanceof ResultWrapper ) {
358  $r =& $res->result;
359  } else {
360  $r =& $res;
361  }
362 
363  $cur = current( $r );
364  if ( is_array( $cur ) ) {
365  next( $r );
366  $obj = new stdClass;
367  foreach ( $cur as $k => $v ) {
368  if ( !is_numeric( $k ) ) {
369  $obj->$k = $v;
370  }
371  }
372 
373  return $obj;
374  }
375 
376  return false;
377  }
378 
383  function fetchRow( $res ) {
384  if ( $res instanceof ResultWrapper ) {
385  $r =& $res->result;
386  } else {
387  $r =& $res;
388  }
389  $cur = current( $r );
390  if ( is_array( $cur ) ) {
391  next( $r );
392 
393  return $cur;
394  }
395 
396  return false;
397  }
398 
405  function numRows( $res ) {
406  $r = $res instanceof ResultWrapper ? $res->result : $res;
407 
408  return count( $r );
409  }
410 
415  function numFields( $res ) {
416  $r = $res instanceof ResultWrapper ? $res->result : $res;
417  if ( is_array( $r ) && count( $r ) > 0 ) {
418  // The size of the result array is twice the number of fields. (Bug: 65578)
419  return count( $r[0] ) / 2;
420  } else {
421  // If the result is empty return 0
422  return 0;
423  }
424  }
425 
431  function fieldName( $res, $n ) {
432  $r = $res instanceof ResultWrapper ? $res->result : $res;
433  if ( is_array( $r ) ) {
434  $keys = array_keys( $r[0] );
435 
436  return $keys[$n];
437  }
438 
439  return false;
440  }
441 
449  function tableName( $name, $format = 'quoted' ) {
450  // table names starting with sqlite_ are reserved
451  if ( strpos( $name, 'sqlite_' ) === 0 ) {
452  return $name;
453  }
454 
455  return str_replace( '"', '', parent::tableName( $name, $format ) );
456  }
457 
463  function insertId() {
464  // PDO::lastInsertId yields a string :(
465  return intval( $this->getBindingHandle()->lastInsertId() );
466  }
467 
472  function dataSeek( $res, $row ) {
473  if ( $res instanceof ResultWrapper ) {
474  $r =& $res->result;
475  } else {
476  $r =& $res;
477  }
478  reset( $r );
479  if ( $row > 0 ) {
480  for ( $i = 0; $i < $row; $i++ ) {
481  next( $r );
482  }
483  }
484  }
485 
489  function lastError() {
490  if ( !is_object( $this->conn ) ) {
491  return "Cannot return last error, no db connection";
492  }
493  $e = $this->conn->errorInfo();
494 
495  return isset( $e[2] ) ? $e[2] : '';
496  }
497 
501  function lastErrno() {
502  if ( !is_object( $this->conn ) ) {
503  return "Cannot return last error, no db connection";
504  } else {
505  $info = $this->conn->errorInfo();
506 
507  return $info[1];
508  }
509  }
510 
514  protected function fetchAffectedRowCount() {
516  }
517 
528  function indexInfo( $table, $index, $fname = __METHOD__ ) {
529  $sql = 'PRAGMA index_info(' . $this->addQuotes( $this->indexName( $index ) ) . ')';
530  $res = $this->query( $sql, $fname );
531  if ( !$res || $res->numRows() == 0 ) {
532  return false;
533  }
534  $info = [];
535  foreach ( $res as $row ) {
536  $info[] = $row->name;
537  }
538 
539  return $info;
540  }
541 
548  function indexUnique( $table, $index, $fname = __METHOD__ ) {
549  $row = $this->selectRow( 'sqlite_master', '*',
550  [
551  'type' => 'index',
552  'name' => $this->indexName( $index ),
553  ], $fname );
554  if ( !$row || !isset( $row->sql ) ) {
555  return null;
556  }
557 
558  // $row->sql will be of the form CREATE [UNIQUE] INDEX ...
559  $indexPos = strpos( $row->sql, 'INDEX' );
560  if ( $indexPos === false ) {
561  return null;
562  }
563  $firstPart = substr( $row->sql, 0, $indexPos );
564  $options = explode( ' ', $firstPart );
565 
566  return in_array( 'UNIQUE', $options );
567  }
568 
576  foreach ( $options as $k => $v ) {
577  if ( is_numeric( $k ) && ( $v == 'FOR UPDATE' || $v == 'LOCK IN SHARE MODE' ) ) {
578  $options[$k] = '';
579  }
580  }
581 
582  return parent::makeSelectOptions( $options );
583  }
584 
589  protected function makeUpdateOptionsArray( $options ) {
590  $options = parent::makeUpdateOptionsArray( $options );
592 
593  return $options;
594  }
595 
600  static function fixIgnore( $options ) {
601  # SQLite uses OR IGNORE not just IGNORE
602  foreach ( $options as $k => $v ) {
603  if ( $v == 'IGNORE' ) {
604  $options[$k] = 'OR IGNORE';
605  }
606  }
607 
608  return $options;
609  }
610 
617 
618  return parent::makeInsertOptions( $options );
619  }
620 
629  function insert( $table, $a, $fname = __METHOD__, $options = [] ) {
630  if ( !count( $a ) ) {
631  return true;
632  }
633 
634  # SQLite can't handle multi-row inserts, so divide up into multiple single-row inserts
635  if ( isset( $a[0] ) && is_array( $a[0] ) ) {
636  $ret = true;
637  foreach ( $a as $v ) {
638  if ( !parent::insert( $table, $v, "$fname/multi-row", $options ) ) {
639  $ret = false;
640  }
641  }
642  } else {
643  $ret = parent::insert( $table, $a, "$fname/single-row", $options );
644  }
645 
646  return $ret;
647  }
648 
656  function replace( $table, $uniqueIndexes, $rows, $fname = __METHOD__ ) {
657  if ( !count( $rows ) ) {
658  return true;
659  }
660 
661  # SQLite can't handle multi-row replaces, so divide up into multiple single-row queries
662  if ( isset( $rows[0] ) && is_array( $rows[0] ) ) {
663  $ret = true;
664  foreach ( $rows as $v ) {
665  if ( !$this->nativeReplace( $table, $v, "$fname/multi-row" ) ) {
666  $ret = false;
667  }
668  }
669  } else {
670  $ret = $this->nativeReplace( $table, $rows, "$fname/single-row" );
671  }
672 
673  return $ret;
674  }
675 
684  function textFieldSize( $table, $field ) {
685  return -1;
686  }
687 
692  return false;
693  }
694 
700  function unionQueries( $sqls, $all ) {
701  $glue = $all ? ' UNION ALL ' : ' UNION ';
702 
703  return implode( $glue, $sqls );
704  }
705 
709  function wasDeadlock() {
710  return $this->lastErrno() == 5; // SQLITE_BUSY
711  }
712 
716  function wasReadOnlyError() {
717  return $this->lastErrno() == 8; // SQLITE_READONLY;
718  }
719 
720  public function wasConnectionError( $errno ) {
721  return $errno == 17; // SQLITE_SCHEMA;
722  }
723 
724  protected function wasKnownStatementRollbackError() {
725  // ON CONFLICT ROLLBACK clauses make it so that SQLITE_CONSTRAINT error is
726  // ambiguous with regard to whether it implies a ROLLBACK or an ABORT happened.
727  // https://sqlite.org/lang_createtable.html#uniqueconst
728  // https://sqlite.org/lang_conflict.html
729  return false;
730  }
731 
735  public function getSoftwareLink() {
736  return "[{{int:version-db-sqlite-url}} SQLite]";
737  }
738 
742  function getServerVersion() {
743  $ver = $this->getBindingHandle()->getAttribute( PDO::ATTR_SERVER_VERSION );
744 
745  return $ver;
746  }
747 
756  function fieldInfo( $table, $field ) {
757  $tableName = $this->tableName( $table );
758  $sql = 'PRAGMA table_info(' . $this->addQuotes( $tableName ) . ')';
759  $res = $this->query( $sql, __METHOD__ );
760  foreach ( $res as $row ) {
761  if ( $row->name == $field ) {
762  return new SQLiteField( $row, $tableName );
763  }
764  }
765 
766  return false;
767  }
768 
769  protected function doBegin( $fname = '' ) {
770  if ( $this->trxMode ) {
771  $this->query( "BEGIN {$this->trxMode}", $fname );
772  } else {
773  $this->query( 'BEGIN', $fname );
774  }
775  $this->trxLevel = 1;
776  }
777 
782  function strencode( $s ) {
783  return substr( $this->addQuotes( $s ), 1, -1 );
784  }
785 
790  function encodeBlob( $b ) {
791  return new Blob( $b );
792  }
793 
798  function decodeBlob( $b ) {
799  if ( $b instanceof Blob ) {
800  $b = $b->fetch();
801  }
802 
803  return $b;
804  }
805 
810  function addQuotes( $s ) {
811  if ( $s instanceof Blob ) {
812  return "x'" . bin2hex( $s->fetch() ) . "'";
813  } elseif ( is_bool( $s ) ) {
814  return (int)$s;
815  } elseif ( strpos( (string)$s, "\0" ) !== false ) {
816  // SQLite doesn't support \0 in strings, so use the hex representation as a workaround.
817  // This is a known limitation of SQLite's mprintf function which PDO
818  // should work around, but doesn't. I have reported this to php.net as bug #63419:
819  // https://bugs.php.net/bug.php?id=63419
820  // There was already a similar report for SQLite3::escapeString, bug #62361:
821  // https://bugs.php.net/bug.php?id=62361
822  // There is an additional bug regarding sorting this data after insert
823  // on older versions of sqlite shipped with ubuntu 12.04
824  // https://phabricator.wikimedia.org/T74367
825  $this->queryLogger->debug(
826  __FUNCTION__ .
827  ': Quoting value containing null byte. ' .
828  'For consistency all binary data should have been ' .
829  'first processed with self::encodeBlob()'
830  );
831  return "x'" . bin2hex( (string)$s ) . "'";
832  } else {
833  return $this->getBindingHandle()->quote( (string)$s );
834  }
835  }
836 
837  public function buildSubstring( $input, $startPosition, $length = null ) {
838  $this->assertBuildSubstringParams( $startPosition, $length );
839  $params = [ $input, $startPosition ];
840  if ( $length !== null ) {
841  $params[] = $length;
842  }
843  return 'SUBSTR(' . implode( ',', $params ) . ')';
844  }
845 
851  public function buildStringCast( $field ) {
852  return 'CAST ( ' . $field . ' AS TEXT )';
853  }
854 
860  public function deadlockLoop( /*...*/ ) {
861  $args = func_get_args();
862  $function = array_shift( $args );
863 
864  return call_user_func_array( $function, $args );
865  }
866 
871  protected function replaceVars( $s ) {
872  $s = parent::replaceVars( $s );
873  if ( preg_match( '/^\s*(CREATE|ALTER) TABLE/i', $s ) ) {
874  // CREATE TABLE hacks to allow schema file sharing with MySQL
875 
876  // binary/varbinary column type -> blob
877  $s = preg_replace( '/\b(var)?binary(\‍(\d+\‍))/i', 'BLOB', $s );
878  // no such thing as unsigned
879  $s = preg_replace( '/\b(un)?signed\b/i', '', $s );
880  // INT -> INTEGER
881  $s = preg_replace( '/\b(tiny|small|medium|big|)int(\s*\‍(\s*\d+\s*\‍)|\b)/i', 'INTEGER', $s );
882  // floating point types -> REAL
883  $s = preg_replace(
884  '/\b(float|double(\s+precision)?)(\s*\‍(\s*\d+\s*(,\s*\d+\s*)?\‍)|\b)/i',
885  'REAL',
886  $s
887  );
888  // varchar -> TEXT
889  $s = preg_replace( '/\b(var)?char\s*\‍(.*?\‍)/i', 'TEXT', $s );
890  // TEXT normalization
891  $s = preg_replace( '/\b(tiny|medium|long)text\b/i', 'TEXT', $s );
892  // BLOB normalization
893  $s = preg_replace( '/\b(tiny|small|medium|long|)blob\b/i', 'BLOB', $s );
894  // BOOL -> INTEGER
895  $s = preg_replace( '/\bbool(ean)?\b/i', 'INTEGER', $s );
896  // DATETIME -> TEXT
897  $s = preg_replace( '/\b(datetime|timestamp)\b/i', 'TEXT', $s );
898  // No ENUM type
899  $s = preg_replace( '/\benum\s*\‍([^)]*\‍)/i', 'TEXT', $s );
900  // binary collation type -> nothing
901  $s = preg_replace( '/\bbinary\b/i', '', $s );
902  // auto_increment -> autoincrement
903  $s = preg_replace( '/\bauto_increment\b/i', 'AUTOINCREMENT', $s );
904  // No explicit options
905  $s = preg_replace( '/\‍)[^);]*(;?)\s*$/', ')\1', $s );
906  // AUTOINCREMENT should immedidately follow PRIMARY KEY
907  $s = preg_replace( '/primary key (.*?) autoincrement/i', 'PRIMARY KEY AUTOINCREMENT $1', $s );
908  } elseif ( preg_match( '/^\s*CREATE (\s*(?:UNIQUE|FULLTEXT)\s+)?INDEX/i', $s ) ) {
909  // No truncated indexes
910  $s = preg_replace( '/\‍(\d+\‍)/', '', $s );
911  // No FULLTEXT
912  $s = preg_replace( '/\bfulltext\b/i', '', $s );
913  } elseif ( preg_match( '/^\s*DROP INDEX/i', $s ) ) {
914  // DROP INDEX is database-wide, not table-specific, so no ON <table> clause.
915  $s = preg_replace( '/\sON\s+[^\s]*/i', '', $s );
916  } elseif ( preg_match( '/^\s*INSERT IGNORE\b/i', $s ) ) {
917  // INSERT IGNORE --> INSERT OR IGNORE
918  $s = preg_replace( '/^\s*INSERT IGNORE\b/i', 'INSERT OR IGNORE', $s );
919  }
920 
921  return $s;
922  }
923 
924  public function lock( $lockName, $method, $timeout = 5 ) {
925  if ( !is_dir( "{$this->dbDir}/locks" ) ) { // create dir as needed
926  if ( !is_writable( $this->dbDir ) || !mkdir( "{$this->dbDir}/locks" ) ) {
927  throw new DBError( $this, "Cannot create directory \"{$this->dbDir}/locks\"." );
928  }
929  }
930 
931  return $this->lockMgr->lock( [ $lockName ], LockManager::LOCK_EX, $timeout )->isOK();
932  }
933 
934  public function unlock( $lockName, $method ) {
935  return $this->lockMgr->unlock( [ $lockName ], LockManager::LOCK_EX )->isOK();
936  }
937 
944  function buildConcat( $stringList ) {
945  return '(' . implode( ') || (', $stringList ) . ')';
946  }
947 
948  public function buildGroupConcatField(
949  $delim, $table, $field, $conds = '', $join_conds = []
950  ) {
951  $fld = "group_concat($field," . $this->addQuotes( $delim ) . ')';
952 
953  return '(' . $this->selectSQLText( $table, $fld, $conds, null, [], $join_conds ) . ')';
954  }
955 
964  function duplicateTableStructure( $oldName, $newName, $temporary = false, $fname = __METHOD__ ) {
965  $res = $this->query( "SELECT sql FROM sqlite_master WHERE tbl_name=" .
966  $this->addQuotes( $oldName ) . " AND type='table'", $fname );
967  $obj = $this->fetchObject( $res );
968  if ( !$obj ) {
969  throw new RuntimeException( "Couldn't retrieve structure for table $oldName" );
970  }
971  $sql = $obj->sql;
972  $sql = preg_replace(
973  '/(?<=\W)"?' . preg_quote( trim( $this->addIdentifierQuotes( $oldName ), '"' ) ) . '"?(?=\W)/',
974  $this->addIdentifierQuotes( $newName ),
975  $sql,
976  1
977  );
978  if ( $temporary ) {
979  if ( preg_match( '/^\\s*CREATE\\s+VIRTUAL\\s+TABLE\b/i', $sql ) ) {
980  $this->queryLogger->debug(
981  "Table $oldName is virtual, can't create a temporary duplicate.\n" );
982  } else {
983  $sql = str_replace( 'CREATE TABLE', 'CREATE TEMPORARY TABLE', $sql );
984  }
985  }
986 
987  $res = $this->query( $sql, $fname );
988 
989  // Take over indexes
990  $indexList = $this->query( 'PRAGMA INDEX_LIST(' . $this->addQuotes( $oldName ) . ')' );
991  foreach ( $indexList as $index ) {
992  if ( strpos( $index->name, 'sqlite_autoindex' ) === 0 ) {
993  continue;
994  }
995 
996  if ( $index->unique ) {
997  $sql = 'CREATE UNIQUE INDEX';
998  } else {
999  $sql = 'CREATE INDEX';
1000  }
1001  // Try to come up with a new index name, given indexes have database scope in SQLite
1002  $indexName = $newName . '_' . $index->name;
1003  $sql .= ' ' . $indexName . ' ON ' . $newName;
1004 
1005  $indexInfo = $this->query( 'PRAGMA INDEX_INFO(' . $this->addQuotes( $index->name ) . ')' );
1006  $fields = [];
1007  foreach ( $indexInfo as $indexInfoRow ) {
1008  $fields[$indexInfoRow->seqno] = $indexInfoRow->name;
1009  }
1010 
1011  $sql .= '(' . implode( ',', $fields ) . ')';
1012 
1013  $this->query( $sql );
1014  }
1015 
1016  return $res;
1017  }
1018 
1027  function listTables( $prefix = null, $fname = __METHOD__ ) {
1028  $result = $this->select(
1029  'sqlite_master',
1030  'name',
1031  "type='table'"
1032  );
1033 
1034  $endArray = [];
1035 
1036  foreach ( $result as $table ) {
1037  $vars = get_object_vars( $table );
1038  $table = array_pop( $vars );
1039 
1040  if ( !$prefix || strpos( $table, $prefix ) === 0 ) {
1041  if ( strpos( $table, 'sqlite_' ) !== 0 ) {
1042  $endArray[] = $table;
1043  }
1044  }
1045  }
1046 
1047  return $endArray;
1048  }
1049 
1058  public function dropTable( $tableName, $fName = __METHOD__ ) {
1059  if ( !$this->tableExists( $tableName, $fName ) ) {
1060  return false;
1061  }
1062  $sql = "DROP TABLE " . $this->tableName( $tableName );
1063 
1064  return $this->query( $sql, $fName );
1065  }
1066 
1067  public function setTableAliases( array $aliases ) {
1068  parent::setTableAliases( $aliases );
1069  foreach ( $this->tableAliases as $params ) {
1070  if ( isset( $this->alreadyAttached[$params['dbname']] ) ) {
1071  continue;
1072  }
1073  $this->attachDatabase( $params['dbname'] );
1074  $this->alreadyAttached[$params['dbname']] = true;
1075  }
1076  }
1077 
1078  public function resetSequenceForTable( $table, $fname = __METHOD__ ) {
1079  $encTable = $this->addIdentifierQuotes( 'sqlite_sequence' );
1080  $encName = $this->addQuotes( $this->tableName( $table, 'raw' ) );
1081  $this->query( "DELETE FROM $encTable WHERE name = $encName", $fname );
1082  }
1083 
1084  public function databasesAreIndependent() {
1085  return true;
1086  }
1087 
1091  public function __toString() {
1092  return is_object( $this->conn )
1093  ? 'SQLite ' . (string)$this->conn->getAttribute( PDO::ATTR_SERVER_VERSION )
1094  : '(not connected)';
1095  }
1096 
1100  protected function getBindingHandle() {
1101  return parent::getBindingHandle();
1102  }
1103 }
1104 
1105 class_alias( DatabaseSqlite::class, 'DatabaseSqlite' );
DBO_PERSISTENT
const DBO_PERSISTENT
Definition: defines.php:14
Wikimedia\Rdbms\DatabaseSqlite\$fulltextEnabled
static bool $fulltextEnabled
Whether full text is enabled.
Definition: DatabaseSqlite.php:39
Wikimedia\Rdbms\SQLiteField
Definition: SQLiteField.php:5
Wikimedia\Rdbms\DatabaseSqlite\$trxMode
string $trxMode
Transaction mode.
Definition: DatabaseSqlite.php:46
Wikimedia\Rdbms\DatabaseSqlite\fieldInfo
fieldInfo( $table, $field)
Get information about a given field Returns false if the field does not exist.
Definition: DatabaseSqlite.php:756
Wikimedia\Rdbms\DatabaseSqlite\$lockMgr
FSLockManager $lockMgr
(hopefully on the same server as the DB)
Definition: DatabaseSqlite.php:57
LockManager
Class for handling resource locking.
Definition: LockManager.php:46
Wikimedia\Rdbms\DatabaseSqlite\getBindingHandle
getBindingHandle()
Definition: DatabaseSqlite.php:1100
Wikimedia\Rdbms\DatabaseSqlite\addQuotes
addQuotes( $s)
Definition: DatabaseSqlite.php:810
Wikimedia\Rdbms\DatabaseSqlite\fetchRow
fetchRow( $res)
Definition: DatabaseSqlite.php:383
Wikimedia\Rdbms\Database
Relational database abstraction object.
Definition: Database.php:48
Wikimedia\Rdbms\DatabaseSqlite
Definition: DatabaseSqlite.php:37
Wikimedia\Rdbms\DatabaseSqlite\$dbDir
string $dbDir
Directory.
Definition: DatabaseSqlite.php:42
Wikimedia\Rdbms\DatabaseSqlite\wasKnownStatementRollbackError
wasKnownStatementRollbackError()
Definition: DatabaseSqlite.php:724
use
Apache License January AND DISTRIBUTION Definitions License shall mean the terms and conditions for use
Definition: APACHE-LICENSE-2.0.txt:10
Wikimedia\Rdbms\Database\factory
static factory( $dbType, $p=[], $connect=self::NEW_CONNECTED)
Construct a Database subclass instance given a database type and parameters.
Definition: Database.php:422
Wikimedia\Rdbms\DatabaseSqlite\listTables
listTables( $prefix=null, $fname=__METHOD__)
List all tables on the database.
Definition: DatabaseSqlite.php:1027
FSLockManager
Simple version of LockManager based on using FS lock files.
Definition: FSLockManager.php:36
$rows
do that in ParserLimitReportFormat instead use this to modify the parameters of the image all existing parser cache entries will be invalid To avoid you ll need to handle that somehow(e.g. with the RejectParserCacheValue hook) because MediaWiki won 't do it for you. & $defaults also a ContextSource after deleting those rows but within the same transaction $rows
Definition: hooks.txt:2783
Wikimedia\Rdbms\DatabaseSqlite\unlock
unlock( $lockName, $method)
Release a lock.
Definition: DatabaseSqlite.php:934
array
the array() calling protocol came about after MediaWiki 1.4rc1.
string
This code would result in ircNotify being run twice when an article is and once for brion Hooks can return three possible true was required This is the default since MediaWiki *some string
Definition: hooks.txt:181
Wikimedia\Rdbms\Database\nativeReplace
nativeReplace( $table, $rows, $fname)
REPLACE query wrapper for MySQL and SQLite, which have a native REPLACE statement.
Definition: Database.php:2720
Wikimedia\Rdbms\DatabaseSqlite\unionSupportsOrderAndLimit
unionSupportsOrderAndLimit()
Definition: DatabaseSqlite.php:691
Wikimedia\Rdbms\DatabaseSqlite\implicitGroupby
implicitGroupby()
Definition: DatabaseSqlite.php:154
Wikimedia\Rdbms\DatabaseSqlite\databasesAreIndependent
databasesAreIndependent()
Returns true if DBs are assumed to be on potentially different servers.
Definition: DatabaseSqlite.php:1084
$ret
null means default in associative array with keys and values unescaped Should be merged with default with a value of false meaning to suppress the attribute in associative array with keys and values unescaped noclasses & $ret
Definition: hooks.txt:2005
Wikimedia\Rdbms\DatabaseSqlite\$dbPath
string $dbPath
File name for SQLite database file.
Definition: DatabaseSqlite.php:44
Wikimedia\Rdbms\Database\indexName
indexName( $index)
Allows for index remapping in queries where this is not consistent across DBMS.
Definition: Database.php:2531
Wikimedia\Rdbms\DatabaseSqlite\fetchAffectedRowCount
fetchAffectedRowCount()
Definition: DatabaseSqlite.php:514
Wikimedia\Rdbms\DatabaseSqlite\replace
replace( $table, $uniqueIndexes, $rows, $fname=__METHOD__)
Definition: DatabaseSqlite.php:656
Wikimedia\Rdbms\DatabaseSqlite\encodeBlob
encodeBlob( $b)
Definition: DatabaseSqlite.php:790
Wikimedia\Rdbms\DatabaseSqlite\setTableAliases
setTableAliases(array $aliases)
Make certain table names use their own database, schema, and table prefix when passed into SQL querie...
Definition: DatabaseSqlite.php:1067
Wikimedia\Rdbms
Definition: ChronologyProtector.php:24
$params
$params
Definition: styleTest.css.php:40
Wikimedia\Rdbms\DatabaseSqlite\lastError
lastError()
Definition: DatabaseSqlite.php:489
Wikimedia\Rdbms\DatabaseSqlite\getServerVersion
getServerVersion()
Definition: DatabaseSqlite.php:742
$s
$s
Definition: mergeMessageFileList.php:187
Wikimedia\Rdbms\DatabaseSqlite\dataSeek
dataSeek( $res, $row)
Definition: DatabaseSqlite.php:472
Wikimedia\Rdbms\DatabaseSqlite\strencode
strencode( $s)
Definition: DatabaseSqlite.php:782
Wikimedia\Rdbms\DatabaseSqlite\$lastResultHandle
resource $lastResultHandle
Definition: DatabaseSqlite.php:51
Wikimedia\Rdbms\DatabaseSqlite\buildSubstring
buildSubstring( $input, $startPosition, $length=null)
Definition: DatabaseSqlite.php:837
$res
$res
Definition: database.txt:21
Wikimedia\Rdbms\ResultWrapper
Result wrapper for grabbing data queried from an IDatabase object.
Definition: ResultWrapper.php:24
Wikimedia\Rdbms\DatabaseSqlite\openFile
openFile( $fileName, $dbName)
Opens a database file.
Definition: DatabaseSqlite.php:189
Wikimedia\Rdbms\DatabaseSqlite\closeConnection
closeConnection()
Does not actually close the connection, just destroys the reference for GC to do its work.
Definition: DatabaseSqlite.php:235
$result
The index of the header message $result[1]=The index of the body text message $result[2 through n]=Parameters passed to body text message. Please note the header message cannot receive/use parameters. 'ImgAuthModifyHeaders':Executed just before a file is streamed to a user via img_auth.php, allowing headers to be modified beforehand. $title:LinkTarget object & $headers:HTTP headers(name=> value, names are case insensitive). Two headers get special handling:If-Modified-Since(value must be a valid HTTP date) and Range(must be of the form "bytes=(\d*-\d*)") will be honored when streaming the file. 'ImportHandleLogItemXMLTag':When parsing a XML tag in a log item. Return false to stop further processing of the tag $reader:XMLReader object $logInfo:Array of information 'ImportHandlePageXMLTag':When parsing a XML tag in a page. Return false to stop further processing of the tag $reader:XMLReader object & $pageInfo:Array of information 'ImportHandleRevisionXMLTag':When parsing a XML tag in a page revision. Return false to stop further processing of the tag $reader:XMLReader object $pageInfo:Array of page information $revisionInfo:Array of revision information 'ImportHandleToplevelXMLTag':When parsing a top level XML tag. Return false to stop further processing of the tag $reader:XMLReader object 'ImportHandleUnknownUser':When a user doesn 't exist locally, this hook is called to give extensions an opportunity to auto-create it. If the auto-creation is successful, return false. $name:User name 'ImportHandleUploadXMLTag':When parsing a XML tag in a file upload. Return false to stop further processing of the tag $reader:XMLReader object $revisionInfo:Array of information 'ImportLogInterwikiLink':Hook to change the interwiki link used in log entries and edit summaries for transwiki imports. & $fullInterwikiPrefix:Interwiki prefix, may contain colons. & $pageTitle:String that contains page title. 'ImportSources':Called when reading from the $wgImportSources configuration variable. Can be used to lazy-load the import sources list. & $importSources:The value of $wgImportSources. Modify as necessary. See the comment in DefaultSettings.php for the detail of how to structure this array. 'InfoAction':When building information to display on the action=info page. $context:IContextSource object & $pageInfo:Array of information 'InitializeArticleMaybeRedirect':MediaWiki check to see if title is a redirect. & $title:Title object for the current page & $request:WebRequest & $ignoreRedirect:boolean to skip redirect check & $target:Title/string of redirect target & $article:Article object 'InternalParseBeforeLinks':during Parser 's internalParse method before links but after nowiki/noinclude/includeonly/onlyinclude and other processings. & $parser:Parser object & $text:string containing partially parsed text & $stripState:Parser 's internal StripState object 'InternalParseBeforeSanitize':during Parser 's internalParse method just before the parser removes unwanted/dangerous HTML tags and after nowiki/noinclude/includeonly/onlyinclude and other processings. Ideal for syntax-extensions after template/parser function execution which respect nowiki and HTML-comments. & $parser:Parser object & $text:string containing partially parsed text & $stripState:Parser 's internal StripState object 'InterwikiLoadPrefix':When resolving if a given prefix is an interwiki or not. Return true without providing an interwiki to continue interwiki search. $prefix:interwiki prefix we are looking for. & $iwData:output array describing the interwiki with keys iw_url, iw_local, iw_trans and optionally iw_api and iw_wikiid. 'InvalidateEmailComplete':Called after a user 's email has been invalidated successfully. $user:user(object) whose email is being invalidated 'IRCLineURL':When constructing the URL to use in an IRC notification. Callee may modify $url and $query, URL will be constructed as $url . $query & $url:URL to index.php & $query:Query string $rc:RecentChange object that triggered url generation 'IsFileCacheable':Override the result of Article::isFileCacheable()(if true) & $article:article(object) being checked 'IsTrustedProxy':Override the result of IP::isTrustedProxy() & $ip:IP being check & $result:Change this value to override the result of IP::isTrustedProxy() 'IsUploadAllowedFromUrl':Override the result of UploadFromUrl::isAllowedUrl() $url:URL used to upload from & $allowed:Boolean indicating if uploading is allowed for given URL 'isValidEmailAddr':Override the result of Sanitizer::validateEmail(), for instance to return false if the domain name doesn 't match your organization. $addr:The e-mail address entered by the user & $result:Set this and return false to override the internal checks 'isValidPassword':Override the result of User::isValidPassword() $password:The password entered by the user & $result:Set this and return false to override the internal checks $user:User the password is being validated for 'Language::getMessagesFileName':$code:The language code or the language we 're looking for a messages file for & $file:The messages file path, you can override this to change the location. 'LanguageGetMagic':DEPRECATED! Use $magicWords in a file listed in $wgExtensionMessagesFiles instead. Use this to define synonyms of magic words depending of the language & $magicExtensions:associative array of magic words synonyms $lang:language code(string) 'LanguageGetNamespaces':Provide custom ordering for namespaces or remove namespaces. Do not use this hook to add namespaces. Use CanonicalNamespaces for that. & $namespaces:Array of namespaces indexed by their numbers 'LanguageGetSpecialPageAliases':DEPRECATED! Use $specialPageAliases in a file listed in $wgExtensionMessagesFiles instead. Use to define aliases of special pages names depending of the language & $specialPageAliases:associative array of magic words synonyms $lang:language code(string) 'LanguageGetTranslatedLanguageNames':Provide translated language names. & $names:array of language code=> language name $code:language of the preferred translations 'LanguageLinks':Manipulate a page 's language links. This is called in various places to allow extensions to define the effective language links for a page. $title:The page 's Title. & $links:Array with elements of the form "language:title" in the order that they will be output. & $linkFlags:Associative array mapping prefixed links to arrays of flags. Currently unused, but planned to provide support for marking individual language links in the UI, e.g. for featured articles. 'LanguageSelector':Hook to change the language selector available on a page. $out:The output page. $cssClassName:CSS class name of the language selector. 'LinkBegin':DEPRECATED! Use HtmlPageLinkRendererBegin instead. Used when generating internal and interwiki links in Linker::link(), before processing starts. Return false to skip default processing and return $ret. See documentation for Linker::link() for details on the expected meanings of parameters. $skin:the Skin object $target:the Title that the link is pointing to & $html:the contents that the< a > tag should have(raw HTML) $result
Definition: hooks.txt:1993
Wikimedia\Rdbms\DBError
Database error base class.
Definition: DBError.php:30
Wikimedia\Rdbms\DatabaseSqlite\buildStringCast
buildStringCast( $field)
Definition: DatabaseSqlite.php:851
Wikimedia\Rdbms\DatabaseSqlite\makeInsertOptions
makeInsertOptions( $options)
Definition: DatabaseSqlite.php:615
true
null means default in associative array with keys and values unescaped Should be merged with default with a value of false meaning to suppress the attribute in associative array with keys and values unescaped noclasses just before the function returns a value If you return true
Definition: hooks.txt:2006
php
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency which acts as the top level factory for services in MediaWiki which can be used to gain access to default instances of various services MediaWikiServices however also allows new services to be defined and default services to be redefined Services are defined or redefined by providing a callback the instantiator that will return a new instance of the service When it will create an instance of MediaWikiServices and populate it with the services defined in the files listed by thereby bootstrapping the DI framework Per $wgServiceWiringFiles lists includes ServiceWiring php
Definition: injection.txt:37
Wikimedia\Rdbms\DatabaseSqlite\unionQueries
unionQueries( $sqls, $all)
Definition: DatabaseSqlite.php:700
flags
design txt This is a brief overview of the new design More thorough and up to date information is available on the documentation wiki at etc Handles the details of getting and saving to the user table of the and dealing with sessions and cookies OutputPage Encapsulates the entire HTML page that will be sent in response to any server request It is used by calling its functions to add in any and then calling but I prefer the flexibility This should also do the output encoding The system allocates a global one in $wgOut Title Represents the title of an and does all the work of translating among various forms such as plain database etc For and for historical it also represents a few features of articles that don t involve their such as access rights See also title txt Article Encapsulates access to the page table of the database The object represents a an and maintains state such as flags
Definition: design.txt:34
Wikimedia\Rdbms\DatabaseSqlite\$lastAffectedRowCount
int $lastAffectedRowCount
The number of rows affected as an integer.
Definition: DatabaseSqlite.php:49
Wikimedia\Rdbms\Database\assertBuildSubstringParams
assertBuildSubstringParams( $startPosition, $length)
Check type and bounds for parameters to self::buildSubstring()
Definition: Database.php:2161
Wikimedia\Rdbms\DatabaseSqlite\wasDeadlock
wasDeadlock()
Definition: DatabaseSqlite.php:709
tableName
We use the convention $dbr for read and $dbw for write to help you keep track of whether the database object is a the world will explode Or to be a subsequent write query which succeeded on the master may fail when replicated to the slave due to a unique key collision Replication on the slave will stop and it may take hours to repair the database and get it back online Setting read_only in my cnf on the slave will avoid this but given the dire we prefer to have as many checks as possible We provide a but the wrapper functions like please read the documentation for tableName() and addQuotes(). You will need both of them. ------------------------------------------------------------------------ Basic query optimisation ------------------------------------------------------------------------ MediaWiki developers who need to write DB queries should have some understanding of databases and the performance issues associated with them. Patches containing unacceptably slow features will not be accepted. Unindexed queries are generally not welcome in MediaWiki
Wikimedia\Rdbms\Database\trxLevel
trxLevel()
Gets the current transaction level.
Definition: Database.php:577
$input
if(is_array( $mode)) switch( $mode) $input
Definition: postprocess-phan.php:141
Wikimedia\Rdbms\DatabaseSqlite\generateFileName
static generateFileName( $dir, $dbName)
Generates a database file name.
Definition: DatabaseSqlite.php:247
Wikimedia\Rdbms\DatabaseSqlite\doBegin
doBegin( $fname='')
Issues the BEGIN command to the database server.
Definition: DatabaseSqlite.php:769
Wikimedia\Rdbms\DatabaseSqlite\$conn
PDO $conn
Definition: DatabaseSqlite.php:54
Wikimedia\Rdbms\DatabaseSqlite\resetSequenceForTable
resetSequenceForTable( $table, $fname=__METHOD__)
Definition: DatabaseSqlite.php:1078
Wikimedia\Rdbms\DatabaseSqlite\fixIgnore
static fixIgnore( $options)
Definition: DatabaseSqlite.php:600
Wikimedia\Rdbms\Database\selectSQLText
selectSQLText( $table, $vars, $conds='', $fname=__METHOD__, $options=[], $join_conds=[])
The equivalent of IDatabase::select() except that the constructed SQL is returned,...
Definition: Database.php:1656
Wikimedia\Rdbms\Database\$user
string $user
User that this instance is currently connected under the name of.
Definition: Database.php:81
Wikimedia\Rdbms\DatabaseSqlite\getDbFilePath
getDbFilePath()
Definition: DatabaseSqlite.php:227
Wikimedia\Rdbms\DatabaseSqlite\numRows
numRows( $res)
The PDO::Statement class implements the array interface so count() will work.
Definition: DatabaseSqlite.php:405
Wikimedia\Rdbms\DatabaseSqlite\replaceVars
replaceVars( $s)
Definition: DatabaseSqlite.php:871
Wikimedia\Rdbms\DatabaseSqlite\deadlockLoop
deadlockLoop()
No-op version of deadlockLoop.
Definition: DatabaseSqlite.php:860
Wikimedia\Rdbms\DatabaseSqlite\fieldName
fieldName( $res, $n)
Definition: DatabaseSqlite.php:431
Wikimedia\Rdbms\Database\selectRow
selectRow( $table, $vars, $conds, $fname=__METHOD__, $options=[], $join_conds=[])
Single row SELECT wrapper.
Definition: Database.php:1725
$fname
if(defined( 'MW_SETUP_CALLBACK')) $fname
Customization point after all loading (constants, functions, classes, DefaultSettings,...
Definition: Setup.php:112
$options
null means default in associative array with keys and values unescaped Should be merged with default with a value of false meaning to suppress the attribute in associative array with keys and values unescaped & $options
Definition: hooks.txt:2001
Wikimedia\Rdbms\DatabaseSqlite\lock
lock( $lockName, $method, $timeout=5)
Acquire a named lock.
Definition: DatabaseSqlite.php:924
Wikimedia\Rdbms\Database\tableExists
tableExists( $table, $fname=__METHOD__)
Query whether a given table exists.
Definition: Database.php:1884
Wikimedia\Rdbms\DatabaseSqlite\fetchObject
fetchObject( $res)
Definition: DatabaseSqlite.php:356
Wikimedia\Rdbms\DatabaseSqlite\__toString
__toString()
Definition: DatabaseSqlite.php:1091
Wikimedia\Rdbms\DatabaseSqlite\doQuery
doQuery( $sql)
SQLite doesn't allow buffered results or data seeking etc, so we'll use fetchAll as the result.
Definition: DatabaseSqlite.php:328
Wikimedia\Rdbms\DatabaseSqlite\getAttributes
static getAttributes()
Definition: DatabaseSqlite.php:97
Wikimedia\Rdbms\DatabaseSqlite\getType
getType()
Definition: DatabaseSqlite.php:145
Wikimedia\Rdbms\DatabaseSqlite\$alreadyAttached
array $alreadyAttached
List of shared database already attached to this connection.
Definition: DatabaseSqlite.php:60
Wikimedia\Rdbms\Database\query
query( $sql, $fname=__METHOD__, $tempIgnore=false)
Run an SQL query and return the result.
Definition: Database.php:1094
Wikimedia\Rdbms\DatabaseSqlite\buildGroupConcatField
buildGroupConcatField( $delim, $table, $field, $conds='', $join_conds=[])
Build a GROUP_CONCAT or equivalent statement for a query.
Definition: DatabaseSqlite.php:948
Wikimedia\Rdbms\DatabaseSqlite\attachDatabase
attachDatabase( $name, $file=false, $fname=__METHOD__)
Attaches external database to our connection, see https://sqlite.org/lang_attach.html for details.
Definition: DatabaseSqlite.php:301
Wikimedia\Rdbms\DatabaseSqlite\isTransactableQuery
isTransactableQuery( $sql)
Determine whether a SQL statement is sensitive to isolation level.
Definition: DatabaseSqlite.php:314
Wikimedia\Rdbms\DatabaseSqlite\insert
insert( $table, $a, $fname=__METHOD__, $options=[])
Based on generic method (parent) with some prior SQLite-sepcific adjustments.
Definition: DatabaseSqlite.php:629
Wikimedia\Rdbms\DatabaseSqlite\newStandaloneInstance
static newStandaloneInstance( $filename, array $p=[])
Definition: DatabaseSqlite.php:110
insert
either a unescaped string or a HtmlArmor object after in associative array form externallinks including delete and insert
Definition: hooks.txt:2091
Wikimedia\Rdbms\Database\addIdentifierQuotes
addIdentifierQuotes( $s)
Quotes an identifier using backticks or "double quotes" depending on the database type.
Definition: Database.php:2563
$args
if( $line===false) $args
Definition: cdb.php:64
Wikimedia\Rdbms\DatabaseSqlite\open
open( $server, $user, $pass, $dbName)
Open an SQLite database and return a resource handle to it NOTE: only $dbName is used,...
Definition: DatabaseSqlite.php:169
Wikimedia\Rdbms\Database\close
close()
Close the database connection.
Definition: Database.php:900
Wikimedia\Rdbms\DatabaseSqlite\getFulltextSearchModule
static getFulltextSearchModule()
Returns version of currently supported SQLite fulltext search module or false if none present.
Definition: DatabaseSqlite.php:273
Wikimedia\Rdbms\Database\getQueryVerb
getQueryVerb( $sql)
Definition: Database.php:1034
$name
Allows to change the fields on the form that will be generated $name
Definition: hooks.txt:302
Wikimedia\Rdbms\DatabaseSqlite\makeUpdateOptionsArray
makeUpdateOptionsArray( $options)
Definition: DatabaseSqlite.php:589
Wikimedia\Rdbms\DatabaseSqlite\getSoftwareLink
getSoftwareLink()
Definition: DatabaseSqlite.php:735
Wikimedia\Rdbms\DatabaseSqlite\doInitConnection
doInitConnection()
Actually connect to the database over the wire (or to local files)
Definition: DatabaseSqlite.php:120
Wikimedia\Rdbms\DatabaseSqlite\insertId
insertId()
This must be called after nextSequenceVal.
Definition: DatabaseSqlite.php:463
Wikimedia\Rdbms\DatabaseSqlite\makeSelectOptions
makeSelectOptions( $options)
Filter the options used in SELECT statements.
Definition: DatabaseSqlite.php:575
Wikimedia\Rdbms\DatabaseSqlite\freeResult
freeResult( $res)
Definition: DatabaseSqlite.php:344
Wikimedia\Rdbms\DatabaseSqlite\lastErrno
lastErrno()
Definition: DatabaseSqlite.php:501
as
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such as
Definition: distributors.txt:22
Wikimedia\Rdbms\DatabaseSqlite\indexUnique
indexUnique( $table, $index, $fname=__METHOD__)
Definition: DatabaseSqlite.php:548
Wikimedia\Rdbms\DBConnectionError
Definition: DBConnectionError.php:26
Wikimedia\Rdbms\DatabaseSqlite\wasReadOnlyError
wasReadOnlyError()
Definition: DatabaseSqlite.php:716
Wikimedia\Rdbms\Database\$server
string $server
Server that this instance is currently connected to.
Definition: Database.php:79
$keys
$keys
Definition: testCompression.php:67
Wikimedia\Rdbms\DatabaseSqlite\buildConcat
buildConcat( $stringList)
Build a concatenation list to feed into a SQL query.
Definition: DatabaseSqlite.php:944
Wikimedia\Rdbms\Database\select
select( $table, $vars, $conds='', $fname=__METHOD__, $options=[], $join_conds=[])
Execute a SELECT query constructed using the various parameters provided.
Definition: Database.php:1649
class
you have access to all of the normal MediaWiki so you can get a DB use the etc For full docs on the Maintenance class
Definition: maintenance.txt:56
Wikimedia\Rdbms\DatabaseSqlite\isWriteQuery
isWriteQuery( $sql)
Determine whether a query writes to the DB.
Definition: DatabaseSqlite.php:310
$vars
static configuration should be added through ResourceLoaderGetConfigVars instead & $vars
Definition: hooks.txt:2228
Wikimedia\Rdbms\DatabaseSqlite\wasConnectionError
wasConnectionError( $errno)
Do not use this method outside of Database/DBError classes.
Definition: DatabaseSqlite.php:720
LockManager\LOCK_EX
const LOCK_EX
Definition: LockManager.php:69
Wikimedia\Rdbms\DatabaseSqlite\__construct
__construct(array $p)
Additional params include:
Definition: DatabaseSqlite.php:70
Wikimedia\Rdbms\DatabaseSqlite\decodeBlob
decodeBlob( $b)
Definition: DatabaseSqlite.php:798
Wikimedia\Rdbms\DatabaseSqlite\dropTable
dropTable( $tableName, $fName=__METHOD__)
Override due to no CASCADE support.
Definition: DatabaseSqlite.php:1058
Wikimedia\Rdbms\DatabaseSqlite\checkForEnabledSearch
checkForEnabledSearch()
Check if the searchindext table is FTS enabled.
Definition: DatabaseSqlite.php:255
Wikimedia\Rdbms\DatabaseSqlite\duplicateTableStructure
duplicateTableStructure( $oldName, $newName, $temporary=false, $fname=__METHOD__)
Definition: DatabaseSqlite.php:964
Wikimedia\Rdbms\DatabaseSqlite\numFields
numFields( $res)
Definition: DatabaseSqlite.php:415
Wikimedia\Rdbms\DatabaseSqlite\tableName
tableName( $name, $format='quoted')
Use MySQL's naming (accounts for prefix etc) but remove surrounding backticks.
Definition: DatabaseSqlite.php:449
$e
div flags Integer display flags(NO_ACTION_LINK, NO_EXTRA_USER_LINKS) 'LogException' returning false will NOT prevent logging $e
Definition: hooks.txt:2171
Wikimedia\Rdbms\DatabaseSqlite\indexInfo
indexInfo( $table, $index, $fname=__METHOD__)
Returns information about an index Returns false if the index does not exist.
Definition: DatabaseSqlite.php:528
Wikimedia\Rdbms\DatabaseSqlite\textFieldSize
textFieldSize( $table, $field)
Returns the size of a text field, or -1 for "unlimited" In SQLite this is SQLITE_MAX_LENGTH,...
Definition: DatabaseSqlite.php:684
Wikimedia\Rdbms\Blob
Definition: Blob.php:5
Wikimedia\Rdbms\Database\$dbName
string $dbName
Database that this instance is currently connected to.
Definition: Database.php:85