MNT Use gha-dispatch-ci (#71)

prevent php 8 complaining about null values

.editorconfig

@@ -0,0 +1,17 @@
+# For more information about the properties used in this file,
+# please see the EditorConfig documentation:
+# http://editorconfig.org
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[{*.yml,package.json}]
+indent_size = 2
+
+# The indent size used in the package.json file cannot be changed:
+# https://github.com/npm/npm/pull/3180#issuecomment-16336516

.gitattributes

@@ -0,0 +1 @@
+/.travis.yml export-ignore

.github/workflows/ci.yml

@@ -0,0 +1,11 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  ci:
+    name: CI
+    uses: silverstripe/gha-ci/.github/workflows/ci.yml@v1

.github/workflows/dispatch-ci.yml

@@ -0,0 +1,16 @@
+name: Dispatch CI
+
+on:
+  # At 3:00 PM UTC, only on Sunday and Monday
+  schedule:
+    - cron: '0 15 * * 0,1'
+
+jobs:
+  dispatch-ci:
+    name: Dispatch CI
+    # Only run cron on the silverstripe account
+    if: (github.event_name == 'schedule' && github.repository_owner == 'silverstripe') || (github.event_name != 'schedule')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Dispatch CI
+        uses: silverstripe/gha-dispatch-ci@v1

.github/workflows/keepalive.yml

@@ -0,0 +1,17 @@
+name: Keepalive
+
+on:
+  workflow_dispatch:
+  # The 15th of every month at 3:50pm UTC
+  schedule:
+    - cron: '50 15 15 * *'
+
+jobs:
+  keepalive:
+    name: Keepalive
+    # Only run cron on the silverstripe account
+    if: (github.event_name == 'schedule' && github.repository_owner == 'silverstripe') || (github.event_name != 'schedule')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Keepalive
+        uses: silverstripe/gha-keepalive@v1

.travis.yml

@@ -1,20 +0,0 @@
-language: php
-
-sudo: false
-
-php:
-  - 5.3
-
-env:
-  matrix:
-    - DB=POSTGRESQL CORE_RELEASE=master
-
-before_script:
- - composer self-update || true
- - phpenv rehash
- - git clone git://github.com/silverstripe-labs/silverstripe-travis-support.git ~/travis-support
- - php ~/travis-support/travis_setup.php --source `pwd` --target ~/builds/ss
- - cd ~/builds/ss
-
-script: 
- - phpunit framework/tests 

.upgrade.yml

@@ -0,0 +1,7 @@
+mappings:
+  SQLite3Connector: SilverStripe\SQLite\SQLite3Connector
+  SQLite3Database: SilverStripe\SQLite\SQLite3Database
+  SQLite3Query: SilverStripe\SQLite\SQLite3Query
+  SQLite3QueryBuilder: SilverStripe\SQLite\SQLite3QueryBuilder
+  SQLite3SchemaManager: SilverStripe\SQLite\SQLite3SchemaManager
+  SQLiteDatabaseConfigurationHelper: SilverStripe\SQLite\SQLiteDatabaseConfigurationHelper

README.md

@@ -1,6 +1,7 @@
 # SQLite3 Module
 
-[![Build Status](https://travis-ci.org/silverstripe-labs/silverstripe-sqlite3.png?branch=master)](https://travis-ci.org/silverstripe-labs/silverstripe-sqlite3)
+[![CI](https://github.com/silverstripe/silverstripe-sqlite3/actions/workflows/ci.yml/badge.svg)](https://github.com/silverstripe/silverstripe-sqlite3/actions/workflows/ci.yml)
+[![Silverstripe supported module](https://img.shields.io/badge/silverstripe-supported-0071C4.svg)](https://www.silverstripe.org/software/addons/silverstripe-commercially-supported-module-list/)
 
 ## Maintainer Contact
 
@@ -9,26 +10,23 @@ Andreas Piening (Nickname: apiening)
 
 ## Requirements
 
- * SilverStripe 3.2 or newer
+ * Silverstripe 4.0 or newer
 
 ## Installation
 
- * If using composer, run `composer require silverstripe/sqlite3 1.4.*-dev`.
+ * Install using composer with `composer require silverstripe/sqlite3 ^2`.
- * Otherwise, download, unzip and copy the sqlite3 folder to your project root so that it becomes a
-   sibling of `framework/`.
 
 ## Configuration
 
 Either use the installer to automatically install SQLite or add this to your _config.php (right after
 "require_once("conf/ConfigureFromEnv.php");" if you are using _ss_environment.php)
 
-	$databaseConfig['type'] = 'SQLiteDatabase';
+	$databaseConfig['type'] = 'SQLite3Database';
 	$databaseConfig['path'] = "/path/to/my/database/file";
 
 Make sure the webserver has sufficient privileges to write to that folder and that it is protected from
 external access.
 
-
 ### Sample mysite/_config.php
 
 ```php
@@ -42,18 +40,14 @@ $database = 'SS_mysite';
 require_once("conf/ConfigureFromEnv.php");
 
 global $databaseConfig;
-
 $databaseConfig = array(
-	"type" => 'SQLiteDatabase',
+	"type" => 'SQLite3Database',
 	"server" => 'none',
 	"username" => 'none',
 	"password" => 'none',
 	"database" => $database,
 	"path" => "/path/to/my/database/file",
 );
-
-SSViewer::set_theme('blackcandy');
-SiteTree::enable_nested_urls();
 ```
 
 Again: make sure that the webserver has permission to read and write to the above path (/path/to/my/database/,

_config.php

@@ -1,3 +1 @@
 <?php
-
-Deprecation::notification_version('1.4.0', 'sqlite3');

_config/connectors.yml

@@ -1,29 +1,36 @@
 ---
 name: sqlite3connectors
 ---
-Injector:
+SilverStripe\Core\Injector\Injector:
   SQLite3PDODatabase:
-    class: 'SQLite3Database'
+    class: SilverStripe\SQLite\SQLite3Database
     properties:
-      connector: %$PDOConnector
+      connector: '%$PDOConnector'
-      schemaManager: %$SQLite3SchemaManager
+      schemaManager: '%$SQLite3SchemaManager'
-      queryBuilder: %$SQLite3QueryBuilder
+      queryBuilder: '%$SQLite3QueryBuilder'
   SQLite3Database:
-    class: 'SQLite3Database'
+    class: SilverStripe\SQLite\SQLite3Database
     properties:
-      connector: %$SQLite3Connector
+      connector: '%$SQLite3Connector'
-      schemaManager: %$SQLite3SchemaManager
+      schemaManager: '%$SQLite3SchemaManager'
-      queryBuilder: %$SQLite3QueryBuilder
+      queryBuilder: '%$SQLite3QueryBuilder'
 # Legacy connector names
   SQLiteDatabase:
-    class: 'SQLite3Database'
+    class: SilverStripe\SQLite\SQLite3Database
     properties:
-      connector: %$SQLite3Connector
+      connector: '%$SQLite3Connector'
-      schemaManager: %$SQLite3SchemaManager
+      schemaManager: '%$SQLite3SchemaManager'
-      queryBuilder: %$SQLite3QueryBuilder
+      queryBuilder: '%$SQLite3QueryBuilder'
   SQLitePDODatabase:
-    class: 'SQLite3Database'
+    class: SilverStripe\SQLite\SQLite3Database
     properties:
-      connector: %$SQLite3Connector
+      connector: '%$SQLite3Connector'
-      schemaManager: %$SQLite3SchemaManager
+      schemaManager: '%$SQLite3SchemaManager'
-      queryBuilder: %$SQLite3QueryBuilder
+      queryBuilder: '%$SQLite3QueryBuilder'
+  SQLite3Connector:
+    class: SilverStripe\SQLite\SQLite3Connector
+    type: prototype
+  SQLite3SchemaManager:
+    class: SilverStripe\SQLite\SQLite3SchemaManager
+  SQLite3QueryBuilder:
+    class: SilverStripe\SQLite\SQLite3QueryBuilder

_config/sqllite3.yml

@@ -1,4 +0,0 @@
-SQLLite3Database:
-# Extension used to distinguish between sqllite database files and other files
-# Required to handle multiple databases
-  database_extension: '.sqlite'

_configure_database.php

@@ -1,14 +1,25 @@
 <?php
 
-// Script called from ConfigureFromEnv.php
+// Called from DatabaseAdapterRegistry::autoconfigure($config)
+use SilverStripe\Core\Environment;
+use SilverStripe\SQLite\SQLite3Database;
+
+if (!isset($databaseConfig)) {
     global $databaseConfig;
-if(strpos($databaseConfig['type'], 'SQLite') === 0) {
-
-	if(defined('SS_SQLITE_DATABASE_PATH')) {
-		$databaseConfig['path'] = SS_SQLITE_DATABASE_PATH;
 }
 
-	if(defined('SS_SQLITE_DATABASE_KEY')) {
+// Get path
-		$databaseConfig['key'] = SS_SQLITE_DATABASE_KEY;
+$path = Environment::getEnv(SQLite3Database::ENV_PATH);
+if ($path) {
+    $databaseConfig['path'] = $path;
+} elseif (defined(SQLite3Database::ENV_PATH)) {
+    $databaseConfig['path'] = constant(SQLite3Database::ENV_PATH);
 }
+
+// Get key
+$key = Environment::getEnv(SQLite3Database::ENV_KEY);
+if ($key) {
+    $databaseConfig['key'] = $key;
+} elseif (defined(SQLite3Database::ENV_KEY)) {
+    $databaseConfig['key'] = constant(SQLite3Database::ENV_KEY);
 }

_register_database.php

@@ -1,5 +1,8 @@
 <?php
 
+use SilverStripe\Dev\Install\DatabaseAdapterRegistry;
+use SilverStripe\SQLite\SQLiteDatabaseConfigurationHelper;
+
 $sqliteDatabaseAdapterRegistryFields = array(
     'path' => array(
         'title' => 'Directory path<br /><small>Absolute path to directory, writeable by the webserver user.<br />'
@@ -13,11 +16,14 @@ $sqliteDatabaseAdapterRegistryFields = array(
 );
 
 // Basic SQLLite3 Database
+/** @skipUpgrade */
 DatabaseAdapterRegistry::register(
     array(
         'class' => 'SQLite3Database',
+        'module' => 'sqlite3',
         'title' => 'SQLite 3.3+ (using SQLite3)',
-		'helperPath' => dirname(__FILE__).'/code/SQLiteDatabaseConfigurationHelper.php',
+        'helperPath' => __DIR__.'/code/SQLiteDatabaseConfigurationHelper.php',
+        'helperClass' => SQLiteDatabaseConfigurationHelper::class,
         'supported' => class_exists('SQLite3'),
         'missingExtensionText' => 'The <a href="http://php.net/manual/en/book.sqlite3.php">SQLite3</a> 
 			PHP Extension is not available. Please install or enable it of them and refresh this page.',
@@ -30,11 +36,14 @@ DatabaseAdapterRegistry::register(
 );
 
 // PDO database
+/** @skipUpgrade */
 DatabaseAdapterRegistry::register(
     array(
         'class' => 'SQLite3PDODatabase',
+        'module' => 'sqlite3',
         'title' => 'SQLite 3.3+ (using PDO)',
-		'helperPath' => dirname(__FILE__).'/code/SQLiteDatabaseConfigurationHelper.php',
+        'helperPath' => __DIR__.'/code/SQLiteDatabaseConfigurationHelper.php',
+        'helperClass' => SQLiteDatabaseConfigurationHelper::class,
         'supported' => (class_exists('PDO') && in_array('sqlite', PDO::getAvailableDrivers())),
         'missingExtensionText' =>
             'Either the <a href="http://php.net/manual/en/book.pdo.php">PDO Extension</a> or the

code-of-conduct.md

@@ -0,0 +1 @@
+When having discussions about this module in issues or pull request please adhere to the [SilverStripe Community Code of Conduct](https://docs.silverstripe.org/en/contributing/code_of_conduct).

code/SQLite3Connector.php

@@ -1,11 +1,15 @@
 <?php
 
+namespace SilverStripe\SQLite;
+
+use SilverStripe\ORM\Connect\DBConnector;
+use SQLite3;
+
 /**
  * SQLite connector class
- * 
- * @package SQLite3
  */
-class SQLite3Connector extends DBConnector {
+class SQLite3Connector extends DBConnector
+{
 
     /**
      * The name of the database.
@@ -21,7 +25,8 @@ class SQLite3Connector extends DBConnector {
      */
     protected $dbConn;
 
-	public function connect($parameters, $selectDB = false) {
+    public function connect($parameters, $selectDB = false)
+    {
         $file = $parameters['filepath'];
         $this->dbConn = empty($parameters['key'])
                 ? new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE)
@@ -30,29 +35,35 @@ class SQLite3Connector extends DBConnector {
         $this->databaseName = $parameters['database'];
     }
 
-	public function affectedRows() {
+    public function affectedRows()
+    {
         return $this->dbConn->changes();
     }
 
-	public function getGeneratedID($table) {
+    public function getGeneratedID($table)
+    {
         return $this->dbConn->lastInsertRowID();
     }
 
-	public function getLastError() {
+    public function getLastError()
+    {
         $message = $this->dbConn->lastErrorMsg();
         return $message === 'not an error' ? null : $message;
     }
 
-	public function getSelectedDatabase() {
+    public function getSelectedDatabase()
+    {
         return $this->databaseName;
     }
 
-	public function getVersion() {
+    public function getVersion()
+    {
         $version = SQLite3::version();
         return trim($version['versionString']);
     }
 
-	public function isActive() {
+    public function isActive()
+    {
         return $this->databaseName && $this->dbConn;
     }
 
@@ -62,7 +73,8 @@ class SQLite3Connector extends DBConnector {
      * @param array $parameters List of parameters
      * @return array List of parameters types and values
      */
-	public function parsePreparedParameters($parameters) {
+    public function parsePreparedParameters($parameters)
+    {
         $values = array();
         foreach ($parameters as $value) {
             $phpType = gettype($value);
@@ -99,7 +111,7 @@ class SQLite3Connector extends DBConnector {
                 case 'array':
                 case 'unknown type':
                 default:
-					user_error("Cannot bind parameter \"$value\" as it is an unsupported type ($phpType)", E_USER_ERROR);
+                    $this->databaseError("Cannot bind parameter \"$value\" as it is an unsupported type ($phpType)");
                     break;
             }
             $values[] = array(
@@ -110,7 +122,8 @@ class SQLite3Connector extends DBConnector {
         return $values;
     }
 
-	public function preparedQuery($sql, $parameters, $errorLevel = E_USER_ERROR) {
+    public function preparedQuery($sql, $parameters, $errorLevel = E_USER_ERROR)
+    {
         // Type check, identify, and prepare parameters for passing to the statement bind function
         $parsedParameters = $this->parsePreparedParameters($parameters);
 
@@ -137,7 +150,8 @@ class SQLite3Connector extends DBConnector {
         return null;
     }
 
-	public function query($sql, $errorLevel = E_USER_ERROR) {
+    public function query($sql, $errorLevel = E_USER_ERROR)
+    {
         // Return successful result
         $handle = @$this->dbConn->query($sql);
         if ($handle) {
@@ -149,22 +163,26 @@ class SQLite3Connector extends DBConnector {
         return null;
     }
 
-	public function quoteString($value) {
+    public function quoteString($value)
+    {
         return "'".$this->escapeString($value)."'";
     }
 
-	public function escapeString($value) {
+    public function escapeString($value)
-		return $this->dbConn->escapeString($value);
+    {
+        return $this->dbConn->escapeString($value ?? '');
     }
 
-	public function selectDatabase($name) {
+    public function selectDatabase($name)
+    {
         if ($name !== $this->databaseName) {
-			user_error("SQLite3Connector can't change databases. Please create a new database connection", E_USER_ERROR);
+            $this->databaseError("SQLite3Connector can't change databases. Please create a new database connection");
         }
         return true;
     }
 
-	public function unloadDatabase() {
+    public function unloadDatabase()
+    {
         $this->dbConn->close();
         $this->databaseName = null;
     }

code/SQLite3Database.php

@@ -1,11 +1,42 @@
 <?php
 
+namespace SilverStripe\SQLite;
+
+use SilverStripe\Assets\File;
+use SilverStripe\Core\Config\Configurable;
+use SilverStripe\Core\Convert;
+use SilverStripe\Dev\Deprecation;
+use SilverStripe\ORM\ArrayList;
+use SilverStripe\ORM\Connect\Database;
+use SilverStripe\ORM\DataList;
+use SilverStripe\ORM\DataObject;
+use SilverStripe\ORM\PaginatedList;
+use SilverStripe\ORM\Queries\SQLSelect;
+
 /**
  * SQLite database controller class
- * 
- * @package SQLite3
  */
-class SQLite3Database extends SS_Database {
+class SQLite3Database extends Database
+{
+    use Configurable;
+
+    /**
+     * Global environment config for setting 'path'
+     */
+    const ENV_PATH = 'SS_SQLITE_DATABASE_PATH';
+
+    /**
+     * Global environment config for setting 'key'
+     */
+    const ENV_KEY = 'SS_SQLITE_DATABASE_KEY';
+
+    /**
+     * Extension added to every database name
+     *
+     * @config
+     * @var string
+     */
+    private static $database_extension = '.sqlite';
 
     /**
      * Database schema manager object
@@ -29,6 +60,16 @@ class SQLite3Database extends SS_Database {
      */
     protected $livesInMemory = false;
 
+    /**
+     * @var bool
+     */
+    protected $transactionNesting = 0;
+
+    /**
+     * @var array
+     */
+    protected $transactionSavepoints = [];
+
     /**
      * List of default pragma values
      *
@@ -48,8 +89,9 @@ class SQLite3Database extends SS_Database {
      *
      * @return string
      */
-	public static function database_extension() {
+    public static function database_extension()
-		return Config::inst()->get('SQLite3Database', 'database_extension');
+    {
+        return static::config()->get('database_extension');
     }
 
     /**
@@ -58,9 +100,12 @@ class SQLite3Database extends SS_Database {
      * @param string $name
      * @return boolean
      */
-	public static function is_valid_database_name($name) {
+    public static function is_valid_database_name($name)
+    {
         $extension = self::database_extension();
-		if(empty($extension)) return true;
+        if (empty($extension)) {
+            return true;
+        }
 
         return substr_compare($name, $extension, -strlen($extension), strlen($extension)) === 0;
     }
@@ -73,8 +118,8 @@ class SQLite3Database extends SS_Database {
      *  - key: the encryption key (needs testing)
      *  - memory: use the faster In-Memory database for unit tests
      */
-	public function connect($parameters) {
+    public function connect($parameters)
-		
+    {
         if (!empty($parameters['memory'])) {
             Deprecation::notice(
                 '1.4.0',
@@ -91,30 +136,20 @@ class SQLite3Database extends SS_Database {
 
         // Ensure database name is set
         if (empty($parameters['database'])) {
-			$parameters['database'] = 'database' . self::database_extension();
+            $parameters['database'] = 'database';
         }
-		$dbName = $parameters['database'];
-		if(!self::is_valid_database_name($dbName)) {
-			// If not using the correct file extension for database files then the
-			// results of SQLite3SchemaManager::databaseList will be unpredictable
-			$extension = self::database_extension();
-			Deprecation::notice('3.2', "SQLite3Database now expects a database file with extension \"$extension\". Behaviour may be unpredictable otherwise.");
-		}
-
         // use the very lightspeed SQLite In-Memory feature for testing
         if ($this->getLivesInMemory()) {
             $file = ':memory:';
         } else {
             // Ensure path is given
-			if(empty($parameters['path'])) {
+            $path = $this->getPath();
-				$parameters['path'] = ASSETS_PATH . '/.sqlitedb';
-			}
 
             //assumes that the path to dbname will always be provided:
-			$file = $parameters['path'] . '/' . $dbName;
+            $file = $path . '/' . $parameters['database'] . self::database_extension();
-			if(!file_exists($parameters['path'])) {
+            if (!file_exists($path)) {
-				SQLiteDatabaseConfigurationHelper::create_db_dir($parameters['path']);
+                SQLiteDatabaseConfigurationHelper::create_db_dir($path);
-				SQLiteDatabaseConfigurationHelper::secure_db_dir($parameters['path']);
+                SQLiteDatabaseConfigurationHelper::secure_db_dir($path);
             }
         }
 
@@ -143,47 +178,76 @@ class SQLite3Database extends SS_Database {
      *
      * @return array
      */
-	public function getParameters() {
+    public function getParameters()
+    {
         return $this->parameters;
     }
 
-	public function getLivesInMemory() {
+    /**
+     * Determine if this Db is in memory
+     *
+     * @return bool
+     */
+    public function getLivesInMemory()
+    {
         return isset($this->parameters['path']) && $this->parameters['path'] === ':memory:';
     }
 
-	public function supportsCollations() {
+    /**
+     * Get file path. If in memory this is null
+     *
+     * @return string|null
+     */
+    public function getPath()
+    {
+        if ($this->getLivesInMemory()) {
+            return null;
+        }
+        if (empty($this->parameters['path'])) {
+            return ASSETS_PATH . '/.sqlitedb';
+        }
+        return $this->parameters['path'];
+    }
+
+    public function supportsCollations()
+    {
         return true;
     }
 
-	public function supportsTimezoneOverride() {
+    public function supportsTimezoneOverride()
+    {
         return false;
     }
 
     /**
      * Execute PRAGMA commands.
      *
-	 * @param string pragma name
+     * @param string $pragma name
-	 * @param string value to set
+     * @param string $value to set
      */
-	public function setPragma($pragma, $value) {
+    public function setPragma($pragma, $value)
+    {
         $this->query("PRAGMA $pragma = $value");
     }
 
     /**
      * Gets pragma value.
      *
-	 * @param string pragma name
+     * @param string $pragma name
      * @return string the pragma value
      */
-	public function getPragma($pragma) {
+    public function getPragma($pragma)
+    {
         return $this->query("PRAGMA $pragma")->value();
     }
 
-	public function getDatabaseServer() {
+    public function getDatabaseServer()
+    {
         return "sqlite";
     }
 
-	public function selectDatabase($name, $create = false, $errorLevel = E_USER_ERROR) {
+    public function selectDatabase($name, $create = false, $errorLevel = E_USER_ERROR)
+    {
         if (!$this->schemaManager->databaseExists($name)) {
             // Check DB creation permisson
             if (!$create) {
@@ -204,11 +268,13 @@ class SQLite3Database extends SS_Database {
         return true;
     }
 
-	function now(){
+    public function now()
+    {
         return "datetime('now', 'localtime')";
     }
 
-	function random(){
+    public function random()
+    {
         return 'random()';
     }
 
@@ -222,65 +288,96 @@ class SQLite3Database extends SS_Database {
      * - the fts3 extension needs to be available
      * for now we use the MySQL implementation with the MATCH()AGAINST() uglily replaced with LIKE
      *
+     * @param array $classesToSearch
      * @param string $keywords Keywords as a space separated string
-	 * @return object DataObjectSet of result pages
+     * @param int $start
+     * @param int $pageLength
+     * @param string $sortBy
+     * @param string $extraFilter
+     * @param bool $booleanSearch
+     * @param string $alternativeFileFilter
+     * @param bool $invertedMatch
+     * @return PaginatedList DataObjectSet of result pages
      */
-	public function searchEngine($classesToSearch, $keywords, $start, $pageLength, $sortBy = "Relevance DESC",
+    public function searchEngine(
-		$extraFilter = "", $booleanSearch = false, $alternativeFileFilter = "", $invertedMatch = false
+        $classesToSearch,
+        $keywords,
+        $start,
+        $pageLength,
+        $sortBy = "Relevance DESC",
+        $extraFilter = "",
+        $booleanSearch = false,
+        $alternativeFileFilter = "",
+        $invertedMatch = false
     ) {
+        $start = (int)$start;
+        $pageLength = (int)$pageLength;
         $keywords = $this->escapeString(str_replace(array('*', '+', '-', '"', '\''), '', $keywords));
         $htmlEntityKeywords = htmlentities(utf8_decode($keywords));
 
-		$extraFilters = array('SiteTree' => '', 'File' => '');
+        $pageClass = 'SilverStripe\\CMS\\Model\\SiteTree';
+        $fileClass = 'SilverStripe\\Assets\\File';
+
+        $extraFilters = array($pageClass => '', $fileClass => '');
 
         if ($extraFilter) {
-			$extraFilters['SiteTree'] = " AND $extraFilter";
+            $extraFilters[$pageClass] = " AND $extraFilter";
 
-			if($alternativeFileFilter) $extraFilters['File'] = " AND $alternativeFileFilter";
+            if ($alternativeFileFilter) {
-			else $extraFilters['File'] = $extraFilters['SiteTree'];
+                $extraFilters[$fileClass] = " AND $alternativeFileFilter";
+            } else {
+                $extraFilters[$fileClass] = $extraFilters[$pageClass];
+            }
         }
 
         // Always ensure that only pages with ShowInSearch = 1 can be searched
-		$extraFilters['SiteTree'] .= ' AND ShowInSearch <> 0';
+        $extraFilters[$pageClass] .= ' AND ShowInSearch <> 0';
         // File.ShowInSearch was added later, keep the database driver backwards compatible
         // by checking for its existence first
-		$fields = $this->getSchemaManager()->fieldList('File');
+        if (File::singleton()->getSchema()->fieldSpec(File::class, 'ShowInSearch')) {
-		if(array_key_exists('ShowInSearch', $fields)) {
+            $extraFilters[$fileClass] .= " AND ShowInSearch <> 0";
-			$extraFilters['File'] .= " AND ShowInSearch <> 0";
         }
 
-		$limit = $start . ", " . (int) $pageLength;
+        $limit = $start . ", " . $pageLength;
 
         $notMatch = $invertedMatch ? "NOT " : "";
         if ($keywords) {
-			$match['SiteTree'] = "
+            $match[$pageClass] =
-				(Title LIKE '%$keywords%' OR MenuTitle LIKE '%$keywords%' OR Content LIKE '%$keywords%' OR MetaDescription LIKE '%$keywords%' OR
+                "(Title LIKE '%$keywords%' OR MenuTitle LIKE '%$keywords%' OR Content LIKE '%$keywords%'"
-				Title LIKE '%$htmlEntityKeywords%' OR MenuTitle LIKE '%$htmlEntityKeywords%' OR Content LIKE '%$htmlEntityKeywords%' OR MetaDescription LIKE '%$htmlEntityKeywords%')
+                . " OR MetaDescription LIKE '%$keywords%' OR Title LIKE '%$htmlEntityKeywords%'"
-			";
+                . " OR MenuTitle LIKE '%$htmlEntityKeywords%' OR Content LIKE '%$htmlEntityKeywords%'"
-			$match['File'] = "(Filename LIKE '%$keywords%' OR Title LIKE '%$keywords%' OR Content LIKE '%$keywords%') AND ClassName = 'File'";
+                . " OR MetaDescription LIKE '%$htmlEntityKeywords%')";
+            $fileClassSQL = Convert::raw2sql($fileClass);
+            $match[$fileClass] =
+                "(Name LIKE '%$keywords%' OR Title LIKE '%$keywords%') AND ClassName = '$fileClassSQL'";
 
             // We make the relevance search by converting a boolean mode search into a normal one
             $relevanceKeywords = $keywords;
             $htmlEntityRelevanceKeywords = $htmlEntityKeywords;
-			$relevance['SiteTree'] = "(Title LIKE '%$relevanceKeywords%' OR MenuTitle LIKE '%$relevanceKeywords%' OR Content LIKE '%$relevanceKeywords%' OR MetaDescription LIKE '%$relevanceKeywords%') + (Title LIKE '%$htmlEntityRelevanceKeywords%' OR MenuTitle LIKE '%$htmlEntityRelevanceKeywords%' OR Content LIKE '%$htmlEntityRelevanceKeywords%' OR MetaDescription LIKE '%$htmlEntityRelevanceKeywords%')";
+            $relevance[$pageClass] =
-			$relevance['File'] = "(Filename LIKE '%$relevanceKeywords%' OR Title LIKE '%$relevanceKeywords%' OR Content LIKE '%$relevanceKeywords%')";
+                "(Title LIKE '%$relevanceKeywords%' OR MenuTitle LIKE '%$relevanceKeywords%'"
+                . " OR Content LIKE '%$relevanceKeywords%' OR MetaDescription LIKE '%$relevanceKeywords%')"
+                . " + (Title LIKE '%$htmlEntityRelevanceKeywords%' OR MenuTitle LIKE '%$htmlEntityRelevanceKeywords%'"
+                . " OR Content LIKE '%$htmlEntityRelevanceKeywords%' OR MetaDescription "
+                . " LIKE '%$htmlEntityRelevanceKeywords%')";
+            $relevance[$fileClass] = "(Name LIKE '%$relevanceKeywords%' OR Title LIKE '%$relevanceKeywords%')";
         } else {
-			$relevance['SiteTree'] = $relevance['File'] = 1;
+            $relevance[$pageClass] = $relevance[$fileClass] = 1;
-			$match['SiteTree'] = $match['File'] = "1 = 1";
+            $match[$pageClass] = $match[$fileClass] = "1 = 1";
         }
 
-		// Generate initial queries and base table names
+        // Generate initial queries
-		$baseClasses = array('SiteTree' => '', 'File' => '');
         $queries = array();
         foreach ($classesToSearch as $class) {
-			$queries[$class] = DataList::create($class)->where($notMatch . $match[$class] . $extraFilters[$class], "")->dataQuery()->query();
+            $queries[$class] = DataList::create($class)
-			$fromArr = $queries[$class]->getFrom();
+                ->where($notMatch . $match[$class] . $extraFilters[$class])
-			$baseClasses[$class] = reset($fromArr);
+                ->dataQuery()
+                ->query();
         }
 
         // Make column selection lists
         $select = array(
-			'SiteTree' => array(
+            $pageClass => array(
                 "\"ClassName\"",
                 "\"ID\"",
                 "\"ParentID\"",
@@ -289,35 +386,32 @@ class SQLite3Database extends SS_Database {
                 "\"Content\"",
                 "\"LastEdited\"",
                 "\"Created\"",
-				"NULL AS \"Filename\"",
                 "NULL AS \"Name\"",
                 "\"CanViewType\"",
-				"$relevance[SiteTree] AS Relevance"
+                $relevance[$pageClass] . " AS Relevance"
             ),
-			'File' => array(
+            $fileClass => array(
                 "\"ClassName\"",
                 "\"ID\"",
                 "NULL AS \"ParentID\"",
                 "\"Title\"",
                 "NULL AS \"URLSegment\"",
-				"\"Content\"",
+                "NULL AS \"Content\"",
                 "\"LastEdited\"",
                 "\"Created\"",
-				"\"Filename\"",
                 "\"Name\"",
                 "NULL AS \"CanViewType\"",
-				"$relevance[File] AS Relevance"
+                $relevance[$fileClass] . " AS Relevance"
             )
         );
 
         // Process queries
         foreach ($classesToSearch as $class) {
             // There's no need to do all that joining
-			$queries[$class]->setFrom($baseClasses[$class]);
+            $queries[$class]->setFrom('"'.DataObject::getSchema()->baseDataTable($class).'"');
-
             $queries[$class]->setSelect(array());
             foreach ($select[$class] as $clause) {
-				if(preg_match('/^(.*) +AS +"?([^"]*)"?/i', $clause, $matches)) {
+                if (preg_match('/^(.*) +AS +"?([^"]*)"?/i', $clause ?? '', $matches)) {
                     $queries[$class]->selectField($matches[1], $matches[2]);
                 } else {
                     $queries[$class]->selectField(str_replace('"', '', $clause));
@@ -332,6 +426,7 @@ class SQLite3Database extends SS_Database {
         $queryParameters = array();
         $totalCount = 0;
         foreach ($queries as $query) {
+            /** @var SQLSelect $query */
             $querySQLs[] = $query->sql($parameters);
             $queryParameters = array_merge($queryParameters, $parameters);
             $totalCount += $query->unlimitedRowCount();
@@ -345,11 +440,14 @@ class SQLite3Database extends SS_Database {
             $objects[] = new $record['ClassName']($record);
         }
 
-		if(isset($objects)) $doSet = new ArrayList($objects);
+        if (isset($objects)) {
-		else $doSet = new ArrayList();
+            $doSet = new ArrayList($objects);
+        } else {
+            $doSet = new ArrayList();
+        }
         $list = new PaginatedList($doSet);
         $list->setPageStart($start);
-		$list->setPageLEngth($pageLength);
+        $list->setPageLength($pageLength);
         $list->setTotalItems($totalCount);
         return $list;
     }
@@ -357,48 +455,194 @@ class SQLite3Database extends SS_Database {
     /*
      * Does this database support transactions?
      */
-	public function supportsTransactions(){
+    public function supportsTransactions()
+    {
         return version_compare($this->getVersion(), '3.6', '>=');
     }
 
-	public function supportsExtensions($extensions = array('partitions', 'tablespaces', 'clustering')){
+    /**
-
+     * Does this database support transaction modes?
-		if(isset($extensions['partitions']))
+     *
-			return true;
+     * SQLite doesn't support transaction modes.
-		elseif(isset($extensions['tablespaces']))
+     *
-			return true;
+     * @param string $mode
-		elseif(isset($extensions['clustering']))
+     * @return bool
-			return true;
+     */
-		else
+    public function supportsTransactionMode(string $mode): bool
+    {
         return false;
     }
 
-	public function transactionStart($transaction_mode = false, $session_characteristics = false) {
+    public function supportsExtensions($extensions = array('partitions', 'tablespaces', 'clustering'))
+    {
+        if (isset($extensions['partitions'])) {
+            return true;
+        } elseif (isset($extensions['tablespaces'])) {
+            return true;
+        } elseif (isset($extensions['clustering'])) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public function transactionStart($transaction_mode = false, $session_characteristics = false)
+    {
+        if ($this->transactionDepth()) {
+            $this->transactionSavepoint('NESTEDTRANSACTION' . $this->transactionDepth());
+        } else {
             $this->query('BEGIN');
+            $this->transactionDepthIncrease();
+        }
     }
 
-	public function transactionSavepoint($savepoint) {
+    public function transactionSavepoint($savepoint)
+    {
         $this->query("SAVEPOINT \"$savepoint\"");
+        $this->transactionDepthIncrease($savepoint);
     }
 
-	public function transactionRollback($savepoint = false){
+    /**
+     * Fetch the name of the most recent savepoint
+     *
+     * @return string
+     */
+    protected function getTransactionSavepointName()
+    {
+        return end($this->transactionSavepoints);
+    }
 
+    public function transactionRollback($savepoint = false)
+    {
+        // Named transaction
         if ($savepoint) {
             $this->query("ROLLBACK TO $savepoint;");
+            $this->transactionDepthDecrease();
+            return true;
+        }
+
+        // Fail if transaction isn't available
+        if (!$this->transactionDepth()) {
+            return false;
+        }
+
+        if ($this->transactionIsNested()) {
+            $this->transactionRollback($this->getTransactionSavepointName());
         } else {
             $this->query('ROLLBACK;');
+            $this->transactionDepthDecrease();
         }
+        return true;
     }
 
-	public function transactionEnd($chain = false){
+    public function transactionDepth()
+    {
+        return $this->transactionNesting;
+    }
+
+    public function transactionEnd($chain = false)
+    {
+        // Fail if transaction isn't available
+        if (!$this->transactionDepth()) {
+            return false;
+        }
+
+        if ($this->transactionIsNested()) {
+            $savepoint = $this->getTransactionSavepointName();
+            $this->query('RELEASE ' . $savepoint);
+            $this->transactionDepthDecrease();
+        } else {
             $this->query('COMMIT;');
+            $this->resetTransactionNesting();
         }
 
-	public function clearTable($table) {
+        if ($chain) {
+            $this->transactionStart();
+        }
+
+        return true;
+    }
+
+    /**
+     * Indicate whether or not the current transaction is nested
+     * Returns false if there are no transactions, or the open
+     * transaction is the 'outer' transaction, i.e. not nested.
+     *
+     * @return bool
+     */
+    protected function transactionIsNested()
+    {
+        return $this->transactionNesting > 1;
+    }
+
+    /**
+     * Increase the nested transaction level by one
+     * savepoint tracking is optional because BEGIN
+     * opens a transaction, but is not a named reference
+     *
+     * @param string $savepoint
+     */
+    protected function transactionDepthIncrease($savepoint = null)
+    {
+        ++$this->transactionNesting;
+        if ($savepoint) {
+            array_push($this->transactionSavepoints, $savepoint);
+        }
+    }
+
+    /**
+     * Decrease the nested transaction level by one
+     * and reduce the savepoint tracking if we are
+     * nesting, as the last one is no longer valid
+     */
+    protected function transactionDepthDecrease()
+    {
+        if ($this->transactionIsNested()) {
+            array_pop($this->transactionSavepoints);
+        }
+        --$this->transactionNesting;
+    }
+
+    /**
+     * In error condition, set transactionNesting to zero
+     */
+    protected function resetTransactionNesting()
+    {
+        $this->transactionNesting = 0;
+        $this->transactionSavepoints = [];
+    }
+
+    public function query($sql, $errorLevel = E_USER_ERROR)
+    {
+        return parent::query($sql, $errorLevel);
+    }
+
+    public function preparedQuery($sql, $parameters, $errorLevel = E_USER_ERROR)
+    {
+        return parent::preparedQuery($sql, $parameters, $errorLevel);
+    }
+
+    /**
+     * Inspect a SQL query prior to execution
+     * @deprecated 2.2.0:3.0.0
+     * @param string $sql
+     */
+    protected function inspectQuery($sql)
+    {
+        // no-op
+    }
+
+    public function clearTable($table)
+    {
         $this->query("DELETE FROM \"$table\"");
     }
 
-	public function comparisonClause($field, $value, $exact = false, $negate = false, $caseSensitive = null,
+    public function comparisonClause(
+        $field,
+        $value,
+        $exact = false,
+        $negate = false,
+        $caseSensitive = null,
         $parameterised = false
     ) {
         if ($exact && !$caseSensitive) {
@@ -414,7 +658,9 @@ class SQLite3Database extends SS_Database {
             } else {
                 $comp = 'LIKE';
             }
-			if($negate) $comp = 'NOT ' . $comp;
+            if ($negate) {
+                $comp = 'NOT ' . $comp;
+            }
         }
 
         if ($parameterised) {
@@ -424,9 +670,14 @@ class SQLite3Database extends SS_Database {
         }
     }
 
-	function formattedDatetimeClause($date, $format) {
+    public function formattedDatetimeClause($date, $format)
-		preg_match_all('/%(.)/', $format, $matches);
+    {
-		foreach($matches[1] as $match) if(array_search($match, array('Y','m','d','H','i','s','U')) === false) user_error('formattedDatetimeClause(): unsupported format character %' . $match, E_USER_WARNING);
+        preg_match_all('/%(.)/', $format ?? '', $matches);
+        foreach ($matches[1] as $match) {
+            if (array_search($match, array('Y', 'm', 'd', 'H', 'i', 's', 'U')) === false) {
+                user_error('formattedDatetimeClause(): unsupported format character %' . $match, E_USER_WARNING);
+            }
+        }
 
         $translate = array(
             '/%i/' => '%M',
@@ -436,12 +687,16 @@ class SQLite3Database extends SS_Database {
         $format = preg_replace(array_keys($translate), array_values($translate), $format);
 
         $modifiers = array();
-		if($format == '%s' && $date != 'now') $modifiers[] = 'utc';
+        if ($format == '%s' && $date != 'now') {
-		if($format != '%s' && $date == 'now') $modifiers[] = 'localtime';
+            $modifiers[] = 'utc';
+        }
+        if ($format != '%s' && $date == 'now') {
+            $modifiers[] = 'localtime';
+        }
 
-		if(preg_match('/^now$/i', $date)) {
+        if (preg_match('/^now$/i', $date ?? '')) {
             $date = "'now'";
-		} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date)) {
+        } elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date ?? '')) {
             $date = "'$date'";
         }
 
@@ -449,13 +704,16 @@ class SQLite3Database extends SS_Database {
         return "strftime('$format', $date$modifier)";
     }
 
-	function datetimeIntervalClause($date, $interval) {
+    public function datetimeIntervalClause($date, $interval)
+    {
         $modifiers = array();
-		if($date == 'now') $modifiers[] = 'localtime';
+        if ($date == 'now') {
+            $modifiers[] = 'localtime';
+        }
 
-		if(preg_match('/^now$/i', $date)) {
+        if (preg_match('/^now$/i', $date ?? '')) {
             $date = "'now'";
-		} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date)) {
+        } elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date ?? '')) {
             $date = "'$date'";
         }
 
@@ -463,22 +721,27 @@ class SQLite3Database extends SS_Database {
         return "datetime($date$modifier, '$interval')";
     }
 
-	function datetimeDifferenceClause($date1, $date2) {
+    public function datetimeDifferenceClause($date1, $date2)
+    {
         $modifiers1 = array();
         $modifiers2 = array();
 
-		if($date1 == 'now') $modifiers1[] = 'localtime';
+        if ($date1 == 'now') {
-		if($date2 == 'now') $modifiers2[] = 'localtime';
+            $modifiers1[] = 'localtime';
+        }
+        if ($date2 == 'now') {
+            $modifiers2[] = 'localtime';
+        }
 
-		if(preg_match('/^now$/i', $date1)) {
+        if (preg_match('/^now$/i', $date1 ?? '')) {
             $date1 = "'now'";
-		} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date1)) {
+        } elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date1 ?? '')) {
             $date1 = "'$date1'";
         }
 
-		if(preg_match('/^now$/i', $date2)) {
+        if (preg_match('/^now$/i', $date2 ?? '')) {
             $date2 = "'now'";
-		} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date2)) {
+        } elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date2 ?? '')) {
             $date2 = "'$date2'";
         }
 

code/SQLite3Query.php

@@ -1,11 +1,15 @@
 <?php
 
+namespace SilverStripe\SQLite;
+
+use SilverStripe\ORM\Connect\Query;
+use SQLite3Result;
+
 /**
  * A result-set from a SQLite3 database.
- * 
- * @package SQLite3
  */
-class SQLite3Query extends SS_Query {
+class SQLite3Query extends Query
+{
 
     /**
      * The SQLite3Connector object that created this result set.
@@ -26,33 +30,50 @@ class SQLite3Query extends SS_Query {
      * @param SQLite3Connector $database The database object that created this query.
      * @param SQLite3Result $handle the internal sqlite3 handle that is points to the resultset.
      */
-	public function __construct(SQLite3Connector $database, SQLite3Result $handle) {
+    public function __construct(SQLite3Connector $database, SQLite3Result $handle)
+    {
         $this->database = $database;
         $this->handle = $handle;
     }
 
-	public function __destruct() {
+    public function __destruct()
-		if($this->handle) $this->handle->finalize();
+    {
+        if ($this->handle) {
+            $this->handle->finalize();
+        }
     }
 
-	public function seek($row) {
+    public function seek($row)
+    {
         $this->handle->reset();
         $i=0;
-		while($i < $row && $row = @$this->handle->fetchArray()) $i++;
+        while ($i <= $row && $result = @$this->handle->fetchArray(SQLITE3_ASSOC)) {
-		return true;
+            $i++;
+        }
+        return $result;
     }
 
     /**
      * @todo This looks terrible but there is no SQLite3::get_num_rows() implementation
      */
-	public function numRecords() {
+    public function numRecords()
+    {
+        // Some queries are not iterable using fetchArray like CREATE statement
+        if (!$this->handle->numColumns()) {
+            return 0;
+        }
+        
+        $this->handle->reset();
         $c=0;
-		while($this->handle->fetchArray()) $c++;
+        while ($this->handle->fetchArray()) {
+            $c++;
+        }
         $this->handle->reset();
         return $c;
     }
 
-	public function nextRecord() {
+    public function nextRecord()
+    {
         if ($data = $this->handle->fetchArray(SQLITE3_ASSOC)) {
             return $data;
         } else {

code/SQLite3QueryBuilder.php

@@ -1,18 +1,26 @@
 <?php
 
+namespace SilverStripe\SQLite;
+
+use SilverStripe\ORM\Queries\SQLAssignmentRow;
+use SilverStripe\ORM\Queries\SQLInsert;
+use SilverStripe\ORM\Queries\SQLSelect;
+use SilverStripe\ORM\Connect\DBQueryBuilder;
+use InvalidArgumentException;
+
 /**
  * Builds a SQL query string from a SQLExpression object
- * 
- * @package SQLite3
  */
-class SQLite3QueryBuilder extends DBQueryBuilder {
+class SQLite3QueryBuilder extends DBQueryBuilder
+{
 
     /**
      * @param SQLInsert $query
      * @param array $parameters
      * @return string
      */
-	protected function buildInsertQuery(SQLInsert $query, array &$parameters) {
+    protected function buildInsertQuery(SQLInsert $query, array &$parameters)
+    {
         // Multi-row insert requires SQLite specific syntax prior to 3.7.11
         // For backwards compatibility reasons include the "union all select" syntax
 
@@ -26,6 +34,7 @@ class SQLite3QueryBuilder extends DBQueryBuilder {
         $rowParts = array();
         foreach ($query->getRows() as $row) {
             // Build all columns in this row
+            /** @var SQLAssignmentRow $row */
             $assignments = $row->getAssignments();
             // Join SET components together, considering parameters
             $parts = array();
@@ -59,12 +68,15 @@ class SQLite3QueryBuilder extends DBQueryBuilder {
      * @param array $parameters Out parameter for the resulting query parameters
      * @return string The finalised limit SQL fragment
      */
-	public function buildLimitFragment(SQLSelect $query, array &$parameters) {
+    public function buildLimitFragment(SQLSelect $query, array &$parameters)
+    {
         $nl = $this->getSeparator();
 
         // Ensure limit is given
         $limit = $query->getLimit();
-		if(empty($limit)) return '';
+        if (empty($limit)) {
+            return '';
+        }
 
         // For literal values return this as the limit SQL
         if (! is_array($limit)) {
@@ -90,5 +102,4 @@ class SQLite3QueryBuilder extends DBQueryBuilder {
         }
         return $clause;
     }
-
 }

code/SQLite3SchemaManager.php

@@ -1,11 +1,18 @@
 <?php
 
+namespace SilverStripe\SQLite;
+
+use Exception;
+use SilverStripe\Control\Director;
+use SilverStripe\Dev\Debug;
+use SilverStripe\ORM\Connect\DBSchemaManager;
+use SQLite3;
+
 /**
  * SQLite schema manager class
- * 
- * @package SQLite3
  */
-class SQLite3SchemaManager extends DBSchemaManager {
+class SQLite3SchemaManager extends DBSchemaManager
+{
 
     /**
      * Instance of the database controller this schema belongs to
@@ -28,49 +35,67 @@ class SQLite3SchemaManager extends DBSchemaManager {
      */
     public static $vacuum = true;
 
-	public function createDatabase($name) {
+    public function createDatabase($name)
+    {
         // Ensure that any existing database is cleared before connection
         $this->dropDatabase($name);
     }
 
-	public function dropDatabase($name) {
+    public function dropDatabase($name)
+    {
         // No need to delete database files if operating purely within memory
-		if($this->database->getLivesInMemory()) return;
+        if ($this->database->getLivesInMemory()) {
-		 
+            return;
-		// If using file based database ensure any existing file is removed
-		$parameters = $this->database->getParameters();
-		$fullpath = $parameters['path'] . '/' . $name;
-		if(is_writable($fullpath)) unlink($fullpath);
         }
 
-	function databaseList() {
+        // If using file based database ensure any existing file is removed
-		$parameters = $this->database->getParameters();
+        $path = $this->database->getPath();
+        $fullpath = $path . '/' . $name . SQLite3Database::database_extension();
+        if (is_writable($fullpath)) {
+            unlink($fullpath);
+        }
+    }
 
+    public function databaseList()
+    {
         // If in-memory use the current database name only
         if ($this->database->getLivesInMemory()) {
-			return array($parameters['database']);
+            return array(
+                $this->database->getConnector()->getSelectedDatabase()
+                    ?: 'database'
+            );
         }
 
         // If using file based database enumerate files in the database directory
-		$directory = $parameters['path'];
+        $directory = $this->database->getPath();
         $files = scandir($directory);
 
         // Filter each file in this directory
         $databases = array();
-		if($files !== false) foreach($files as $file) {
+        if ($files !== false) {
-			
+            foreach ($files as $file) {
                 // Filter non-files
-			if(!is_file("$directory/$file")) continue;
+                if (!is_file("$directory/$file")) {
+                    continue;
+                }
 
                 // Filter those with correct extension
-			if(!SQLite3Database::is_valid_database_name($file)) continue;
+                if (!SQLite3Database::is_valid_database_name($file)) {
+                    continue;
+                }
 
+                if ($extension = SQLite3Database::database_extension()) {
+                    $databases[] = substr($file, 0, -strlen($extension));
+                } else {
                     $databases[] = $file;
                 }
+            }
+        }
         return $databases;
     }
 
-	public function databaseExists($name) {
+    public function databaseExists($name)
+    {
         $databases = $this->databaseList();
         return in_array($name, $databases);
     }
@@ -78,11 +103,13 @@ class SQLite3SchemaManager extends DBSchemaManager {
     /**
      * Empties any cached enum values
      */
-	public function flushCache() {
+    public function flushCache()
+    {
         $this->enum_map = array();
     }
 
-	function schemaUpdate($callback) {
+    public function schemaUpdate($callback)
+    {
         // Set locking mode
         $this->database->setPragma('locking_mode', 'EXCLUSIVE');
         $this->checkAndRepairTable();
@@ -99,7 +126,9 @@ class SQLite3SchemaManager extends DBSchemaManager {
         // Revert locking mode
         $this->database->setPragma('locking_mode', SQLite3Database::$default_pragma['locking_mode']);
 
-		if($error) throw $error;
+        if ($error) {
+            throw $error;
+        }
     }
 
     /**
@@ -107,17 +136,25 @@ class SQLite3SchemaManager extends DBSchemaManager {
      *
      * @param string $table
      */
-	public function clearTable($table) {
+    public function clearTable($table)
-		if($table != 'SQLiteEnums') $this->dbConn->query("DELETE FROM \"$table\"");
+    {
+        if ($table != 'SQLiteEnums') {
+            $this->query("DELETE FROM \"$table\"");
+        }
     }
 
-	public function createTable($table, $fields = null, $indexes = null, $options = null, $advancedOptions = null) {
+    public function createTable($table, $fields = null, $indexes = null, $options = null, $advancedOptions = null)
-		if(!isset($fields['ID'])) $fields['ID'] = $this->IdColumn();
+    {
+        if (!isset($fields['ID'])) {
+            $fields['ID'] = $this->IdColumn();
+        }
 
         $fieldSchemata = array();
-		if($fields) foreach($fields as $k => $v) {
+        if ($fields) {
+            foreach ($fields as $k => $v) {
                 $fieldSchemata[] = "\"$k\" $v";
             }
+        }
         $fieldSchemas = implode(",\n", $fieldSchemata);
 
         // Switch to "CREATE TEMPORARY TABLE" for temporary tables
@@ -135,49 +172,67 @@ class SQLite3SchemaManager extends DBSchemaManager {
         return $table;
     }
 
-	public function alterTable($tableName, $newFields = null, $newIndexes = null, $alteredFields = null,
+    public function alterTable(
-		$alteredIndexes = null, $alteredOptions = null, $advancedOptions = null
+        $tableName,
+        $newFields = null,
+        $newIndexes = null,
+        $alteredFields = null,
+        $alteredIndexes = null,
+        $alteredOptions = null,
+        $advancedOptions = null
     ) {
-		if($newFields) foreach($newFields as $fieldName => $fieldSpec) {
+        if ($newFields) {
+            foreach ($newFields as $fieldName => $fieldSpec) {
                 $this->createField($tableName, $fieldName, $fieldSpec);
             }
+        }
 
-		if($alteredFields) foreach($alteredFields as $fieldName => $fieldSpec) {
+        if ($alteredFields) {
+            foreach ($alteredFields as $fieldName => $fieldSpec) {
                 $this->alterField($tableName, $fieldName, $fieldSpec);
             }
-
-		if($newIndexes) foreach($newIndexes as $indexName => $indexSpec) {
-			$this->createIndex($tableName, $indexName, $indexSpec);
         }
 
-		if($alteredIndexes) foreach($alteredIndexes as $indexName => $indexSpec) {
+        if ($newIndexes) {
+            foreach ($newIndexes as $indexName => $indexSpec) {
+                $this->createIndex($tableName, $indexName, $indexSpec);
+            }
+        }
+
+        if ($alteredIndexes) {
+            foreach ($alteredIndexes as $indexName => $indexSpec) {
                 $this->alterIndex($tableName, $indexName, $indexSpec);
             }
         }
+    }
 
-	public function renameTable($oldTableName, $newTableName) {
+    public function renameTable($oldTableName, $newTableName)
+    {
         $this->query("ALTER TABLE \"$oldTableName\" RENAME TO \"$newTableName\"");
     }
 
-	public function checkAndRepairTable($tableName = null) {
+    public function checkAndRepairTable($tableName = null)
+    {
         $ok = true;
 
-		if(!SapphireTest::using_temp_db() && !self::$checked_and_repaired) {
+        if (!self::$checked_and_repaired) {
             $this->alterationMessage("Checking database integrity", "repaired");
 
             // Check for any tables with failed integrity
             if ($messages = $this->query('PRAGMA integrity_check')) {
-				foreach($messages as $message) if($message['integrity_check'] != 'ok') {
+                foreach ($messages as $message) {
+                    if ($message['integrity_check'] != 'ok') {
                         Debug::show($message['integrity_check']);
                         $ok = false;
                     }
                 }
+            }
 
             // If enabled vacuum (clean and rebuild) the database
             if (self::$vacuum) {
                 $this->query('VACUUM', E_USER_NOTICE);
                 $message = $this->database->getConnector()->getLastError();
-				if(preg_match('/authoriz/', $message)) {
+                if (preg_match('/authoriz/', $message ?? '')) {
                     $this->alterationMessage("VACUUM | $message", "error");
                 } else {
                     $this->alterationMessage("VACUUMing", "repaired");
@@ -189,7 +244,8 @@ class SQLite3SchemaManager extends DBSchemaManager {
         return $ok;
     }
 
-	public function createField($table, $field, $spec) {
+    public function createField($table, $field, $spec)
+    {
         $this->query("ALTER TABLE \"$table\" ADD \"$field\" $spec");
     }
 
@@ -199,7 +255,8 @@ class SQLite3SchemaManager extends DBSchemaManager {
      * @param string $fieldName The name of the field to change.
      * @param string $fieldSpec The new field specification
      */
-	public function alterField($tableName, $fieldName, $fieldSpec) {
+    public function alterField($tableName, $fieldName, $fieldSpec)
+    {
         $oldFieldList = $this->fieldList($tableName);
         $fieldNameList = '"' . implode('","', array_keys($oldFieldList)) . '"';
 
@@ -208,7 +265,9 @@ class SQLite3SchemaManager extends DBSchemaManager {
         }
 
         // Skip non-existing columns
-		if(!array_key_exists($fieldName, $oldFieldList)) return;
+        if (!array_key_exists($fieldName, $oldFieldList)) {
+            return;
+        }
 
         // Update field spec
         $newColsSpec = array();
@@ -217,19 +276,22 @@ class SQLite3SchemaManager extends DBSchemaManager {
         }
 
         $queries = array(
-			"BEGIN TRANSACTION",
             "CREATE TABLE \"{$tableName}_alterfield_{$fieldName}\"(" . implode(',', $newColsSpec) . ")",
             "INSERT INTO \"{$tableName}_alterfield_{$fieldName}\" SELECT {$fieldNameList} FROM \"$tableName\"",
             "DROP TABLE \"$tableName\"",
             "ALTER TABLE \"{$tableName}_alterfield_{$fieldName}\" RENAME TO \"$tableName\"",
-			"COMMIT"
         );
 
         // Remember original indexes
         $indexList = $this->indexList($tableName);
 
         // Then alter the table column
-		foreach($queries as $query) $this->query($query.';');
+        $database = $this->database;
+        $database->withTransaction(function () use ($database, $queries, $indexList) {
+            foreach ($queries as $query) {
+                $database->query($query . ';');
+            }
+        });
 
         // Recreate the indexes
         foreach ($indexList as $indexName => $indexSpec) {
@@ -237,11 +299,14 @@ class SQLite3SchemaManager extends DBSchemaManager {
         }
     }
 
-	public function renameField($tableName, $oldName, $newName) {
+    public function renameField($tableName, $oldName, $newName)
+    {
         $oldFieldList = $this->fieldList($tableName);
 
         // Skip non-existing columns
-		if(!array_key_exists($oldName, $oldFieldList)) return;
+        if (!array_key_exists($oldName, $oldFieldList)) {
+            return;
+        }
 
         // Determine column mappings
         $oldCols = array();
@@ -252,39 +317,62 @@ class SQLite3SchemaManager extends DBSchemaManager {
         }
 
         // SQLite doesn't support direct renames through ALTER TABLE
+        $oldColsStr = implode(',', $oldCols);
+        $newColsSpecStr = implode(',', $newColsSpec);
         $queries = array(
-			"BEGIN TRANSACTION",
+            "CREATE TABLE \"{$tableName}_renamefield_{$oldName}\" ({$newColsSpecStr})",
-			"CREATE TABLE \"{$tableName}_renamefield_{$oldName}\" (" . implode(',', $newColsSpec) . ")",
+            "INSERT INTO \"{$tableName}_renamefield_{$oldName}\" SELECT {$oldColsStr} FROM \"$tableName\"",
-			"INSERT INTO \"{$tableName}_renamefield_{$oldName}\" SELECT " . implode(',', $oldCols) . " FROM \"$tableName\"",
             "DROP TABLE \"$tableName\"",
             "ALTER TABLE \"{$tableName}_renamefield_{$oldName}\" RENAME TO \"$tableName\"",
-			"COMMIT"
         );
 
         // Remember original indexes
         $oldIndexList = $this->indexList($tableName);
 
         // Then alter the table column
-		foreach($queries as $query) $this->query($query.';');
+        $database = $this->database;
+        $database->withTransaction(function () use ($database, $queries) {
+            foreach ($queries as $query) {
+                $database->query($query . ';');
+            }
+        });
 
         // Recreate the indexes
         foreach ($oldIndexList as $indexName => $indexSpec) {
-			// Rename columns to new columns
+            // Map index columns
-			$indexSpec['value'] = preg_replace("/\"$oldName\"/i", "\"$newName\"", $indexSpec['value']);
+            $columns = array_filter(array_map(function ($column) use ($newName, $oldName) {
+                // Unchanged
+                if ($column !== $oldName) {
+                    return $column;
+                }
+                // Skip obsolete fields
+                if (stripos($newName, '_obsolete_') === 0) {
+                    return null;
+                }
+                return $newName;
+            }, $indexSpec['columns']));
+
+            // Create index if column count unchanged
+            if (count($columns) === count($indexSpec['columns'])) {
+                $indexSpec['columns'] = $columns;
                 $this->createIndex($tableName, $indexName, $indexSpec);
             }
         }
+    }
 
-	public function fieldList($table) {
+    public function fieldList($table)
+    {
         $sqlCreate = $this->preparedQuery(
-			'SELECT sql FROM sqlite_master WHERE type = ? AND name = ?',
+            'SELECT "sql" FROM "sqlite_master" WHERE "type" = ? AND "name" = ?',
             array('table', $table)
         )->record();
 
         $fieldList = array();
         if ($sqlCreate && $sqlCreate['sql']) {
-			preg_match('/^[\s]*CREATE[\s]+TABLE[\s]+[\'"]?[a-zA-Z0-9_\\\]+[\'"]?[\s]*\((.+)\)[\s]*$/ims',
+            preg_match(
-				$sqlCreate['sql'], $matches
+                '/^[\s]*CREATE[\s]+TABLE[\s]+[\'"]?[a-zA-Z0-9_\\\]+[\'"]?[\s]*\((.+)\)[\s]*$/ims',
+                $sqlCreate['sql'] ?? '',
+                $matches
             );
             $fields = isset($matches[1])
                 ? preg_split('/,(?=(?:[^\'"]*$)|(?:[^\'"]*[\'"][^\'"]*[\'"][^\'"]*)*$)/x', $matches[1])
@@ -306,15 +394,16 @@ class SQLite3SchemaManager extends DBSchemaManager {
      * @param string $indexName The name of the index.
      * @param array $indexSpec The specification of the index, see Database::requireIndex() for more details.
      */
-	public function createIndex($tableName, $indexName, $indexSpec) {
+    public function createIndex($tableName, $indexName, $indexSpec)
-		$parsedSpec = $this->parseIndexSpec($indexName, $indexSpec);
+    {
         $sqliteName = $this->buildSQLiteIndexName($tableName, $indexName);
-		$columns = $parsedSpec['value'];
+        $columns = $this->implodeColumnList($indexSpec['columns']);
-		$unique = ($parsedSpec['type'] == 'unique') ? 'UNIQUE' : '';
+        $unique = ($indexSpec['type'] == 'unique') ? 'UNIQUE' : '';
         $this->query("CREATE $unique INDEX IF NOT EXISTS \"$sqliteName\" ON \"$tableName\" ($columns)");
     }
 
-	public function alterIndex($tableName, $indexName, $indexSpec) {
+    public function alterIndex($tableName, $indexName, $indexSpec)
+    {
         // Drop existing index
         $sqliteName = $this->buildSQLiteIndexName($tableName, $indexName);
         $this->query("DROP INDEX IF EXISTS \"$sqliteName\"");
@@ -333,31 +422,31 @@ class SQLite3SchemaManager extends DBSchemaManager {
      * @param string $indexName
      * @return string The SQLite3 name of the index
      */
-	protected function buildSQLiteIndexName($tableName, $indexName) {
+    protected function buildSQLiteIndexName($tableName, $indexName)
+    {
         return "{$tableName}_{$indexName}";
     }
 
-	protected function parseIndexSpec($name, $spec) {
+    public function indexKey($table, $index, $spec)
-		$spec = parent::parseIndexSpec($name, $spec);
+    {
-		
-		// Only allow index / unique index types
-		if(!in_array($spec['type'], array('index', 'unique'))) {
-			$spec['type'] = 'index';
-		}
-		
-		return $spec;
-	}
-	
-	public function indexKey($table, $index, $spec) {
         return $this->buildSQLiteIndexName($table, $index);
     }
 
-	public function indexList($table) {
+    protected function convertIndexSpec($indexSpec)
+    {
+        $supportedIndexTypes = ['index', 'unique'];
+        if (isset($indexSpec['type']) && !in_array($indexSpec['type'], $supportedIndexTypes)) {
+            $indexSpec['type'] = 'index';
+        }
+        return parent::convertIndexSpec($indexSpec);
+    }
+
+    public function indexList($table)
+    {
         $indexList = array();
 
         // Enumerate each index and related fields
         foreach ($this->query("PRAGMA index_list(\"$table\")") as $index) {
-			
             // The SQLite internal index name, not the actual Silverstripe name
             $indexName = $index["name"];
             $indexType = $index['unique'] ? 'unique' : 'index';
@@ -369,17 +458,18 @@ class SQLite3SchemaManager extends DBSchemaManager {
             }
 
             // Safely encode this spec
-			$indexList[$indexName] = $this->parseIndexSpec($indexName, array(
+            $indexList[$indexName] = array(
                 'name' => $indexName,
-				'value' => $this->implodeColumnList($list),
+                'columns' => $list,
-				'type' => $indexType
+                'type' => $indexType,
-			));
+            );
         }
 
         return $indexList;
     }
 
-	public function tableList() {
+    public function tableList()
+    {
         $tables = array();
         $result = $this->preparedQuery('SELECT name FROM sqlite_master WHERE type = ?', array('table'));
         foreach ($result as $record) {
@@ -392,10 +482,11 @@ class SQLite3SchemaManager extends DBSchemaManager {
     /**
      * Return a boolean type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function boolean($values) {
+    public function boolean($values)
+    {
         $default = empty($values['default']) ? 0 : (int)$values['default'];
         return "BOOL NOT NULL DEFAULT $default";
     }
@@ -403,20 +494,22 @@ class SQLite3SchemaManager extends DBSchemaManager {
     /**
      * Return a date type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function date($values){
+    public function date($values)
+    {
         return "TEXT";
     }
 
     /**
      * Return a decimal type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function decimal($values, $asDbValue = false) {
+    public function decimal($values)
+    {
         $default = isset($values['default']) && is_numeric($values['default']) ? $values['default'] : 0;
         return "NUMERIC NOT NULL DEFAULT $default";
     }
@@ -433,16 +526,19 @@ class SQLite3SchemaManager extends DBSchemaManager {
      *
      * enums are not supported. as a workaround to store allowed values we creates an additional table
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function enum($values){
+    public function enum($values)
+    {
         $tablefield = $values['table'] . '.' . $values['name'];
         $enumValues = implode(',', $values['enums']);
 
         // Ensure the cache table exists
         if (empty($this->enum_map)) {
-			$this->query("CREATE TABLE IF NOT EXISTS \"SQLiteEnums\" (\"TableColumn\" TEXT PRIMARY KEY, \"EnumList\" TEXT)");
+            $this->query(
+                "CREATE TABLE IF NOT EXISTS \"SQLiteEnums\" (\"TableColumn\" TEXT PRIMARY KEY, \"EnumList\" TEXT)"
+            );
         }
 
         // Ensure the table row exists
@@ -456,7 +552,18 @@ class SQLite3SchemaManager extends DBSchemaManager {
 
         // Set default
         if (!empty($values['default'])) {
-			$default = str_replace(array('"',"'","\\","\0"), "", $values['default']);
+            /*
+            On escaping strings:
+
+            https://www.sqlite.org/lang_expr.html
+            "A string constant is formed by enclosing the string in single quotes ('). A single quote within
+            the string can be encoded by putting two single quotes in a row - as in Pascal. C-style escapes
+            using the backslash character are not supported because they are not standard SQL."
+
+            Also, there is a nifty PHP function for this. However apparently one must still be cautious of
+            the null character ('\0' or 0x0), as per https://bugs.php.net/bug.php?id=63419
+            */
+            $default = SQLite3::escapeString(str_replace("\0", "", $values['default']));
             return "TEXT DEFAULT '$default'";
         } else {
             return 'TEXT';
@@ -469,91 +576,100 @@ class SQLite3SchemaManager extends DBSchemaManager {
      *
      * @see SQLite3SchemaManager::enum()
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function set($values) {
+    public function set($values)
+    {
         return $this->enum($values);
     }
 
     /**
      * Return a float type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function float($values, $asDbValue = false){
+    public function float($values)
+    {
         return "REAL";
     }
 
     /**
      * Return a Double type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function double($values, $asDbValue = false){
+    public function double($values)
+    {
         return "REAL";
     }
 
     /**
      * Return a int type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function int($values, $asDbValue = false){
+    public function int($values)
+    {
         return "INTEGER({$values['precision']}) " . strtoupper($values['null']) . " DEFAULT " . (int)$values['default'];
     }
 
     /**
      * Return a bigint type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function bigint($values, $asDbValue = false){
+    public function bigint($values)
-		return $this->int($values, $asDbValue);
+    {
+        return $this->int($values);
     }
 
     /**
      * Return a datetime type-formatted string
      * For SQLite3, we simply return the word 'TEXT', no other parameters are necessary
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function ss_datetime($values, $asDbValue = false) {
+    public function datetime($values)
+    {
         return "DATETIME";
     }
 
     /**
      * Return a text type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function text($values, $asDbValue = false) {
+    public function text($values)
+    {
         return 'TEXT';
     }
 
     /**
      * Return a time type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function time($values) {
+    public function time($values)
+    {
         return "TEXT";
     }
 
     /**
      * Return a varchar type-formatted string
      *
-	 * @params array $values Contains a tokenised list of info about this data type
+     * @param array $values Contains a tokenised list of info about this data type
      * @return string
      */
-	public function varchar($values, $asDbValue = false) {
+    public function varchar($values)
+    {
         return "VARCHAR({$values['precision']}) COLLATE NOCASE";
     }
 
@@ -561,17 +677,20 @@ class SQLite3SchemaManager extends DBSchemaManager {
      * Return a 4 digit numeric type.  MySQL has a proprietary 'Year' type.
      * For SQLite3 we use TEXT
      */
-	public function year($values, $asDbValue = false){
+    public function year($values, $asDbValue = false)
+    {
         return "TEXT";
     }
 
-	public function IdColumn($asDbValue = false, $hasAutoIncPK = true){
+    public function IdColumn($asDbValue = false, $hasAutoIncPK = true)
+    {
         return 'INTEGER PRIMARY KEY AUTOINCREMENT';
     }
 
-	function hasTable($tableName) {
+    public function hasTable($tableName)
+    {
         return (bool)$this->preparedQuery(
-			'SELECT name FROM sqlite_master WHERE type = ? AND name = ?',
+            'SELECT "name" FROM "sqlite_master" WHERE "type" = ? AND "name" = ?',
             array('table', $tableName)
         )->first();
     }
@@ -579,9 +698,12 @@ class SQLite3SchemaManager extends DBSchemaManager {
     /**
      * Return enum values for the given field
      *
+     * @param string $tableName
+     * @param string $fieldName
      * @return array
      */
-	public function enumValuesForField($tableName, $fieldName) {
+    public function enumValuesForField($tableName, $fieldName)
+    {
         $tablefield = "$tableName.$fieldName";
 
         // Check already cached values for this field
@@ -604,12 +726,16 @@ class SQLite3SchemaManager extends DBSchemaManager {
         return array();
     }
 
-	function dbDataType($type){
+    public function dbDataType($type)
+    {
         $values = array(
             'unsigned integer' => 'INT'
         );
 
-		if(isset($values[$type])) return $values[$type];
+        if (isset($values[$type])) {
-		else return '';
+            return $values[$type];
+        } else {
+            return '';
+        }
     }
 }

code/SQLiteDatabaseConfigurationHelper.php

@@ -1,23 +1,32 @@
 <?php
 
+namespace SilverStripe\SQLite;
+
+use SilverStripe\Dev\Install\DatabaseAdapterRegistry;
+use SilverStripe\Dev\Install\DatabaseConfigurationHelper;
+use SQLite3;
+use PDO;
+use Exception;
+
 /**
  * This is a helper class for the SS installer.
  *
  * It does all the specific checking for SQLiteDatabase
  * to ensure that the configuration is setup correctly.
- * 
- * @package SQLite3
  */
-class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
+class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper
+{
 
     /**
      * Create a connection of the appropriate type
      *
+     * @skipUpgrade
      * @param array $databaseConfig
      * @param string $error Error message passed by value
      * @return mixed|null Either the connection object, or null if error
      */
-	protected function createConnection($databaseConfig, &$error) {
+    protected function createConnection($databaseConfig, &$error)
+    {
         $error = null;
         try {
             if (!file_exists($databaseConfig['path'])) {
@@ -32,7 +41,11 @@ class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
                     if (empty($databaseConfig['key'])) {
                         $conn = @new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE);
                     } else {
-						$conn = @new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, $databaseConfig['key']);
+                        $conn = @new SQLite3(
+                            $file,
+                            SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE,
+                            $databaseConfig['key']
+                        );
                     }
                     break;
                 case 'SQLite3PDODatabase':
@@ -40,7 +53,7 @@ class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
                     $conn = @new PDO("sqlite:$file");
                     break;
                 default:
-					$error = 'Invalid connection type';
+                    $error = 'Invalid connection type: ' . $databaseConfig['type'];
                     return null;
             }
 
@@ -56,12 +69,14 @@ class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
         }
     }
 
-	public function requireDatabaseFunctions($databaseConfig) {
+    public function requireDatabaseFunctions($databaseConfig)
+    {
         $data = DatabaseAdapterRegistry::get_adapter($databaseConfig['type']);
         return !empty($data['supported']);
     }
 
-	public function requireDatabaseServer($databaseConfig) {
+    public function requireDatabaseServer($databaseConfig)
+    {
         $path = $databaseConfig['path'];
         $error = '';
         $success = false;
@@ -90,29 +105,38 @@ class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
      * @param array $databaseConfig Associative array of db configuration, e.g. "type", "path" etc
      * @return array Result - e.g. array('success' => true, 'error' => 'details of error')
      */
-	public function requireDatabaseConnection($databaseConfig) {
+    public function requireDatabaseConnection($databaseConfig)
+    {
         // Do additional validation around file paths
-		if(empty($databaseConfig['path'])) return array(
+        if (empty($databaseConfig['path'])) {
+            return array(
                 'success' => false,
                 'error' => "Missing directory path"
             );
-		if(empty($databaseConfig['database'])) return array(
+        }
+        if (empty($databaseConfig['database'])) {
+            return array(
                 'success' => false,
                 'error' => "Missing database filename"
             );
+        }
 
         // Create and secure db directory
         $path = $databaseConfig['path'];
         $dirCreated = self::create_db_dir($path);
-		if(!$dirCreated) return array(
+        if (!$dirCreated) {
+            return array(
                 'success' => false,
                 'error' => sprintf('Cannot create path: "%s"', $path)
             );
+        }
         $dirSecured = self::secure_db_dir($path);
-		if(!$dirSecured) return array(
+        if (!$dirSecured) {
+            return array(
                 'success' => false,
                 'error' => sprintf('Cannot secure path through .htaccess: "%s"', $path)
             );
+        }
 
         $conn = $this->createConnection($databaseConfig, $error);
         $success = !empty($conn);
@@ -124,9 +148,11 @@ class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
         );
     }
 
-	public function getDatabaseVersion($databaseConfig) {
+    public function getDatabaseVersion($databaseConfig)
+    {
         $version = 0;
 
+        /** @skipUpgrade */
         switch ($databaseConfig['type']) {
             case 'SQLite3Database':
                 $info = SQLite3::version();
@@ -144,7 +170,8 @@ class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
         return $version;
     }
 
-	public function requireDatabaseVersion($databaseConfig) {
+    public function requireDatabaseVersion($databaseConfig)
+    {
         $success = false;
         $error = '';
         $version = $this->getDatabaseVersion($databaseConfig);
@@ -162,7 +189,8 @@ class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
         );
     }
 
-	public function requireDatabaseOrCreatePermissions($databaseConfig) {
+    public function requireDatabaseOrCreatePermissions($databaseConfig)
+    {
         $conn = $this->createConnection($databaseConfig, $error);
         $success = $alreadyExists = !empty($conn);
         return array(
@@ -179,7 +207,8 @@ class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
      * @param String $path Absolute path, usually with a hidden folder.
      * @return boolean
      */
-	public static function create_db_dir($path) {
+    public static function create_db_dir($path)
+    {
         return file_exists($path) || mkdir($path);
     }
 
@@ -193,11 +222,13 @@ class SQLiteDatabaseConfigurationHelper implements DatabaseConfigurationHelper {
      * @param String $path Absolute path, containing a SQLite datatbase
      * @return boolean
      */
-	public static function secure_db_dir($path) {
+    public static function secure_db_dir($path)
+    {
         return (is_writeable($path)) ? file_put_contents($path . '/.htaccess', 'deny from all') : false;
     }
 
-	public function requireDatabaseAlterPermissions($databaseConfig) {
+    public function requireDatabaseAlterPermissions($databaseConfig)
+    {
         // no concept of table-specific permissions; If you can connect you can alter schema
         return array(
             'success' => true,

composer.json

@@ -1,7 +1,7 @@
 {
 	"name": "silverstripe/sqlite3",
 	"description": "Adds SQLite3 support to SilverStripe",
-	"type": "silverstripe-module",
+	"type": "silverstripe-vendormodule",
 	"keywords": ["silverstripe", "sqlite3", "database"],
 	"authors": [
 		{
@@ -14,11 +14,21 @@
 		}
 	],
 	"require": {
-		"silverstripe/framework": "^3.2.0"
+		"silverstripe/framework": "~4.0",
+		"silverstripe/vendor-plugin": "^1.0"
 	},
-	"extra": {
+	"require-dev": {
-		"branch-alias": {
+		"squizlabs/php_codesniffer": "^3"
-			"dev-master": "1.4.x-dev"
+	},
-		}
+	"autoload": {
+		"psr-4": {
+			"SilverStripe\\SQLite\\": "code/"
 		}
+	},
+    "scripts": {
+        "lint": "phpcs code/ *.php",
+        "lint-clean": "phpcbf code/ *.php"
+    },
+    "minimum-stability": "dev",
+    "prefer-stable": true
 }

phpcs.xml.dist

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ruleset name="SilverStripe">
+    <description>CodeSniffer ruleset for SilverStripe coding conventions.</description>
+
+    <file>code</file>
+
+    <!-- base rules are PSR-2 -->
+    <rule ref="PSR2" >
+        <!-- Current exclusions -->
+        <exclude name="PSR1.Methods.CamelCapsMethodName" />
+    </rule>
+</ruleset>