Compare commits

...

90 Commits
1.4.0 ... 2

Author SHA1 Message Date
Steve Boyd df532bb741
MNT Use gha-dispatch-ci (#71) 2023-03-20 16:31:41 +13:00
Will Rossiter 1a87b18e71
fix: remove deprecated function 2023-01-24 20:04:50 +13:00
Guy Sartorelli ee7f0e4d25
Merge pull request #65 from lekoala/patch-1
prevent php 8 complaining about null values
2022-09-06 15:59:32 +12:00
Thomas Portelange 66c1c09b74
switch back to null
users are expected to use ?? '' if needed
2022-08-31 09:00:08 +02:00
Thomas Portelange d3d03d9f79
Update code/SQLite3Connector.php
Co-authored-by: Guy Sartorelli <36352093+GuySartorelli@users.noreply.github.com>
2022-08-31 08:58:48 +02:00
Guy Sartorelli f949becc6a
Merge branch '2.1' into 2 2022-08-31 12:58:44 +12:00
Thomas Portelange ecaadc029e
Enforce proper type
Otherwise it may fail when passed to preg_match

Deprecated: preg_match(): Passing null to parameter #2 ($subject) of type string is deprecated
2022-08-19 15:07:23 +02:00
Thomas Portelange 05abb3f483
prevent php 8 complaining about null values
Fix Deprecated: SQLite3::escapeString(): Passing null to parameter #1 ($string) of type string is deprecated
2022-08-19 15:04:48 +02:00
Guy Sartorelli f102cad3bf
Merge pull request #64 from creative-commoners/pulls/2.1/phpcs
MNT Add codesniffer
2022-08-05 14:48:24 +12:00
Steve Boyd d142dd77e4 MNT Add codesniffer 2022-08-05 12:33:00 +12:00
Steve Boyd a919f8a317 Merge branch '2.1' into 2 2022-08-02 19:11:46 +12:00
Steve Boyd ea06c57cfb Merge branch '2.0' into 2.1 2022-08-02 19:11:02 +12:00
Guy Sartorelli d399c27722
Merge pull request #63 from creative-commoners/pulls/2.0/standardise-modules
MNT Standardise modules
2022-08-02 16:18:19 +12:00
Steve Boyd bf07381fc9 MNT Standardise modules 2022-08-01 16:23:18 +12:00
Guy Sartorelli 2ba8fe5c50
Merge pull request #61 from elliot-sawyer/compat/8.1
PHP 8.1 compatibility
2022-07-25 12:12:09 +12:00
Elliot Sawyer f9dfa9f34c PHP 8.1 compatibility 2022-07-20 19:17:01 +12:00
Sam Minnée c95b0105f5
Merge pull request #60 from chrometoasters/pulls/transaction-mode-not-supported
Override transaction mode support check method
2019-09-25 10:03:09 +12:00
Michal Kleiner 22d46a5ef8 Override transaction mode support check method as these are not supported by SQLite 2019-09-16 14:50:16 +12:00
Robbie Averill 10c85d4179 Merge branch '2.1' into 2 2019-01-09 09:35:00 +01:00
Robbie Averill b5a6416388 Merge branch '2.0' into 2.1 2019-01-09 09:34:48 +01:00
Robbie Averill 4edf7c23f8
Merge pull request #58 from mark-cameron/issue_57_upgrade_connectors_yml_file
Added quotes to values in connectors.yml
2019-01-09 09:33:59 +01:00
Mark Cameron 3c8a06f5b9 Added quotes to values in connectors.yml 2019-01-09 00:17:49 +01:00
Robbie Averill 34a3221097
Merge pull request #52 from silverstripe/features/better-travis-matrix
FIX: Better travis matrix
2018-10-19 11:26:10 +02:00
Sam Minnee 1589089f5b FIX: Better travis matrix
- Test PHP 7.2 and 7.3
 - Test against all 4.x minor releases
2018-10-19 14:21:42 +13:00
Sam Minnée e919bdffd9
Correct travis badge 2018-10-19 11:54:37 +13:00
Maxime Rainville 40b9e876ba
Merge pull request #51 from NightJar/tighten-transactions
FIX Tighten transactions
2018-10-19 10:47:46 +13:00
NightjarNZ c2569099ce correct @deprecated docblock to be Draft PSR-5 compliant 2018-10-18 22:12:06 +13:00
NightjarNZ 5eacbe7842 FIX convert index definitions to reflect actual support
It is not uncommon for an index to be defined as e.g. 'fulltext'
which SQLite3 does not support without a module to create a
virtual table (rather than an index on an existing one). The code
already in place sees that definitions be updated to 'index' on
the fly during creation and later inspection (indexList) - which
causes issue when comparing existing table definitions to what
SilverStripe expects by DataObject configuration. This discrepency
leads to tables constantly being marked to update, although
effectively nothing actually changes. We can save these CPU cycles
and a bit of head scratching by converting to a supported index type.
2018-10-16 21:57:51 +13:00
Maxime Rainville 7add192ebf
Merge pull request #50 from NightJar/escape-enum-default-death
FIX preserve enum values with correct escaping
2018-10-12 14:37:08 +13:00
NightjarNZ 0fa6b0fde7 FIX transaction depth related errors with invalid savepoint names
The logic for cancelling a savepoint was incorrect, as the behaviour
the logic was modelled on was for a different RDBMS - where a COMMIT
would always close the most recently opened transaction.

SQLite on contrast will commit the entire transaction, not just the
most recent savepoint marker until current execution point. The correct
manner to deal with a 'partial' commit is to call RELEASE <savepoint>.

This revealed an error in the savepoint logic, in that if someone had
supplied a savepoint name instead of relying on generated ones, the
rollback command did not factor for this and always assumed generated
savepoint names - again causing error. For this reason a new class
member field has been introduced to track savepoint names in a stack
fashion.
2018-10-11 22:07:23 +13:00
NightjarNZ 62ef14f711 FIX correct nesting level mismatches causing errors
Transactions that used more than one level would cause errors if
there were consecutive calls to start a transaction - because each
query executed would clear the flag indicating that a transaction
was already in progress.

The comment for the logic to reset the nesting level on a query was
indicating that DDL (data definition language) would not work within
a transaction. This is untrue, and the module itself uses a transaction
to alter table or field names. So this function has been converted to
a no-op, deprecated to be removed in version 3 of this module. It is
also no longer called upon each query.

There have been some maintenance tidyups around this area also by
abstracting the nested transaction flag manipulations into protected
functions.
2018-10-11 00:02:12 +13:00
NightjarNZ 0efd40e5c2 FIX correct handwritten logic for transactions to use new API instead
Code in the field alteration logic had a queries defiend as strings to
begin and commit transactions involve with changing table or column names.
This was causing fatal errors as BEGIN is not a valid keyword within
a trasaction (see SQLite documentation excerpt below).

A new api has been introduced to deal with transactions programmatically,
and this module was updated to support this a few months ago. This is a
tidy up of some missed portions - consuming this API which correctly uses
SAVEPOINT when a nested transaction is required automatically.

https://www.sqlite.org/lang_transaction.html
Transactions created using BEGIN...COMMIT do not nest. For nested
transactions, use the SAVEPOINT and RELEASE commands.
2018-10-09 22:22:53 +13:00
NightjarNZ 418c1178a1 FIX preserve enum values with correct escaping
Enum values are themselves enumerated in sqlite as they are not supported
as a type. This leads to values being stored in their own table, and a
regular TEXT field being used in a MySQL ENUM's stead. The default value
for this field was being escaped with custom string replacement, and
erroneously relacing the backslash (a redundant operation). This lead
to invalid Fully Qualified Class Names in SilverStripe 4, which is a
required trait for polymorphic relationships. As a result any polymorphic
relationship not set on first write would then proceed to cause an execution
error the next time the dataobject with the relationship was fetched from
the database. By using the PHP supplied escape function for SQLite3 we can
avoid this, and restore functionality.

Relevant section of SQLite documentation to justify the removal of escaping
various characters, such as the backslash:

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.

https://www.sqlite.org/lang_expr.html
2018-10-08 23:09:24 +13:00
Daniel Hensby 4167d9fd1a FIX Make sure nested transactions get reset on implicit commits 2018-07-05 15:31:05 +12:00
Damian Mooyman 6432ceea0d
Merge pull request #46 from creative-commoners/pulls/master/add-supported-module-badge
Add supported module badge to readme
2018-06-18 10:14:43 +12:00
Dylan Wagstaff d315c61ea0 Add supported module badge to readme 2018-06-15 17:49:06 +12:00
Damian Mooyman c346e64590
Merge pull request #43 from lekoala/patch-1
return 0 for non iterable results
2018-04-16 09:08:06 +12:00
Damian Mooyman a38ab53e33
Merge pull request #39 from dhensby/pulls/2.0/nested-transactions
FIX Add nested transaction support
2018-03-13 09:25:09 +13:00
Thomas Portelange 978c371820
return 0 for non iterable results
If there are no columns, it's not a iterable result set and we can return 0. This fixes issues with things like CREATE statement.
2018-03-12 14:04:43 +01:00
Daniel Hensby b36f3598bb
Merge pull request #40 from mikenz/patch-2
Missing 'n'
2018-02-13 10:50:27 +00:00
Mike Cochrane 34648b9c05
Missing 'n' 2018-02-13 14:18:48 +13:00
Daniel Hensby f176bb0a39
FIX Add nested transaction support 2018-02-09 11:24:35 +00:00
Damian Mooyman 0e6aa26f55
Merge remote-tracking branch 'origin/2.1' into 2 2017-12-07 16:18:39 +13:00
Damian Mooyman 9b00630616
Merge remote-tracking branch 'origin/2.0' into 2.1
# Conflicts:
#	code/SQLite3Database.php
#	code/SQLiteDatabaseConfigurationHelper.php
2017-12-07 16:18:19 +13:00
Damian Mooyman e8f4e55b8a
Merge remote-tracking branch 'origin/1.4' into 2.0
# Conflicts:
#	.travis.yml
#	code/SQLite3Database.php
#	composer.json
2017-12-07 16:16:11 +13:00
Damian Mooyman 2bde2640c3
Merge pull request #1 from silverstripe-security/patch/1.4/SS-2017-008
[SS-2017-008] Fix SQL injection in search engine
2017-12-07 15:59:01 +13:00
Damian Mooyman ca4a76eaab
Update 2 branch alias to 2.2 2017-11-28 10:50:04 +13:00
Damian Mooyman 77e5a5e18c
Merge branch '2.1' into 2 2017-11-28 10:49:33 +13:00
Damian Mooyman dbf10488ee
Remove master branch alias from 2.1 branch 2017-11-28 10:49:05 +13:00
Daniel Hensby 978a5a19ce
Merge pull request #37 from open-sausages/pulls/4.0/update-styles
Update config / code styles for 4.0
2017-11-23 12:50:04 +00:00
Damian Mooyman 24cf40beaf
Update config / code styles for 4.0
Related https://github.com/silverstripe/silverstripe-framework/issues/7590
2017-11-23 14:11:10 +13:00
Daniel Hensby 4aad42c084
[SS-2017-008] Fix SQL injection in search engine 2017-11-21 16:16:32 +00:00
Damian Mooyman acaaf95d22 Merge pull request #35 from dhensby/pulls/db-index-update
Update module to work with new stricter index definitions
2017-10-12 14:03:50 +13:00
Daniel Hensby c00a11cf7e
Travis setup 2017-10-10 15:10:30 +01:00
Daniel Hensby 536ada309e
Update module to work with new stricter index definitions 2017-10-10 13:09:06 +01:00
Damian Mooyman 8d25343c41 Merge pull request #32 from open-sausages/pulls/2/vendorise-me-baby
Expose as vendor module
2017-10-03 16:17:05 +13:00
Ingo Schommer eba3c2c746 Expose as vendor module 2017-10-03 03:12:27 +13:00
Daniel Hensby 4e854b3fd2 Merge pull request #30 from kinglozzer/fix-seek
FIX: SQLite3Query::seek() failed to return a record
2017-01-13 11:56:18 +00:00
Loz Calver 0a646577fe FIX: SQLite3Query::seek() failed to return a record 2017-01-12 17:08:05 +00:00
Damian Mooyman 47d47ab2a8 Bump alias of master to 2.1 2016-11-13 21:57:58 +13:00
Damian Mooyman 7304708fa1 BUG Fix installer for 4.0 (#29) 2016-10-26 14:24:31 +13:00
Loz Calver cfdf20b253 Merge pull request #28 from mikenz/patch-1
Update for latest SS4 changes
2016-10-10 09:05:52 +01:00
Mike Cochrane dd81faac7b Update for latest SS4 changes 2016-10-10 11:13:18 +13:00
Daniel Hensby 360b70aa22 Merge pull request #27 from open-sausages/pulls/4.0/fix-path-warnings
BUG Fix errors when 'path' isn't declared explicitly
2016-09-30 12:24:10 +01:00
Damian Mooyman 6d74fc05cf
BUG Fix errors when 'path' isn't declared explicitly 2016-09-30 15:45:13 +13:00
Damian Mooyman b710ef04b3 Rename SS_ prefixed classes (#26) 2016-09-09 15:46:48 +12:00
Ingo Schommer 8001e69b71 Merge pull request #25 from open-sausages/pulls/4.0/namespace-everything
Upgrade for silverstripe namespaces
2016-09-08 16:11:21 +12:00
Damian Mooyman 1cb63311d8
Upgrade for silverstripe namespaces 2016-09-08 15:41:17 +12:00
Ingo Schommer 32ae8f8d94 Merge pull request #24 from open-sausages/pulls/4.0/namespace-cms
Update for SilverStripe\CMS namespace
2016-08-12 16:39:36 +12:00
Damian Mooyman 99e6081c42
Update for SilverStripe\CMS namespace 2016-08-12 13:22:58 +12:00
Damian Mooyman 72638cf40e BUG Fix incorrect upgrade / rules 2016-07-05 16:27:01 +12:00
Ingo Schommer d09ab6bea4 Merge pull request #23 from open-sausages/pulls/4.0/namespace
API Apply SilverStripe\SQLite namespace to module
2016-07-01 15:10:06 +12:00
Damian Mooyman e36e74ab2f API Apply SilverStripe\SQLite namespace to module 2016-06-29 13:55:45 +12:00
Damian Mooyman 0bd28649f5 Merge pull request #21 from dhensby/pulls/2.0/travis-fix
Update travis for 4.0 tests
2016-03-24 11:57:08 +13:00
Damian Mooyman df303356cd Merge pull request #19 from helpfulrobot/add-standard-scrutinizer-config
Added standard Scrutinizer config
2016-03-24 11:52:54 +13:00
Loz Calver 149d1708b6 Merge pull request #20 from dhensby/pulls/1.4/travis
Update travis test coverage
2016-03-23 13:50:28 +00:00
Daniel Hensby 8a4e3434bc Update travis for 4.0 tests 2016-03-23 12:48:55 +00:00
Daniel Hensby ea1d504617 Update travis test coverage 2016-03-23 11:37:24 +00:00
helpfulrobot c77a73e970 Added standard Scrutinizer config 2016-03-23 23:18:23 +13:00
Daniel Hensby 7cf13c1808 Merge pull request #18 from helpfulrobot/add-standard-code-of-conduct-file
Added standard code of conduct file
2016-02-16 09:44:36 +00:00
helpfulrobot f7ef5f16de Added standard code of conduct file 2016-02-16 11:42:22 +13:00
Ingo Schommer 9780bb014c Merge pull request #17 from silverstripe-labs/pulls/fix-tests
BUG Fix .travis.yml
2016-01-18 15:54:26 +13:00
Damian Mooyman c95cbcdc01 BUG Fix .travis.yml 2016-01-18 15:28:10 +13:00
Damian Mooyman 941fc9d857 Merge pull request #16 from helpfulrobot/add-standard-gitattributes-file
Added standard .gitattributes file
2016-01-18 15:25:37 +13:00
helpfulrobot 0c0dceacac Added standard .gitattributes file 2016-01-16 19:32:49 +13:00
Damian Mooyman 608458ccb8 Merge pull request #15 from helpfulrobot/convert-to-psr-2
Converted to PSR-2
2015-12-18 10:05:28 +13:00
helpfulrobot b2d40ed61e Converted to PSR-2 2015-12-18 07:11:01 +13:00
Damian Mooyman 7daf437e24 Merge pull request #14 from helpfulrobot/add-standard-editorconfig-file
Added standard .editorconfig file
2015-12-17 14:07:08 +13:00
helpfulrobot 4b6dcd8dde Added standard .editorconfig file 2015-12-17 10:06:47 +13:00
Damian Mooyman e76bd4b1a1 API Update master to new major version for 4.0 compat 2015-10-16 11:17:24 +13:00
22 changed files with 2168 additions and 1611 deletions

17
.editorconfig Normal file
View File

@ -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

1
.gitattributes vendored Normal file
View File

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

11
.github/workflows/ci.yml vendored Normal file
View File

@ -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

16
.github/workflows/dispatch-ci.yml vendored Normal file
View File

@ -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

17
.github/workflows/keepalive.yml vendored Normal file
View File

@ -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

View File

@ -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

7
.upgrade.yml Normal file
View File

@ -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

View File

@ -1,6 +1,7 @@
# SQLite3 Module # 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 ## Maintainer Contact
@ -9,26 +10,23 @@ Andreas Piening (Nickname: apiening)
## Requirements ## Requirements
* SilverStripe 3.2 or newer * Silverstripe 4.0 or newer
## Installation ## 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 ## Configuration
Either use the installer to automatically install SQLite or add this to your _config.php (right after 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) "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"; $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 Make sure the webserver has sufficient privileges to write to that folder and that it is protected from
external access. external access.
### Sample mysite/_config.php ### Sample mysite/_config.php
```php ```php
@ -42,18 +40,14 @@ $database = 'SS_mysite';
require_once("conf/ConfigureFromEnv.php"); require_once("conf/ConfigureFromEnv.php");
global $databaseConfig; global $databaseConfig;
$databaseConfig = array( $databaseConfig = array(
"type" => 'SQLiteDatabase', "type" => 'SQLite3Database',
"server" => 'none', "server" => 'none',
"username" => 'none', "username" => 'none',
"password" => 'none', "password" => 'none',
"database" => $database, "database" => $database,
"path" => "/path/to/my/database/file", "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/, Again: make sure that the webserver has permission to read and write to the above path (/path/to/my/database/,

View File

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

View File

@ -1,29 +1,36 @@
--- ---
name: sqlite3connectors name: sqlite3connectors
--- ---
Injector: SilverStripe\Core\Injector\Injector:
SQLite3PDODatabase: SQLite3PDODatabase:
class: 'SQLite3Database' class: SilverStripe\SQLite\SQLite3Database
properties: properties:
connector: %$PDOConnector connector: '%$PDOConnector'
schemaManager: %$SQLite3SchemaManager schemaManager: '%$SQLite3SchemaManager'
queryBuilder: %$SQLite3QueryBuilder queryBuilder: '%$SQLite3QueryBuilder'
SQLite3Database: SQLite3Database:
class: 'SQLite3Database' class: SilverStripe\SQLite\SQLite3Database
properties: properties:
connector: %$SQLite3Connector connector: '%$SQLite3Connector'
schemaManager: %$SQLite3SchemaManager schemaManager: '%$SQLite3SchemaManager'
queryBuilder: %$SQLite3QueryBuilder queryBuilder: '%$SQLite3QueryBuilder'
# Legacy connector names # Legacy connector names
SQLiteDatabase: SQLiteDatabase:
class: 'SQLite3Database' class: SilverStripe\SQLite\SQLite3Database
properties: properties:
connector: %$SQLite3Connector connector: '%$SQLite3Connector'
schemaManager: %$SQLite3SchemaManager schemaManager: '%$SQLite3SchemaManager'
queryBuilder: %$SQLite3QueryBuilder queryBuilder: '%$SQLite3QueryBuilder'
SQLitePDODatabase: SQLitePDODatabase:
class: 'SQLite3Database' class: SilverStripe\SQLite\SQLite3Database
properties: 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

View File

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

View File

@ -1,14 +1,25 @@
<?php <?php
// Script called from ConfigureFromEnv.php // Called from DatabaseAdapterRegistry::autoconfigure($config)
global $databaseConfig; use SilverStripe\Core\Environment;
if(strpos($databaseConfig['type'], 'SQLite') === 0) { use SilverStripe\SQLite\SQLite3Database;
if(defined('SS_SQLITE_DATABASE_PATH')) { if (!isset($databaseConfig)) {
$databaseConfig['path'] = SS_SQLITE_DATABASE_PATH; global $databaseConfig;
} }
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);
} }

View File

@ -1,45 +1,54 @@
<?php <?php
use SilverStripe\Dev\Install\DatabaseAdapterRegistry;
use SilverStripe\SQLite\SQLiteDatabaseConfigurationHelper;
$sqliteDatabaseAdapterRegistryFields = array( $sqliteDatabaseAdapterRegistryFields = array(
'path' => array( 'path' => array(
'title' => 'Directory path<br /><small>Absolute path to directory, writeable by the webserver user.<br />' 'title' => 'Directory path<br /><small>Absolute path to directory, writeable by the webserver user.<br />'
. 'Recommended to be outside of your webroot</small>', . 'Recommended to be outside of your webroot</small>',
'default' => dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . 'assets' . DIRECTORY_SEPARATOR . '.sqlitedb' 'default' => dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . 'assets' . DIRECTORY_SEPARATOR . '.sqlitedb'
), ),
'database' => array( 'database' => array(
'title' => 'Database filename (extension .sqlite)', 'title' => 'Database filename (extension .sqlite)',
'default' => 'database.sqlite' 'default' => 'database.sqlite'
) )
); );
// Basic SQLLite3 Database // Basic SQLLite3 Database
/** @skipUpgrade */
DatabaseAdapterRegistry::register( DatabaseAdapterRegistry::register(
array( array(
'class' => 'SQLite3Database', 'class' => 'SQLite3Database',
'title' => 'SQLite 3.3+ (using SQLite3)', 'module' => 'sqlite3',
'helperPath' => dirname(__FILE__).'/code/SQLiteDatabaseConfigurationHelper.php', 'title' => 'SQLite 3.3+ (using SQLite3)',
'supported' => class_exists('SQLite3'), 'helperPath' => __DIR__.'/code/SQLiteDatabaseConfigurationHelper.php',
'missingExtensionText' => 'The <a href="http://php.net/manual/en/book.sqlite3.php">SQLite3</a> '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.', PHP Extension is not available. Please install or enable it of them and refresh this page.',
'fields' => array_merge($sqliteDatabaseAdapterRegistryFields, array('key' => array( 'fields' => array_merge($sqliteDatabaseAdapterRegistryFields, array('key' => array(
'title' => 'Encryption key<br><small>This function is experimental and requires configuration of an ' 'title' => 'Encryption key<br><small>This function is experimental and requires configuration of an '
. 'encryption module</small>', . 'encryption module</small>',
'default' => '' 'default' => ''
))) )))
) )
); );
// PDO database // PDO database
/** @skipUpgrade */
DatabaseAdapterRegistry::register( DatabaseAdapterRegistry::register(
array( array(
'class' => 'SQLite3PDODatabase', 'class' => 'SQLite3PDODatabase',
'title' => 'SQLite 3.3+ (using PDO)', 'module' => 'sqlite3',
'helperPath' => dirname(__FILE__).'/code/SQLiteDatabaseConfigurationHelper.php', 'title' => 'SQLite 3.3+ (using PDO)',
'supported' => (class_exists('PDO') && in_array('sqlite', PDO::getAvailableDrivers())), 'helperPath' => __DIR__.'/code/SQLiteDatabaseConfigurationHelper.php',
'missingExtensionText' => 'helperClass' => SQLiteDatabaseConfigurationHelper::class,
'Either the <a href="http://php.net/manual/en/book.pdo.php">PDO Extension</a> or the '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
<a href="http://php.net/manual/en/book.sqlite3.php">SQLite3 PDO Driver</a> <a href="http://php.net/manual/en/book.sqlite3.php">SQLite3 PDO Driver</a>
are unavailable. Please install or enable these and refresh this page.', are unavailable. Please install or enable these and refresh this page.',
'fields' => $sqliteDatabaseAdapterRegistryFields 'fields' => $sqliteDatabaseAdapterRegistryFields
) )
); );

1
code-of-conduct.md Normal file
View File

@ -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).

View File

@ -1,171 +1,189 @@
<?php <?php
namespace SilverStripe\SQLite;
use SilverStripe\ORM\Connect\DBConnector;
use SQLite3;
/** /**
* SQLite connector class * SQLite connector class
*
* @package SQLite3
*/ */
class SQLite3Connector extends DBConnector { class SQLite3Connector extends DBConnector
{
/** /**
* The name of the database. * The name of the database.
* *
* @var string * @var string
*/ */
protected $databaseName; protected $databaseName;
/** /**
* Connection to the DBMS. * Connection to the DBMS.
* *
* @var SQLite3 * @var SQLite3
*/ */
protected $dbConn; protected $dbConn;
public function connect($parameters, $selectDB = false) { public function connect($parameters, $selectDB = false)
$file = $parameters['filepath']; {
$this->dbConn = empty($parameters['key']) $file = $parameters['filepath'];
? new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE) $this->dbConn = empty($parameters['key'])
: new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, $parameters['key']); ? new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE)
$this->dbConn->busyTimeout(60000); : new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, $parameters['key']);
$this->databaseName = $parameters['database']; $this->dbConn->busyTimeout(60000);
} $this->databaseName = $parameters['database'];
}
public function affectedRows() { public function affectedRows()
return $this->dbConn->changes(); {
} return $this->dbConn->changes();
}
public function getGeneratedID($table) { public function getGeneratedID($table)
return $this->dbConn->lastInsertRowID(); {
} return $this->dbConn->lastInsertRowID();
}
public function getLastError() { public function getLastError()
$message = $this->dbConn->lastErrorMsg(); {
return $message === 'not an error' ? null : $message; $message = $this->dbConn->lastErrorMsg();
} return $message === 'not an error' ? null : $message;
}
public function getSelectedDatabase() { public function getSelectedDatabase()
return $this->databaseName; {
} return $this->databaseName;
}
public function getVersion() { public function getVersion()
$version = SQLite3::version(); {
return trim($version['versionString']); $version = SQLite3::version();
} return trim($version['versionString']);
}
public function isActive() { public function isActive()
return $this->databaseName && $this->dbConn; {
} return $this->databaseName && $this->dbConn;
}
/** /**
* Prepares the list of parameters in preparation for passing to mysqli_stmt_bind_param * Prepares the list of parameters in preparation for passing to mysqli_stmt_bind_param
* *
* @param array $parameters List of parameters * @param array $parameters List of parameters
* @return array List of parameters types and values * @return array List of parameters types and values
*/ */
public function parsePreparedParameters($parameters) { public function parsePreparedParameters($parameters)
$values = array(); {
foreach($parameters as $value) { $values = array();
$phpType = gettype($value); foreach ($parameters as $value) {
$sqlType = null; $phpType = gettype($value);
$sqlType = null;
// Allow overriding of parameter type using an associative array // Allow overriding of parameter type using an associative array
if($phpType === 'array') { if ($phpType === 'array') {
$phpType = $value['type']; $phpType = $value['type'];
$value = $value['value']; $value = $value['value'];
} }
// Convert php variable type to one that makes mysqli_stmt_bind_param happy // Convert php variable type to one that makes mysqli_stmt_bind_param happy
// @see http://www.php.net/manual/en/mysqli-stmt.bind-param.php // @see http://www.php.net/manual/en/mysqli-stmt.bind-param.php
switch($phpType) { switch ($phpType) {
case 'boolean': case 'boolean':
case 'integer': case 'integer':
$sqlType = SQLITE3_INTEGER; $sqlType = SQLITE3_INTEGER;
break; break;
case 'float': // Not actually returnable from gettype case 'float': // Not actually returnable from gettype
case 'double': case 'double':
$sqlType = SQLITE3_FLOAT; $sqlType = SQLITE3_FLOAT;
break; break;
case 'object': // Allowed if the object or resource has a __toString method case 'object': // Allowed if the object or resource has a __toString method
case 'resource': case 'resource':
case 'string': case 'string':
$sqlType = SQLITE3_TEXT; $sqlType = SQLITE3_TEXT;
break; break;
case 'NULL': case 'NULL':
$sqlType = SQLITE3_NULL; $sqlType = SQLITE3_NULL;
break; break;
case 'blob': case 'blob':
$sqlType = SQLITE3_BLOB; $sqlType = SQLITE3_BLOB;
break; break;
case 'array': case 'array':
case 'unknown type': case 'unknown type':
default: 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; break;
} }
$values[] = array( $values[] = array(
'type' => $sqlType, 'type' => $sqlType,
'value' => $value 'value' => $value
); );
} }
return $values; 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); // Type check, identify, and prepare parameters for passing to the statement bind function
$parsedParameters = $this->parsePreparedParameters($parameters);
// Prepare statement // Prepare statement
$statement = @$this->dbConn->prepare($sql); $statement = @$this->dbConn->prepare($sql);
if($statement) { if ($statement) {
// Bind and run to statement // Bind and run to statement
for($i = 0; $i < count($parsedParameters); $i++) { for ($i = 0; $i < count($parsedParameters); $i++) {
$value = $parsedParameters[$i]['value']; $value = $parsedParameters[$i]['value'];
$type = $parsedParameters[$i]['type']; $type = $parsedParameters[$i]['type'];
$statement->bindValue($i+1, $value, $type); $statement->bindValue($i+1, $value, $type);
} }
// Return successful result
$handle = $statement->execute();
if ($handle) {
return new SQLite3Query($this, $handle);
}
}
// Handle error
$values = $this->parameterValues($parameters);
$this->databaseError($this->getLastError(), $errorLevel, $sql, $values);
return null;
}
public function query($sql, $errorLevel = E_USER_ERROR) { // Return successful result
// Return successful result $handle = $statement->execute();
$handle = @$this->dbConn->query($sql); if ($handle) {
if ($handle) { return new SQLite3Query($this, $handle);
return new SQLite3Query($this, $handle); }
} }
// Handle error
$this->databaseError($this->getLastError(), $errorLevel, $sql);
return null;
}
public function quoteString($value) { // Handle error
return "'".$this->escapeString($value)."'"; $values = $this->parameterValues($parameters);
} $this->databaseError($this->getLastError(), $errorLevel, $sql, $values);
return null;
}
public function escapeString($value) { public function query($sql, $errorLevel = E_USER_ERROR)
return $this->dbConn->escapeString($value); {
} // Return successful result
$handle = @$this->dbConn->query($sql);
if ($handle) {
return new SQLite3Query($this, $handle);
}
public function selectDatabase($name) { // Handle error
if($name !== $this->databaseName) { $this->databaseError($this->getLastError(), $errorLevel, $sql);
user_error("SQLite3Connector can't change databases. Please create a new database connection", E_USER_ERROR); return null;
} }
return true;
}
public function unloadDatabase() { public function quoteString($value)
$this->dbConn->close(); {
$this->databaseName = null; return "'".$this->escapeString($value)."'";
} }
public function escapeString($value)
{
return $this->dbConn->escapeString($value ?? '');
}
public function selectDatabase($name)
{
if ($name !== $this->databaseName) {
$this->databaseError("SQLite3Connector can't change databases. Please create a new database connection");
}
return true;
}
public function unloadDatabase()
{
$this->dbConn->close();
$this->databaseName = null;
}
} }

View File

@ -1,490 +1,753 @@
<?php <?php
/** namespace SilverStripe\SQLite;
* SQLite database controller class
* use SilverStripe\Assets\File;
* @package SQLite3 use SilverStripe\Core\Config\Configurable;
*/ use SilverStripe\Core\Convert;
class SQLite3Database extends SS_Database { use SilverStripe\Dev\Deprecation;
use SilverStripe\ORM\ArrayList;
/** use SilverStripe\ORM\Connect\Database;
* Database schema manager object use SilverStripe\ORM\DataList;
* use SilverStripe\ORM\DataObject;
* @var SQLite3SchemaManager use SilverStripe\ORM\PaginatedList;
*/ use SilverStripe\ORM\Queries\SQLSelect;
protected $schemaManager = null;
/**
/* * SQLite database controller class
* This holds the parameters that the original connection was created with, */
* so we can switch back to it if necessary (used for unit tests) class SQLite3Database extends Database
* {
* @var array use Configurable;
*/
protected $parameters; /**
* Global environment config for setting 'path'
/* */
* if we're on a In-Memory db const ENV_PATH = 'SS_SQLITE_DATABASE_PATH';
*
* @var boolean /**
*/ * Global environment config for setting 'key'
protected $livesInMemory = false; */
const ENV_KEY = 'SS_SQLITE_DATABASE_KEY';
/**
* List of default pragma values /**
* * Extension added to every database name
* @todo Migrate to SS config *
* * @config
* @var array * @var string
*/ */
public static $default_pragma = array( private static $database_extension = '.sqlite';
'encoding' => '"UTF-8"',
'locking_mode' => 'NORMAL' /**
); * Database schema manager object
*
* @var SQLite3SchemaManager
/** */
* Extension used to distinguish between sqllite database files and other files. protected $schemaManager = null;
* Required to handle multiple databases.
* /*
* @return string * This holds the parameters that the original connection was created with,
*/ * so we can switch back to it if necessary (used for unit tests)
public static function database_extension() { *
return Config::inst()->get('SQLite3Database', 'database_extension'); * @var array
} */
protected $parameters;
/**
* Check if a database name has a valid extension /*
* * if we're on a In-Memory db
* @param string $name *
* @return boolean * @var boolean
*/ */
public static function is_valid_database_name($name) { protected $livesInMemory = false;
$extension = self::database_extension();
if(empty($extension)) return true; /**
* @var bool
return substr_compare($name, $extension, -strlen($extension), strlen($extension)) === 0; */
} protected $transactionNesting = 0;
/** /**
* Connect to a SQLite3 database. * @var array
* @param array $parameters An map of parameters, which should include: */
* - database: The database to connect to, with the correct file extension (.sqlite) protected $transactionSavepoints = [];
* - path: the path to the SQLite3 database file
* - key: the encryption key (needs testing) /**
* - memory: use the faster In-Memory database for unit tests * List of default pragma values
*/ *
public function connect($parameters) { * @todo Migrate to SS config
*
if(!empty($parameters['memory'])) { * @var array
Deprecation::notice( */
'1.4.0', public static $default_pragma = array(
"\$databaseConfig['memory'] is deprecated. Use \$databaseConfig['path'] = ':memory:' instead.", 'encoding' => '"UTF-8"',
Deprecation::SCOPE_GLOBAL 'locking_mode' => 'NORMAL'
); );
unset($parameters['memory']);
$parameters['path'] = ':memory:';
} /**
* Extension used to distinguish between sqllite database files and other files.
//We will store these connection parameters for use elsewhere (ie, unit tests) * Required to handle multiple databases.
$this->parameters = $parameters; *
$this->schemaManager->flushCache(); * @return string
*/
// Ensure database name is set public static function database_extension()
if(empty($parameters['database'])) { {
$parameters['database'] = 'database' . self::database_extension(); return static::config()->get('database_extension');
} }
$dbName = $parameters['database'];
if(!self::is_valid_database_name($dbName)) { /**
// If not using the correct file extension for database files then the * Check if a database name has a valid extension
// results of SQLite3SchemaManager::databaseList will be unpredictable *
$extension = self::database_extension(); * @param string $name
Deprecation::notice('3.2', "SQLite3Database now expects a database file with extension \"$extension\". Behaviour may be unpredictable otherwise."); * @return boolean
} */
public static function is_valid_database_name($name)
// use the very lightspeed SQLite In-Memory feature for testing {
if($this->getLivesInMemory()) { $extension = self::database_extension();
$file = ':memory:'; if (empty($extension)) {
} else { return true;
// Ensure path is given }
if(empty($parameters['path'])) {
$parameters['path'] = ASSETS_PATH . '/.sqlitedb'; return substr_compare($name, $extension, -strlen($extension), strlen($extension)) === 0;
} }
//assumes that the path to dbname will always be provided: /**
$file = $parameters['path'] . '/' . $dbName; * Connect to a SQLite3 database.
if(!file_exists($parameters['path'])) { * @param array $parameters An map of parameters, which should include:
SQLiteDatabaseConfigurationHelper::create_db_dir($parameters['path']); * - database: The database to connect to, with the correct file extension (.sqlite)
SQLiteDatabaseConfigurationHelper::secure_db_dir($parameters['path']); * - path: the path to the SQLite3 database file
} * - key: the encryption key (needs testing)
} * - memory: use the faster In-Memory database for unit tests
*/
// 'path' and 'database' are merged into the full file path, which public function connect($parameters)
// is the format that connectors such as PDOConnector expect {
$parameters['filepath'] = $file; if (!empty($parameters['memory'])) {
Deprecation::notice(
// Ensure that driver is available (required by PDO) '1.4.0',
if(empty($parameters['driver'])) { "\$databaseConfig['memory'] is deprecated. Use \$databaseConfig['path'] = ':memory:' instead.",
$parameters['driver'] = $this->getDatabaseServer(); Deprecation::SCOPE_GLOBAL
} );
unset($parameters['memory']);
$this->connector->connect($parameters, true); $parameters['path'] = ':memory:';
}
foreach(self::$default_pragma as $pragma => $value) {
$this->setPragma($pragma, $value); //We will store these connection parameters for use elsewhere (ie, unit tests)
} $this->parameters = $parameters;
$this->schemaManager->flushCache();
if(empty(self::$default_pragma['locking_mode'])) {
self::$default_pragma['locking_mode'] = $this->getPragma('locking_mode'); // Ensure database name is set
} if (empty($parameters['database'])) {
} $parameters['database'] = 'database';
}
/** // use the very lightspeed SQLite In-Memory feature for testing
* Retrieve parameters used to connect to this SQLLite database if ($this->getLivesInMemory()) {
* $file = ':memory:';
* @return array } else {
*/ // Ensure path is given
public function getParameters() { $path = $this->getPath();
return $this->parameters;
} //assumes that the path to dbname will always be provided:
$file = $path . '/' . $parameters['database'] . self::database_extension();
public function getLivesInMemory() { if (!file_exists($path)) {
return isset($this->parameters['path']) && $this->parameters['path'] === ':memory:'; SQLiteDatabaseConfigurationHelper::create_db_dir($path);
} SQLiteDatabaseConfigurationHelper::secure_db_dir($path);
}
public function supportsCollations() { }
return true;
} // 'path' and 'database' are merged into the full file path, which
// is the format that connectors such as PDOConnector expect
public function supportsTimezoneOverride() { $parameters['filepath'] = $file;
return false;
} // Ensure that driver is available (required by PDO)
if (empty($parameters['driver'])) {
/** $parameters['driver'] = $this->getDatabaseServer();
* Execute PRAGMA commands. }
*
* @param string pragma name $this->connector->connect($parameters, true);
* @param string value to set
*/ foreach (self::$default_pragma as $pragma => $value) {
public function setPragma($pragma, $value) { $this->setPragma($pragma, $value);
$this->query("PRAGMA $pragma = $value"); }
}
if (empty(self::$default_pragma['locking_mode'])) {
/** self::$default_pragma['locking_mode'] = $this->getPragma('locking_mode');
* Gets pragma value. }
* }
* @param string pragma name
* @return string the pragma value /**
*/ * Retrieve parameters used to connect to this SQLLite database
public function getPragma($pragma) { *
return $this->query("PRAGMA $pragma")->value(); * @return array
} */
public function getParameters()
public function getDatabaseServer() { {
return "sqlite"; return $this->parameters;
} }
public function selectDatabase($name, $create = false, $errorLevel = E_USER_ERROR) { /**
if (!$this->schemaManager->databaseExists($name)) { * Determine if this Db is in memory
// Check DB creation permisson *
if (!$create) { * @return bool
if ($errorLevel !== false) { */
user_error("Attempted to connect to non-existing database \"$name\"", $errorLevel); public function getLivesInMemory()
} {
// Unselect database return isset($this->parameters['path']) && $this->parameters['path'] === ':memory:';
$this->connector->unloadDatabase(); }
return false;
} /**
$this->schemaManager->createDatabase($name); * Get file path. If in memory this is null
} *
* @return string|null
// Reconnect using the existing parameters */
$parameters = $this->parameters; public function getPath()
$parameters['database'] = $name; {
$this->connect($parameters); if ($this->getLivesInMemory()) {
return true; return null;
} }
if (empty($this->parameters['path'])) {
function now(){ return ASSETS_PATH . '/.sqlitedb';
return "datetime('now', 'localtime')"; }
} return $this->parameters['path'];
}
function random(){
return 'random()'; public function supportsCollations()
} {
return true;
/** }
* The core search engine configuration.
* @todo There is a fulltext search for SQLite making use of virtual tables, the fts3 extension and the public function supportsTimezoneOverride()
* MATCH operator {
* there are a few issues with fts: return false;
* - shared cached lock doesn't allow to create virtual tables on versions prior to 3.6.17 }
* - there must not be more than one MATCH operator per statement
* - the fts3 extension needs to be available /**
* for now we use the MySQL implementation with the MATCH()AGAINST() uglily replaced with LIKE * Execute PRAGMA commands.
* *
* @param string $keywords Keywords as a space separated string * @param string $pragma name
* @return object DataObjectSet of result pages * @param string $value to set
*/ */
public function searchEngine($classesToSearch, $keywords, $start, $pageLength, $sortBy = "Relevance DESC", public function setPragma($pragma, $value)
$extraFilter = "", $booleanSearch = false, $alternativeFileFilter = "", $invertedMatch = false {
) { $this->query("PRAGMA $pragma = $value");
$keywords = $this->escapeString(str_replace(array('*','+','-','"','\''), '', $keywords)); }
$htmlEntityKeywords = htmlentities(utf8_decode($keywords));
/**
$extraFilters = array('SiteTree' => '', 'File' => ''); * Gets pragma value.
*
if($extraFilter) { * @param string $pragma name
$extraFilters['SiteTree'] = " AND $extraFilter"; * @return string the pragma value
*/
if($alternativeFileFilter) $extraFilters['File'] = " AND $alternativeFileFilter"; public function getPragma($pragma)
else $extraFilters['File'] = $extraFilters['SiteTree']; {
} return $this->query("PRAGMA $pragma")->value();
}
// Always ensure that only pages with ShowInSearch = 1 can be searched
$extraFilters['SiteTree'] .= ' AND ShowInSearch <> 0'; public function getDatabaseServer()
// File.ShowInSearch was added later, keep the database driver backwards compatible {
// by checking for its existence first return "sqlite";
$fields = $this->getSchemaManager()->fieldList('File'); }
if(array_key_exists('ShowInSearch', $fields)) {
$extraFilters['File'] .= " AND ShowInSearch <> 0"; public function selectDatabase($name, $create = false, $errorLevel = E_USER_ERROR)
} {
if (!$this->schemaManager->databaseExists($name)) {
$limit = $start . ", " . (int) $pageLength; // Check DB creation permisson
if (!$create) {
$notMatch = $invertedMatch ? "NOT " : ""; if ($errorLevel !== false) {
if($keywords) { user_error("Attempted to connect to non-existing database \"$name\"", $errorLevel);
$match['SiteTree'] = " }
(Title LIKE '%$keywords%' OR MenuTitle LIKE '%$keywords%' OR Content LIKE '%$keywords%' OR MetaDescription LIKE '%$keywords%' OR // Unselect database
Title LIKE '%$htmlEntityKeywords%' OR MenuTitle LIKE '%$htmlEntityKeywords%' OR Content LIKE '%$htmlEntityKeywords%' OR MetaDescription LIKE '%$htmlEntityKeywords%') $this->connector->unloadDatabase();
"; return false;
$match['File'] = "(Filename LIKE '%$keywords%' OR Title LIKE '%$keywords%' OR Content LIKE '%$keywords%') AND ClassName = 'File'"; }
$this->schemaManager->createDatabase($name);
// We make the relevance search by converting a boolean mode search into a normal one }
$relevanceKeywords = $keywords;
$htmlEntityRelevanceKeywords = $htmlEntityKeywords; // Reconnect using the existing parameters
$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%')"; $parameters = $this->parameters;
$relevance['File'] = "(Filename LIKE '%$relevanceKeywords%' OR Title LIKE '%$relevanceKeywords%' OR Content LIKE '%$relevanceKeywords%')"; $parameters['database'] = $name;
} else { $this->connect($parameters);
$relevance['SiteTree'] = $relevance['File'] = 1; return true;
$match['SiteTree'] = $match['File'] = "1 = 1"; }
}
public function now()
// Generate initial queries and base table names {
$baseClasses = array('SiteTree' => '', 'File' => ''); return "datetime('now', 'localtime')";
$queries = array(); }
foreach($classesToSearch as $class) {
$queries[$class] = DataList::create($class)->where($notMatch . $match[$class] . $extraFilters[$class], "")->dataQuery()->query(); public function random()
$fromArr = $queries[$class]->getFrom(); {
$baseClasses[$class] = reset($fromArr); return 'random()';
} }
// Make column selection lists /**
$select = array( * The core search engine configuration.
'SiteTree' => array( * @todo There is a fulltext search for SQLite making use of virtual tables, the fts3 extension and the
"\"ClassName\"", * MATCH operator
"\"ID\"", * there are a few issues with fts:
"\"ParentID\"", * - shared cached lock doesn't allow to create virtual tables on versions prior to 3.6.17
"\"Title\"", * - there must not be more than one MATCH operator per statement
"\"URLSegment\"", * - the fts3 extension needs to be available
"\"Content\"", * for now we use the MySQL implementation with the MATCH()AGAINST() uglily replaced with LIKE
"\"LastEdited\"", *
"\"Created\"", * @param array $classesToSearch
"NULL AS \"Filename\"", * @param string $keywords Keywords as a space separated string
"NULL AS \"Name\"", * @param int $start
"\"CanViewType\"", * @param int $pageLength
"$relevance[SiteTree] AS Relevance" * @param string $sortBy
), * @param string $extraFilter
'File' => array( * @param bool $booleanSearch
"\"ClassName\"", * @param string $alternativeFileFilter
"\"ID\"", * @param bool $invertedMatch
"NULL AS \"ParentID\"", * @return PaginatedList DataObjectSet of result pages
"\"Title\"", */
"NULL AS \"URLSegment\"", public function searchEngine(
"\"Content\"", $classesToSearch,
"\"LastEdited\"", $keywords,
"\"Created\"", $start,
"\"Filename\"", $pageLength,
"\"Name\"", $sortBy = "Relevance DESC",
"NULL AS \"CanViewType\"", $extraFilter = "",
"$relevance[File] AS Relevance" $booleanSearch = false,
) $alternativeFileFilter = "",
); $invertedMatch = false
) {
// Process queries $start = (int)$start;
foreach($classesToSearch as $class) { $pageLength = (int)$pageLength;
// There's no need to do all that joining $keywords = $this->escapeString(str_replace(array('*', '+', '-', '"', '\''), '', $keywords));
$queries[$class]->setFrom($baseClasses[$class]); $htmlEntityKeywords = htmlentities(utf8_decode($keywords));
$queries[$class]->setSelect(array()); $pageClass = 'SilverStripe\\CMS\\Model\\SiteTree';
foreach($select[$class] as $clause) { $fileClass = 'SilverStripe\\Assets\\File';
if(preg_match('/^(.*) +AS +"?([^"]*)"?/i', $clause, $matches)) {
$queries[$class]->selectField($matches[1], $matches[2]); $extraFilters = array($pageClass => '', $fileClass => '');
} else {
$queries[$class]->selectField(str_replace('"', '', $clause)); if ($extraFilter) {
} $extraFilters[$pageClass] = " AND $extraFilter";
}
if ($alternativeFileFilter) {
$queries[$class]->setOrderBy(array()); $extraFilters[$fileClass] = " AND $alternativeFileFilter";
} } else {
$extraFilters[$fileClass] = $extraFilters[$pageClass];
// Combine queries }
$querySQLs = array(); }
$queryParameters = array();
$totalCount = 0; // Always ensure that only pages with ShowInSearch = 1 can be searched
foreach($queries as $query) { $extraFilters[$pageClass] .= ' AND ShowInSearch <> 0';
$querySQLs[] = $query->sql($parameters); // File.ShowInSearch was added later, keep the database driver backwards compatible
$queryParameters = array_merge($queryParameters, $parameters); // by checking for its existence first
$totalCount += $query->unlimitedRowCount(); if (File::singleton()->getSchema()->fieldSpec(File::class, 'ShowInSearch')) {
} $extraFilters[$fileClass] .= " AND ShowInSearch <> 0";
}
$fullQuery = implode(" UNION ", $querySQLs) . " ORDER BY $sortBy LIMIT $limit";
// Get records $limit = $start . ", " . $pageLength;
$records = $this->preparedQuery($fullQuery, $queryParameters);
$notMatch = $invertedMatch ? "NOT " : "";
foreach($records as $record) { if ($keywords) {
$objects[] = new $record['ClassName']($record); $match[$pageClass] =
} "(Title LIKE '%$keywords%' OR MenuTitle LIKE '%$keywords%' OR Content LIKE '%$keywords%'"
. " OR MetaDescription LIKE '%$keywords%' OR Title LIKE '%$htmlEntityKeywords%'"
if(isset($objects)) $doSet = new ArrayList($objects); . " OR MenuTitle LIKE '%$htmlEntityKeywords%' OR Content LIKE '%$htmlEntityKeywords%'"
else $doSet = new ArrayList(); . " OR MetaDescription LIKE '%$htmlEntityKeywords%')";
$list = new PaginatedList($doSet); $fileClassSQL = Convert::raw2sql($fileClass);
$list->setPageStart($start); $match[$fileClass] =
$list->setPageLEngth($pageLength); "(Name LIKE '%$keywords%' OR Title LIKE '%$keywords%') AND ClassName = '$fileClassSQL'";
$list->setTotalItems($totalCount);
return $list; // We make the relevance search by converting a boolean mode search into a normal one
} $relevanceKeywords = $keywords;
$htmlEntityRelevanceKeywords = $htmlEntityKeywords;
/* $relevance[$pageClass] =
* Does this database support transactions? "(Title LIKE '%$relevanceKeywords%' OR MenuTitle LIKE '%$relevanceKeywords%'"
*/ . " OR Content LIKE '%$relevanceKeywords%' OR MetaDescription LIKE '%$relevanceKeywords%')"
public function supportsTransactions(){ . " + (Title LIKE '%$htmlEntityRelevanceKeywords%' OR MenuTitle LIKE '%$htmlEntityRelevanceKeywords%'"
return version_compare($this->getVersion(), '3.6', '>='); . " OR Content LIKE '%$htmlEntityRelevanceKeywords%' OR MetaDescription "
} . " LIKE '%$htmlEntityRelevanceKeywords%')";
$relevance[$fileClass] = "(Name LIKE '%$relevanceKeywords%' OR Title LIKE '%$relevanceKeywords%')";
public function supportsExtensions($extensions = array('partitions', 'tablespaces', 'clustering')){ } else {
$relevance[$pageClass] = $relevance[$fileClass] = 1;
if(isset($extensions['partitions'])) $match[$pageClass] = $match[$fileClass] = "1 = 1";
return true; }
elseif(isset($extensions['tablespaces']))
return true; // Generate initial queries
elseif(isset($extensions['clustering'])) $queries = array();
return true; foreach ($classesToSearch as $class) {
else $queries[$class] = DataList::create($class)
return false; ->where($notMatch . $match[$class] . $extraFilters[$class])
} ->dataQuery()
->query();
public function transactionStart($transaction_mode = false, $session_characteristics = false) { }
$this->query('BEGIN');
} // Make column selection lists
$select = array(
public function transactionSavepoint($savepoint) { $pageClass => array(
$this->query("SAVEPOINT \"$savepoint\""); "\"ClassName\"",
} "\"ID\"",
"\"ParentID\"",
public function transactionRollback($savepoint = false){ "\"Title\"",
"\"URLSegment\"",
if($savepoint) { "\"Content\"",
$this->query("ROLLBACK TO $savepoint;"); "\"LastEdited\"",
} else { "\"Created\"",
$this->query('ROLLBACK;'); "NULL AS \"Name\"",
} "\"CanViewType\"",
} $relevance[$pageClass] . " AS Relevance"
),
public function transactionEnd($chain = false){ $fileClass => array(
$this->query('COMMIT;'); "\"ClassName\"",
} "\"ID\"",
"NULL AS \"ParentID\"",
public function clearTable($table) { "\"Title\"",
$this->query("DELETE FROM \"$table\""); "NULL AS \"URLSegment\"",
} "NULL AS \"Content\"",
"\"LastEdited\"",
public function comparisonClause($field, $value, $exact = false, $negate = false, $caseSensitive = null, "\"Created\"",
$parameterised = false "\"Name\"",
) { "NULL AS \"CanViewType\"",
if($exact && !$caseSensitive) { $relevance[$fileClass] . " AS Relevance"
$comp = ($negate) ? '!=' : '='; )
} else { );
if($caseSensitive) {
// GLOB uses asterisks as wildcards. // Process queries
// Replace them in search string, without replacing escaped percetage signs. foreach ($classesToSearch as $class) {
$comp = 'GLOB'; // There's no need to do all that joining
$value = preg_replace('/^%([^\\\\])/', '*$1', $value); $queries[$class]->setFrom('"'.DataObject::getSchema()->baseDataTable($class).'"');
$value = preg_replace('/([^\\\\])%$/', '$1*', $value); $queries[$class]->setSelect(array());
$value = preg_replace('/([^\\\\])%/', '$1*', $value); foreach ($select[$class] as $clause) {
} else { if (preg_match('/^(.*) +AS +"?([^"]*)"?/i', $clause ?? '', $matches)) {
$comp = 'LIKE'; $queries[$class]->selectField($matches[1], $matches[2]);
} } else {
if($negate) $comp = 'NOT ' . $comp; $queries[$class]->selectField(str_replace('"', '', $clause));
} }
}
if($parameterised) {
return sprintf("%s %s ?", $field, $comp); $queries[$class]->setOrderBy(array());
} else { }
return sprintf("%s %s '%s'", $field, $comp, $value);
} // Combine queries
} $querySQLs = array();
$queryParameters = array();
function formattedDatetimeClause($date, $format) { $totalCount = 0;
preg_match_all('/%(.)/', $format, $matches); foreach ($queries as $query) {
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); /** @var SQLSelect $query */
$querySQLs[] = $query->sql($parameters);
$translate = array( $queryParameters = array_merge($queryParameters, $parameters);
'/%i/' => '%M', $totalCount += $query->unlimitedRowCount();
'/%s/' => '%S', }
'/%U/' => '%s',
); $fullQuery = implode(" UNION ", $querySQLs) . " ORDER BY $sortBy LIMIT $limit";
$format = preg_replace(array_keys($translate), array_values($translate), $format); // Get records
$records = $this->preparedQuery($fullQuery, $queryParameters);
$modifiers = array();
if($format == '%s' && $date != 'now') $modifiers[] = 'utc'; foreach ($records as $record) {
if($format != '%s' && $date == 'now') $modifiers[] = 'localtime'; $objects[] = new $record['ClassName']($record);
}
if(preg_match('/^now$/i', $date)) {
$date = "'now'"; if (isset($objects)) {
} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date)) { $doSet = new ArrayList($objects);
$date = "'$date'"; } else {
} $doSet = new ArrayList();
}
$modifier = empty($modifiers) ? '' : ", '" . implode("', '", $modifiers) . "'"; $list = new PaginatedList($doSet);
return "strftime('$format', $date$modifier)"; $list->setPageStart($start);
} $list->setPageLength($pageLength);
$list->setTotalItems($totalCount);
function datetimeIntervalClause($date, $interval) { return $list;
$modifiers = array(); }
if($date == 'now') $modifiers[] = 'localtime';
/*
if(preg_match('/^now$/i', $date)) { * Does this database support transactions?
$date = "'now'"; */
} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date)) { public function supportsTransactions()
$date = "'$date'"; {
} return version_compare($this->getVersion(), '3.6', '>=');
}
$modifier = empty($modifiers) ? '' : ", '" . implode("', '", $modifiers) . "'";
return "datetime($date$modifier, '$interval')"; /**
} * Does this database support transaction modes?
*
function datetimeDifferenceClause($date1, $date2) { * SQLite doesn't support transaction modes.
$modifiers1 = array(); *
$modifiers2 = array(); * @param string $mode
* @return bool
if($date1 == 'now') $modifiers1[] = 'localtime'; */
if($date2 == 'now') $modifiers2[] = 'localtime'; public function supportsTransactionMode(string $mode): bool
{
if(preg_match('/^now$/i', $date1)) { return false;
$date1 = "'now'"; }
} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date1)) {
$date1 = "'$date1'"; public function supportsExtensions($extensions = array('partitions', 'tablespaces', 'clustering'))
} {
if (isset($extensions['partitions'])) {
if(preg_match('/^now$/i', $date2)) { return true;
$date2 = "'now'"; } elseif (isset($extensions['tablespaces'])) {
} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date2)) { return true;
$date2 = "'$date2'"; } elseif (isset($extensions['clustering'])) {
} return true;
} else {
$modifier1 = empty($modifiers1) ? '' : ", '" . implode("', '", $modifiers1) . "'"; return false;
$modifier2 = empty($modifiers2) ? '' : ", '" . implode("', '", $modifiers2) . "'"; }
}
return "strftime('%s', $date1$modifier1) - strftime('%s', $date2$modifier2)";
} 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)
{
$this->query("SAVEPOINT \"$savepoint\"");
$this->transactionDepthIncrease($savepoint);
}
/**
* 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 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();
}
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,
$parameterised = false
) {
if ($exact && !$caseSensitive) {
$comp = ($negate) ? '!=' : '=';
} else {
if ($caseSensitive) {
// GLOB uses asterisks as wildcards.
// Replace them in search string, without replacing escaped percetage signs.
$comp = 'GLOB';
$value = preg_replace('/^%([^\\\\])/', '*$1', $value);
$value = preg_replace('/([^\\\\])%$/', '$1*', $value);
$value = preg_replace('/([^\\\\])%/', '$1*', $value);
} else {
$comp = 'LIKE';
}
if ($negate) {
$comp = 'NOT ' . $comp;
}
}
if ($parameterised) {
return sprintf("%s %s ?", $field, $comp);
} else {
return sprintf("%s %s '%s'", $field, $comp, $value);
}
}
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);
}
}
$translate = array(
'/%i/' => '%M',
'/%s/' => '%S',
'/%U/' => '%s',
);
$format = preg_replace(array_keys($translate), array_values($translate), $format);
$modifiers = array();
if ($format == '%s' && $date != 'now') {
$modifiers[] = 'utc';
}
if ($format != '%s' && $date == 'now') {
$modifiers[] = 'localtime';
}
if (preg_match('/^now$/i', $date ?? '')) {
$date = "'now'";
} elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date ?? '')) {
$date = "'$date'";
}
$modifier = empty($modifiers) ? '' : ", '" . implode("', '", $modifiers) . "'";
return "strftime('$format', $date$modifier)";
}
public function datetimeIntervalClause($date, $interval)
{
$modifiers = array();
if ($date == 'now') {
$modifiers[] = 'localtime';
}
if (preg_match('/^now$/i', $date ?? '')) {
$date = "'now'";
} elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date ?? '')) {
$date = "'$date'";
}
$modifier = empty($modifiers) ? '' : ", '" . implode("', '", $modifiers) . "'";
return "datetime($date$modifier, '$interval')";
}
public function datetimeDifferenceClause($date1, $date2)
{
$modifiers1 = array();
$modifiers2 = array();
if ($date1 == 'now') {
$modifiers1[] = 'localtime';
}
if ($date2 == 'now') {
$modifiers2[] = 'localtime';
}
if (preg_match('/^now$/i', $date1 ?? '')) {
$date1 = "'now'";
} 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 ?? '')) {
$date2 = "'now'";
} elseif (preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date2 ?? '')) {
$date2 = "'$date2'";
}
$modifier1 = empty($modifiers1) ? '' : ", '" . implode("', '", $modifiers1) . "'";
$modifier2 = empty($modifiers2) ? '' : ", '" . implode("', '", $modifiers2) . "'";
return "strftime('%s', $date1$modifier1) - strftime('%s', $date2$modifier2)";
}
}

View File

@ -1,62 +1,83 @@
<?php <?php
namespace SilverStripe\SQLite;
use SilverStripe\ORM\Connect\Query;
use SQLite3Result;
/** /**
* A result-set from a SQLite3 database. * 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. * The SQLite3Connector object that created this result set.
* *
* @var SQLite3Connector * @var SQLite3Connector
*/ */
protected $database; protected $database;
/** /**
* The internal sqlite3 handle that points to the result set. * The internal sqlite3 handle that points to the result set.
* *
* @var SQLite3Result * @var SQLite3Result
*/ */
protected $handle; protected $handle;
/** /**
* Hook the result-set given into a Query class, suitable for use by framework. * Hook the result-set given into a Query class, suitable for use by framework.
* @param SQLite3Connector $database The database object that created this query. * @param SQLite3Connector $database The database object that created this query.
* @param SQLite3Result $handle the internal sqlite3 handle that is points to the resultset. * @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; $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; $this->handle->reset();
while($i < $row && $row = @$this->handle->fetchArray()) $i++; $i=0;
return true; while ($i <= $row && $result = @$this->handle->fetchArray(SQLITE3_ASSOC)) {
} $i++;
}
return $result;
}
/** /**
* @todo This looks terrible but there is no SQLite3::get_num_rows() implementation * @todo This looks terrible but there is no SQLite3::get_num_rows() implementation
*/ */
public function numRecords() { public function numRecords()
$c=0; {
while($this->handle->fetchArray()) $c++; // Some queries are not iterable using fetchArray like CREATE statement
$this->handle->reset(); if (!$this->handle->numColumns()) {
return $c; return 0;
} }
$this->handle->reset();
$c=0;
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; if ($data = $this->handle->fetchArray(SQLITE3_ASSOC)) {
} else { return $data;
return false; } else {
} return false;
} }
}
} }

View File

@ -1,94 +1,105 @@
<?php <?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 * 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) {
// Multi-row insert requires SQLite specific syntax prior to 3.7.11
// For backwards compatibility reasons include the "union all select" syntax
$nl = $this->getSeparator();
$into = $query->getInto();
// Column identifiers
$columns = $query->getColumns();
// Build all rows
$rowParts = array();
foreach($query->getRows() as $row) {
// Build all columns in this row
$assignments = $row->getAssignments();
// Join SET components together, considering parameters
$parts = array();
foreach($columns as $column) {
// Check if this column has a value for this row
if(isset($assignments[$column])) {
// Assigment is a single item array, expand with a loop here
foreach($assignments[$column] as $assignmentSQL => $assignmentParameters) {
$parts[] = $assignmentSQL;
$parameters = array_merge($parameters, $assignmentParameters);
break;
}
} else {
// This row is missing a value for a column used by another row
$parts[] = '?';
$parameters[] = null;
}
}
$rowParts[] = implode(', ', $parts);
}
$columnSQL = implode(', ', $columns);
$sql = "INSERT INTO {$into}{$nl}($columnSQL){$nl}SELECT " . implode("{$nl}UNION ALL SELECT ", $rowParts);
return $sql;
}
/** /**
* Return the LIMIT clause ready for inserting into a query. * @param SQLInsert $query
* * @param array $parameters
* @param SQLSelect $query The expression object to build from * @return string
* @param array $parameters Out parameter for the resulting query parameters */
* @return string The finalised limit SQL fragment protected function buildInsertQuery(SQLInsert $query, array &$parameters)
*/ {
public function buildLimitFragment(SQLSelect $query, array &$parameters) { // Multi-row insert requires SQLite specific syntax prior to 3.7.11
$nl = $this->getSeparator(); // For backwards compatibility reasons include the "union all select" syntax
// Ensure limit is given $nl = $this->getSeparator();
$limit = $query->getLimit(); $into = $query->getInto();
if(empty($limit)) return '';
// For literal values return this as the limit SQL // Column identifiers
if( ! is_array($limit)) { $columns = $query->getColumns();
return "{$nl}LIMIT $limit";
}
// Assert that the array version provides the 'limit' key // Build all rows
if( ! array_key_exists('limit', $limit) || ($limit['limit'] !== null && ! is_numeric($limit['limit']))) { $rowParts = array();
throw new InvalidArgumentException( foreach ($query->getRows() as $row) {
'SQLite3QueryBuilder::buildLimitSQL(): Wrong format for $limit: '. var_export($limit, true) // Build all columns in this row
); /** @var SQLAssignmentRow $row */
} $assignments = $row->getAssignments();
// Join SET components together, considering parameters
$parts = array();
foreach ($columns as $column) {
// Check if this column has a value for this row
if (isset($assignments[$column])) {
// Assigment is a single item array, expand with a loop here
foreach ($assignments[$column] as $assignmentSQL => $assignmentParameters) {
$parts[] = $assignmentSQL;
$parameters = array_merge($parameters, $assignmentParameters);
break;
}
} else {
// This row is missing a value for a column used by another row
$parts[] = '?';
$parameters[] = null;
}
}
$rowParts[] = implode(', ', $parts);
}
$columnSQL = implode(', ', $columns);
$sql = "INSERT INTO {$into}{$nl}($columnSQL){$nl}SELECT " . implode("{$nl}UNION ALL SELECT ", $rowParts);
$clause = "{$nl}"; return $sql;
if($limit['limit'] !== null) { }
$clause .= "LIMIT {$limit['limit']} ";
} else {
$clause .= "LIMIT -1 ";
}
if(isset($limit['start']) && is_numeric($limit['start']) && $limit['start'] !== 0) {
$clause .= "OFFSET {$limit['start']}";
}
return $clause;
}
/**
* Return the LIMIT clause ready for inserting into a query.
*
* @param SQLSelect $query The expression object to build from
* @param array $parameters Out parameter for the resulting query parameters
* @return string The finalised limit SQL fragment
*/
public function buildLimitFragment(SQLSelect $query, array &$parameters)
{
$nl = $this->getSeparator();
// Ensure limit is given
$limit = $query->getLimit();
if (empty($limit)) {
return '';
}
// For literal values return this as the limit SQL
if (! is_array($limit)) {
return "{$nl}LIMIT $limit";
}
// Assert that the array version provides the 'limit' key
if (! array_key_exists('limit', $limit) || ($limit['limit'] !== null && ! is_numeric($limit['limit']))) {
throw new InvalidArgumentException(
'SQLite3QueryBuilder::buildLimitSQL(): Wrong format for $limit: '. var_export($limit, true)
);
}
$clause = "{$nl}";
if ($limit['limit'] !== null) {
$clause .= "LIMIT {$limit['limit']} ";
} else {
$clause .= "LIMIT -1 ";
}
if (isset($limit['start']) && is_numeric($limit['start']) && $limit['start'] !== 0) {
$clause .= "OFFSET {$limit['start']}";
}
return $clause;
}
} }

View File

@ -1,615 +1,741 @@
<?php <?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 * SQLite schema manager class
*
* @package SQLite3
*/ */
class SQLite3SchemaManager extends DBSchemaManager { class SQLite3SchemaManager extends DBSchemaManager
{
/** /**
* Instance of the database controller this schema belongs to * Instance of the database controller this schema belongs to
* *
* @var SQLite3Database * @var SQLite3Database
*/ */
protected $database = null; protected $database = null;
/** /**
* Flag indicating whether or not the database has been checked and repaired * Flag indicating whether or not the database has been checked and repaired
* *
* @var boolean * @var boolean
*/ */
protected static $checked_and_repaired = false; protected static $checked_and_repaired = false;
/** /**
* Should schema be vacuumed during checkeAndRepairTable? * Should schema be vacuumed during checkeAndRepairTable?
* *
* @var boolean * @var boolean
*/ */
public static $vacuum = true; public static $vacuum = true;
public function createDatabase($name) {
// Ensure that any existing database is cleared before connection
$this->dropDatabase($name);
}
public function dropDatabase($name) { public function createDatabase($name)
// No need to delete database files if operating purely within memory {
if($this->database->getLivesInMemory()) return; // Ensure that any existing database is cleared before connection
$this->dropDatabase($name);
// 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() {
$parameters = $this->database->getParameters();
// If in-memory use the current database name only
if($this->database->getLivesInMemory()) {
return array($parameters['database']);
}
// If using file based database enumerate files in the database directory
$directory = $parameters['path'];
$files = scandir($directory);
// Filter each file in this directory
$databases = array();
if($files !== false) foreach($files as $file) {
// Filter non-files
if(!is_file("$directory/$file")) continue;
// Filter those with correct extension
if(!SQLite3Database::is_valid_database_name($file)) continue;
$databases[] = $file;
}
return $databases;
}
public function databaseExists($name) { public function dropDatabase($name)
$databases = $this->databaseList(); {
return in_array($name, $databases); // No need to delete database files if operating purely within memory
} if ($this->database->getLivesInMemory()) {
return;
/** }
* Empties any cached enum values
*/
public function flushCache() {
$this->enum_map = array();
}
function schemaUpdate($callback) {
// Set locking mode
$this->database->setPragma('locking_mode', 'EXCLUSIVE');
$this->checkAndRepairTable();
$this->flushCache();
// Initiate schema update
$error = null;
try {
parent::schemaUpdate($callback);
} catch(Exception $ex) {
$error = $ex;
}
// Revert locking mode
$this->database->setPragma('locking_mode', SQLite3Database::$default_pragma['locking_mode']);
if($error) throw $error;
}
/** // If using file based database ensure any existing file is removed
* Empty a specific table $path = $this->database->getPath();
* $fullpath = $path . '/' . $name . SQLite3Database::database_extension();
* @param string $table if (is_writable($fullpath)) {
*/ unlink($fullpath);
public function clearTable($table) { }
if($table != 'SQLiteEnums') $this->dbConn->query("DELETE FROM \"$table\""); }
}
public function createTable($table, $fields = null, $indexes = null, $options = null, $advancedOptions = null) { public function databaseList()
if(!isset($fields['ID'])) $fields['ID'] = $this->IdColumn(); {
// If in-memory use the current database name only
if ($this->database->getLivesInMemory()) {
return array(
$this->database->getConnector()->getSelectedDatabase()
?: 'database'
);
}
$fieldSchemata = array(); // If using file based database enumerate files in the database directory
if($fields) foreach($fields as $k => $v) { $directory = $this->database->getPath();
$fieldSchemata[] = "\"$k\" $v"; $files = scandir($directory);
}
$fieldSchemas = implode(",\n", $fieldSchemata);
// Switch to "CREATE TEMPORARY TABLE" for temporary tables // Filter each file in this directory
$temporary = empty($options['temporary']) ? "" : "TEMPORARY"; $databases = array();
$this->query("CREATE $temporary TABLE \"$table\" ( if ($files !== false) {
foreach ($files as $file) {
// Filter non-files
if (!is_file("$directory/$file")) {
continue;
}
// Filter those with correct extension
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)
{
$databases = $this->databaseList();
return in_array($name, $databases);
}
/**
* Empties any cached enum values
*/
public function flushCache()
{
$this->enum_map = array();
}
public function schemaUpdate($callback)
{
// Set locking mode
$this->database->setPragma('locking_mode', 'EXCLUSIVE');
$this->checkAndRepairTable();
$this->flushCache();
// Initiate schema update
$error = null;
try {
parent::schemaUpdate($callback);
} catch (Exception $ex) {
$error = $ex;
}
// Revert locking mode
$this->database->setPragma('locking_mode', SQLite3Database::$default_pragma['locking_mode']);
if ($error) {
throw $error;
}
}
/**
* Empty a specific table
*
* @param string $table
*/
public function clearTable($table)
{
if ($table != 'SQLiteEnums') {
$this->query("DELETE FROM \"$table\"");
}
}
public function createTable($table, $fields = null, $indexes = null, $options = null, $advancedOptions = null)
{
if (!isset($fields['ID'])) {
$fields['ID'] = $this->IdColumn();
}
$fieldSchemata = array();
if ($fields) {
foreach ($fields as $k => $v) {
$fieldSchemata[] = "\"$k\" $v";
}
}
$fieldSchemas = implode(",\n", $fieldSchemata);
// Switch to "CREATE TEMPORARY TABLE" for temporary tables
$temporary = empty($options['temporary']) ? "" : "TEMPORARY";
$this->query("CREATE $temporary TABLE \"$table\" (
$fieldSchemas $fieldSchemas
)"); )");
if($indexes) { if ($indexes) {
foreach($indexes as $indexName => $indexDetails) { foreach ($indexes as $indexName => $indexDetails) {
$this->createIndex($table, $indexName, $indexDetails); $this->createIndex($table, $indexName, $indexDetails);
} }
} }
return $table; return $table;
} }
public function alterTable($tableName, $newFields = null, $newIndexes = null, $alteredFields = null, public function alterTable(
$alteredIndexes = null, $alteredOptions = null, $advancedOptions = null $tableName,
) { $newFields = null,
if($newFields) foreach($newFields as $fieldName => $fieldSpec) { $newIndexes = null,
$this->createField($tableName, $fieldName, $fieldSpec); $alteredFields = null,
} $alteredIndexes = null,
$alteredOptions = null,
$advancedOptions = null
) {
if ($newFields) {
foreach ($newFields as $fieldName => $fieldSpec) {
$this->createField($tableName, $fieldName, $fieldSpec);
}
}
if($alteredFields) foreach($alteredFields as $fieldName => $fieldSpec) { if ($alteredFields) {
$this->alterField($tableName, $fieldName, $fieldSpec); foreach ($alteredFields as $fieldName => $fieldSpec) {
} $this->alterField($tableName, $fieldName, $fieldSpec);
}
}
if($newIndexes) foreach($newIndexes as $indexName => $indexSpec) { if ($newIndexes) {
$this->createIndex($tableName, $indexName, $indexSpec); foreach ($newIndexes as $indexName => $indexSpec) {
} $this->createIndex($tableName, $indexName, $indexSpec);
}
}
if($alteredIndexes) foreach($alteredIndexes as $indexName => $indexSpec) { if ($alteredIndexes) {
$this->alterIndex($tableName, $indexName, $indexSpec); foreach ($alteredIndexes as $indexName => $indexSpec) {
} $this->alterIndex($tableName, $indexName, $indexSpec);
} }
}
public function renameTable($oldTableName, $newTableName) { }
$this->query("ALTER TABLE \"$oldTableName\" RENAME TO \"$newTableName\"");
}
public function checkAndRepairTable($tableName = null) { public function renameTable($oldTableName, $newTableName)
$ok = true; {
$this->query("ALTER TABLE \"$oldTableName\" RENAME TO \"$newTableName\"");
}
if(!SapphireTest::using_temp_db() && !self::$checked_and_repaired) { public function checkAndRepairTable($tableName = null)
$this->alterationMessage("Checking database integrity", "repaired"); {
$ok = true;
// Check for any tables with failed integrity
if($messages = $this->query('PRAGMA integrity_check')) {
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)) {
$this->alterationMessage("VACUUM | $message", "error");
} else {
$this->alterationMessage("VACUUMing", "repaired");
}
}
self::$checked_and_repaired = true;
}
return $ok;
}
public function createField($table, $field, $spec) { if (!self::$checked_and_repaired) {
$this->query("ALTER TABLE \"$table\" ADD \"$field\" $spec"); $this->alterationMessage("Checking database integrity", "repaired");
}
/** // Check for any tables with failed integrity
* Change the database type of the given field. if ($messages = $this->query('PRAGMA integrity_check')) {
* @param string $tableName The name of the tbale the field is in. foreach ($messages as $message) {
* @param string $fieldName The name of the field to change. if ($message['integrity_check'] != 'ok') {
* @param string $fieldSpec The new field specification Debug::show($message['integrity_check']);
*/ $ok = false;
public function alterField($tableName, $fieldName, $fieldSpec) { }
$oldFieldList = $this->fieldList($tableName); }
$fieldNameList = '"' . implode('","', array_keys($oldFieldList)) . '"'; }
if(!empty($_REQUEST['avoidConflict']) && Director::isDev()) { // If enabled vacuum (clean and rebuild) the database
$fieldSpec = preg_replace('/\snot null\s/i', ' NOT NULL ON CONFLICT REPLACE ', $fieldSpec); if (self::$vacuum) {
} $this->query('VACUUM', E_USER_NOTICE);
$message = $this->database->getConnector()->getLastError();
if (preg_match('/authoriz/', $message ?? '')) {
$this->alterationMessage("VACUUM | $message", "error");
} else {
$this->alterationMessage("VACUUMing", "repaired");
}
}
self::$checked_and_repaired = true;
}
// Skip non-existing columns return $ok;
if(!array_key_exists($fieldName, $oldFieldList)) return; }
// Update field spec public function createField($table, $field, $spec)
$newColsSpec = array(); {
foreach($oldFieldList as $name => $oldSpec) { $this->query("ALTER TABLE \"$table\" ADD \"$field\" $spec");
$newColsSpec[] = "\"$name\" " . ($name == $fieldName ? $fieldSpec : $oldSpec); }
}
$queries = array( /**
"BEGIN TRANSACTION", * Change the database type of the given field.
"CREATE TABLE \"{$tableName}_alterfield_{$fieldName}\"(" . implode(',', $newColsSpec) . ")", * @param string $tableName The name of the tbale the field is in.
"INSERT INTO \"{$tableName}_alterfield_{$fieldName}\" SELECT {$fieldNameList} FROM \"$tableName\"", * @param string $fieldName The name of the field to change.
"DROP TABLE \"$tableName\"", * @param string $fieldSpec The new field specification
"ALTER TABLE \"{$tableName}_alterfield_{$fieldName}\" RENAME TO \"$tableName\"", */
"COMMIT" public function alterField($tableName, $fieldName, $fieldSpec)
); {
$oldFieldList = $this->fieldList($tableName);
$fieldNameList = '"' . implode('","', array_keys($oldFieldList)) . '"';
// Remember original indexes if (!empty($_REQUEST['avoidConflict']) && Director::isDev()) {
$indexList = $this->indexList($tableName); $fieldSpec = preg_replace('/\snot null\s/i', ' NOT NULL ON CONFLICT REPLACE ', $fieldSpec);
}
// Then alter the table column
foreach($queries as $query) $this->query($query.';');
// Recreate the indexes // Skip non-existing columns
foreach($indexList as $indexName => $indexSpec) { if (!array_key_exists($fieldName, $oldFieldList)) {
$this->createIndex($tableName, $indexName, $indexSpec); return;
} }
}
public function renameField($tableName, $oldName, $newName) { // Update field spec
$oldFieldList = $this->fieldList($tableName); $newColsSpec = array();
foreach ($oldFieldList as $name => $oldSpec) {
$newColsSpec[] = "\"$name\" " . ($name == $fieldName ? $fieldSpec : $oldSpec);
}
// Skip non-existing columns $queries = array(
if(!array_key_exists($oldName, $oldFieldList)) return; "CREATE TABLE \"{$tableName}_alterfield_{$fieldName}\"(" . implode(',', $newColsSpec) . ")",
"INSERT INTO \"{$tableName}_alterfield_{$fieldName}\" SELECT {$fieldNameList} FROM \"$tableName\"",
// Determine column mappings "DROP TABLE \"$tableName\"",
$oldCols = array(); "ALTER TABLE \"{$tableName}_alterfield_{$fieldName}\" RENAME TO \"$tableName\"",
$newColsSpec = array(); );
foreach($oldFieldList as $name => $spec) {
$oldCols[] = "\"$name\"" . (($name == $oldName) ? " AS $newName" : '');
$newColsSpec[] = "\"" . (($name == $oldName) ? $newName : $name) . "\" $spec";
}
// SQLite doesn't support direct renames through ALTER TABLE // Remember original indexes
$queries = array( $indexList = $this->indexList($tableName);
"BEGIN TRANSACTION",
"CREATE TABLE \"{$tableName}_renamefield_{$oldName}\" (" . implode(',', $newColsSpec) . ")",
"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 // Then alter the table column
$oldIndexList = $this->indexList($tableName); $database = $this->database;
$database->withTransaction(function () use ($database, $queries, $indexList) {
foreach ($queries as $query) {
$database->query($query . ';');
}
});
// Then alter the table column // Recreate the indexes
foreach($queries as $query) $this->query($query.';'); foreach ($indexList as $indexName => $indexSpec) {
$this->createIndex($tableName, $indexName, $indexSpec);
}
}
// Recreate the indexes public function renameField($tableName, $oldName, $newName)
foreach($oldIndexList as $indexName => $indexSpec) { {
// Rename columns to new columns $oldFieldList = $this->fieldList($tableName);
$indexSpec['value'] = preg_replace("/\"$oldName\"/i", "\"$newName\"", $indexSpec['value']);
$this->createIndex($tableName, $indexName, $indexSpec);
}
}
public function fieldList($table) { // Skip non-existing columns
$sqlCreate = $this->preparedQuery( if (!array_key_exists($oldName, $oldFieldList)) {
'SELECT sql FROM sqlite_master WHERE type = ? AND name = ?', return;
array('table', $table) }
)->record();
$fieldList = array();
if($sqlCreate && $sqlCreate['sql']) {
preg_match('/^[\s]*CREATE[\s]+TABLE[\s]+[\'"]?[a-zA-Z0-9_\\\]+[\'"]?[\s]*\((.+)\)[\s]*$/ims',
$sqlCreate['sql'], $matches
);
$fields = isset($matches[1])
? preg_split('/,(?=(?:[^\'"]*$)|(?:[^\'"]*[\'"][^\'"]*[\'"][^\'"]*)*$)/x', $matches[1])
: array();
foreach($fields as $field) {
$details = preg_split('/\s/', trim($field));
$name = array_shift($details);
$name = str_replace('"', '', trim($name));
$fieldList[$name] = implode(' ', $details);
}
}
return $fieldList;
}
/** // Determine column mappings
* Create an index on a table. $oldCols = array();
* $newColsSpec = array();
* @param string $tableName The name of the table. foreach ($oldFieldList as $name => $spec) {
* @param string $indexName The name of the index. $oldCols[] = "\"$name\"" . (($name == $oldName) ? " AS $newName" : '');
* @param array $indexSpec The specification of the index, see Database::requireIndex() for more details. $newColsSpec[] = "\"" . (($name == $oldName) ? $newName : $name) . "\" $spec";
*/ }
public function createIndex($tableName, $indexName, $indexSpec) {
$parsedSpec = $this->parseIndexSpec($indexName, $indexSpec);
$sqliteName = $this->buildSQLiteIndexName($tableName, $indexName);
$columns = $parsedSpec['value'];
$unique = ($parsedSpec['type'] == 'unique') ? 'UNIQUE' : '';
$this->query("CREATE $unique INDEX IF NOT EXISTS \"$sqliteName\" ON \"$tableName\" ($columns)");
}
public function alterIndex($tableName, $indexName, $indexSpec) { // SQLite doesn't support direct renames through ALTER TABLE
// Drop existing index $oldColsStr = implode(',', $oldCols);
$sqliteName = $this->buildSQLiteIndexName($tableName, $indexName); $newColsSpecStr = implode(',', $newColsSpec);
$this->query("DROP INDEX IF EXISTS \"$sqliteName\""); $queries = array(
"CREATE TABLE \"{$tableName}_renamefield_{$oldName}\" ({$newColsSpecStr})",
// Create the index "INSERT INTO \"{$tableName}_renamefield_{$oldName}\" SELECT {$oldColsStr} FROM \"$tableName\"",
$this->createIndex($tableName, $indexName, $indexSpec); "DROP TABLE \"$tableName\"",
} "ALTER TABLE \"{$tableName}_renamefield_{$oldName}\" RENAME TO \"$tableName\"",
);
/**
* Builds the internal SQLLite index name given the silverstripe table and index name.
*
* The name is built using the table and index name in order to prevent name collisions
* between indexes of the same name across multiple tables
*
* @param string $tableName
* @param string $indexName
* @return string The SQLite3 name of the index
*/
protected function buildSQLiteIndexName($tableName, $indexName) {
return "{$tableName}_{$indexName}";
}
protected function parseIndexSpec($name, $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) { // Remember original indexes
$indexList = array(); $oldIndexList = $this->indexList($tableName);
// 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';
// Determine a clean list of column names within this index
$list = array();
foreach($this->query("PRAGMA index_info(\"$indexName\")") as $details) {
$list[] = preg_replace('/^"?(.*)"?$/', '$1', $details['name']);
}
// Safely encode this spec
$indexList[$indexName] = $this->parseIndexSpec($indexName, array(
'name' => $indexName,
'value' => $this->implodeColumnList($list),
'type' => $indexType
));
}
return $indexList; // Then alter the table column
} $database = $this->database;
$database->withTransaction(function () use ($database, $queries) {
foreach ($queries as $query) {
$database->query($query . ';');
}
});
public function tableList() { // Recreate the indexes
$tables = array(); foreach ($oldIndexList as $indexName => $indexSpec) {
$result = $this->preparedQuery('SELECT name FROM sqlite_master WHERE type = ?', array('table')); // Map index columns
foreach($result as $record) { $columns = array_filter(array_map(function ($column) use ($newName, $oldName) {
$table = reset($record); // Unchanged
$tables[strtolower($table)] = $table; if ($column !== $oldName) {
} return $column;
return $tables; }
} // Skip obsolete fields
if (stripos($newName, '_obsolete_') === 0) {
/** return null;
* Return a boolean type-formatted string }
* return $newName;
* @params array $values Contains a tokenised list of info about this data type }, $indexSpec['columns']));
* @return string
*/
public function boolean($values) {
$default = empty($values['default']) ? 0 : (int)$values['default'];
return "BOOL NOT NULL DEFAULT $default";
}
/** // Create index if column count unchanged
* Return a date type-formatted string if (count($columns) === count($indexSpec['columns'])) {
* $indexSpec['columns'] = $columns;
* @params array $values Contains a tokenised list of info about this data type $this->createIndex($tableName, $indexName, $indexSpec);
* @return string }
*/ }
public function date($values){ }
return "TEXT";
}
/** public function fieldList($table)
* Return a decimal type-formatted string {
* $sqlCreate = $this->preparedQuery(
* @params array $values Contains a tokenised list of info about this data type 'SELECT "sql" FROM "sqlite_master" WHERE "type" = ? AND "name" = ?',
* @return string array('table', $table)
*/ )->record();
public function decimal($values, $asDbValue = false) {
$default = isset($values['default']) && is_numeric($values['default']) ? $values['default'] : 0;
return "NUMERIC NOT NULL DEFAULT $default";
}
/** $fieldList = array();
* Cached list of enum values indexed by table.column if ($sqlCreate && $sqlCreate['sql']) {
* preg_match(
* @var array '/^[\s]*CREATE[\s]+TABLE[\s]+[\'"]?[a-zA-Z0-9_\\\]+[\'"]?[\s]*\((.+)\)[\s]*$/ims',
*/ $sqlCreate['sql'] ?? '',
protected $enum_map = array(); $matches
);
/** $fields = isset($matches[1])
* Return a enum type-formatted string ? preg_split('/,(?=(?:[^\'"]*$)|(?:[^\'"]*[\'"][^\'"]*[\'"][^\'"]*)*$)/x', $matches[1])
* : array();
* enums are not supported. as a workaround to store allowed values we creates an additional table foreach ($fields as $field) {
* $details = preg_split('/\s/', trim($field));
* @params array $values Contains a tokenised list of info about this data type $name = array_shift($details);
* @return string $name = str_replace('"', '', trim($name));
*/ $fieldList[$name] = implode(' ', $details);
public function enum($values){ }
$tablefield = $values['table'] . '.' . $values['name']; }
$enumValues = implode(',', $values['enums']); return $fieldList;
}
// Ensure the cache table exists
if(empty($this->enum_map)) {
$this->query("CREATE TABLE IF NOT EXISTS \"SQLiteEnums\" (\"TableColumn\" TEXT PRIMARY KEY, \"EnumList\" TEXT)");
}
// Ensure the table row exists
if(empty($this->enum_map[$tablefield]) || $this->enum_map[$tablefield] != $enumValues) {
$this->preparedQuery(
"REPLACE INTO SQLiteEnums (TableColumn, EnumList) VALUES (?, ?)",
array($tablefield, $enumValues)
);
$this->enum_map[$tablefield] = $enumValues;
}
// Set default
if(!empty($values['default'])) {
$default = str_replace(array('"',"'","\\","\0"), "", $values['default']);
return "TEXT DEFAULT '$default'";
} else {
return 'TEXT';
}
}
/**
* Return a set type-formatted string
* This type doesn't exist in SQLite either
*
* @see SQLite3SchemaManager::enum()
*
* @params array $values Contains a tokenised list of info about this data type
* @return string
*/
public function set($values) {
return $this->enum($values);
}
/** /**
* Return a float type-formatted string * Create an index on a table.
* *
* @params array $values Contains a tokenised list of info about this data type * @param string $tableName The name of the table.
* @return string * @param string $indexName The name of the index.
*/ * @param array $indexSpec The specification of the index, see Database::requireIndex() for more details.
public function float($values, $asDbValue = false){ */
return "REAL"; public function createIndex($tableName, $indexName, $indexSpec)
} {
$sqliteName = $this->buildSQLiteIndexName($tableName, $indexName);
$columns = $this->implodeColumnList($indexSpec['columns']);
$unique = ($indexSpec['type'] == 'unique') ? 'UNIQUE' : '';
$this->query("CREATE $unique INDEX IF NOT EXISTS \"$sqliteName\" ON \"$tableName\" ($columns)");
}
/** public function alterIndex($tableName, $indexName, $indexSpec)
* Return a Double type-formatted string {
* // Drop existing index
* @params array $values Contains a tokenised list of info about this data type $sqliteName = $this->buildSQLiteIndexName($tableName, $indexName);
* @return string $this->query("DROP INDEX IF EXISTS \"$sqliteName\"");
*/
public function double($values, $asDbValue = false){
return "REAL";
}
/** // Create the index
* Return a int type-formatted string $this->createIndex($tableName, $indexName, $indexSpec);
* }
* @params array $values Contains a tokenised list of info about this data type
* @return string
*/
public function int($values, $asDbValue = false){
return "INTEGER({$values['precision']}) " . strtoupper($values['null']) . " DEFAULT " . (int)$values['default'];
}
/** /**
* Return a bigint type-formatted string * Builds the internal SQLLite index name given the silverstripe table and index name.
* *
* @params array $values Contains a tokenised list of info about this data type * The name is built using the table and index name in order to prevent name collisions
* @return string * between indexes of the same name across multiple tables
*/ *
public function bigint($values, $asDbValue = false){ * @param string $tableName
return $this->int($values, $asDbValue); * @param string $indexName
} * @return string The SQLite3 name of the index
*/
protected function buildSQLiteIndexName($tableName, $indexName)
{
return "{$tableName}_{$indexName}";
}
/** public function indexKey($table, $index, $spec)
* Return a datetime type-formatted string {
* For SQLite3, we simply return the word 'TEXT', no other parameters are necessary return $this->buildSQLiteIndexName($table, $index);
* }
* @params array $values Contains a tokenised list of info about this data type
* @return string
*/
public function ss_datetime($values, $asDbValue = false) {
return "DATETIME";
}
/** protected function convertIndexSpec($indexSpec)
* Return a text type-formatted string {
* $supportedIndexTypes = ['index', 'unique'];
* @params array $values Contains a tokenised list of info about this data type if (isset($indexSpec['type']) && !in_array($indexSpec['type'], $supportedIndexTypes)) {
* @return string $indexSpec['type'] = 'index';
*/ }
public function text($values, $asDbValue = false) { return parent::convertIndexSpec($indexSpec);
return 'TEXT'; }
}
/** public function indexList($table)
* Return a time type-formatted string {
* $indexList = array();
* @params array $values Contains a tokenised list of info about this data type
* @return string
*/
public function time($values) {
return "TEXT";
}
/** // Enumerate each index and related fields
* Return a varchar type-formatted string foreach ($this->query("PRAGMA index_list(\"$table\")") as $index) {
* // The SQLite internal index name, not the actual Silverstripe name
* @params array $values Contains a tokenised list of info about this data type $indexName = $index["name"];
* @return string $indexType = $index['unique'] ? 'unique' : 'index';
*/
public function varchar($values, $asDbValue = false) {
return "VARCHAR({$values['precision']}) COLLATE NOCASE";
}
/* // Determine a clean list of column names within this index
* Return a 4 digit numeric type. MySQL has a proprietary 'Year' type. $list = array();
* For SQLite3 we use TEXT foreach ($this->query("PRAGMA index_info(\"$indexName\")") as $details) {
*/ $list[] = preg_replace('/^"?(.*)"?$/', '$1', $details['name']);
public function year($values, $asDbValue = false){ }
return "TEXT";
}
public function IdColumn($asDbValue = false, $hasAutoIncPK = true){ // Safely encode this spec
return 'INTEGER PRIMARY KEY AUTOINCREMENT'; $indexList[$indexName] = array(
} 'name' => $indexName,
'columns' => $list,
'type' => $indexType,
);
}
function hasTable($tableName) { return $indexList;
return (bool)$this->preparedQuery( }
'SELECT name FROM sqlite_master WHERE type = ? AND name = ?',
array('table', $tableName)
)->first();
}
/** public function tableList()
* Return enum values for the given field {
* $tables = array();
* @return array $result = $this->preparedQuery('SELECT name FROM sqlite_master WHERE type = ?', array('table'));
*/ foreach ($result as $record) {
public function enumValuesForField($tableName, $fieldName) { $table = reset($record);
$tablefield = "$tableName.$fieldName"; $tables[strtolower($table)] = $table;
}
// Check already cached values for this field return $tables;
if(!empty($this->enum_map[$tablefield])) { }
return explode(',', $this->enum_map[$tablefield]);
} /**
* Return a boolean type-formatted string
// Retrieve and cache these details from the database *
$classnameinfo = $this->preparedQuery( * @param array $values Contains a tokenised list of info about this data type
"SELECT EnumList FROM SQLiteEnums WHERE TableColumn = ?", * @return string
array($tablefield) */
)->first(); public function boolean($values)
if($classnameinfo) { {
$valueList = $classnameinfo['EnumList']; $default = empty($values['default']) ? 0 : (int)$values['default'];
$this->enum_map[$tablefield] = $valueList; return "BOOL NOT NULL DEFAULT $default";
return explode(',', $valueList); }
}
/**
// Fallback to empty list * Return a date type-formatted string
return array(); *
} * @param array $values Contains a tokenised list of info about this data type
* @return string
function dbDataType($type){ */
$values = array( public function date($values)
'unsigned integer' => 'INT' {
); return "TEXT";
}
if(isset($values[$type])) return $values[$type];
else return ''; /**
} * Return a decimal type-formatted string
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function decimal($values)
{
$default = isset($values['default']) && is_numeric($values['default']) ? $values['default'] : 0;
return "NUMERIC NOT NULL DEFAULT $default";
}
/**
* Cached list of enum values indexed by table.column
*
* @var array
*/
protected $enum_map = array();
/**
* Return a enum type-formatted string
*
* enums are not supported. as a workaround to store allowed values we creates an additional table
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
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)"
);
}
// Ensure the table row exists
if (empty($this->enum_map[$tablefield]) || $this->enum_map[$tablefield] != $enumValues) {
$this->preparedQuery(
"REPLACE INTO SQLiteEnums (TableColumn, EnumList) VALUES (?, ?)",
array($tablefield, $enumValues)
);
$this->enum_map[$tablefield] = $enumValues;
}
// Set default
if (!empty($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';
}
}
/**
* Return a set type-formatted string
* This type doesn't exist in SQLite either
*
* @see SQLite3SchemaManager::enum()
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function set($values)
{
return $this->enum($values);
}
/**
* Return a float type-formatted string
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function float($values)
{
return "REAL";
}
/**
* Return a Double type-formatted string
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function double($values)
{
return "REAL";
}
/**
* Return a int type-formatted string
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function int($values)
{
return "INTEGER({$values['precision']}) " . strtoupper($values['null']) . " DEFAULT " . (int)$values['default'];
}
/**
* Return a bigint type-formatted string
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function bigint($values)
{
return $this->int($values);
}
/**
* Return a datetime type-formatted string
* For SQLite3, we simply return the word 'TEXT', no other parameters are necessary
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function datetime($values)
{
return "DATETIME";
}
/**
* Return a text type-formatted string
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function text($values)
{
return 'TEXT';
}
/**
* Return a time type-formatted string
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function time($values)
{
return "TEXT";
}
/**
* Return a varchar type-formatted string
*
* @param array $values Contains a tokenised list of info about this data type
* @return string
*/
public function varchar($values)
{
return "VARCHAR({$values['precision']}) COLLATE NOCASE";
}
/*
* Return a 4 digit numeric type. MySQL has a proprietary 'Year' type.
* For SQLite3 we use TEXT
*/
public function year($values, $asDbValue = false)
{
return "TEXT";
}
public function IdColumn($asDbValue = false, $hasAutoIncPK = true)
{
return 'INTEGER PRIMARY KEY AUTOINCREMENT';
}
public function hasTable($tableName)
{
return (bool)$this->preparedQuery(
'SELECT "name" FROM "sqlite_master" WHERE "type" = ? AND "name" = ?',
array('table', $tableName)
)->first();
}
/**
* Return enum values for the given field
*
* @param string $tableName
* @param string $fieldName
* @return array
*/
public function enumValuesForField($tableName, $fieldName)
{
$tablefield = "$tableName.$fieldName";
// Check already cached values for this field
if (!empty($this->enum_map[$tablefield])) {
return explode(',', $this->enum_map[$tablefield]);
}
// Retrieve and cache these details from the database
$classnameinfo = $this->preparedQuery(
"SELECT EnumList FROM SQLiteEnums WHERE TableColumn = ?",
array($tablefield)
)->first();
if ($classnameinfo) {
$valueList = $classnameinfo['EnumList'];
$this->enum_map[$tablefield] = $valueList;
return explode(',', $valueList);
}
// Fallback to empty list
return array();
}
public function dbDataType($type)
{
$values = array(
'unsigned integer' => 'INT'
);
if (isset($values[$type])) {
return $values[$type];
} else {
return '';
}
}
} }

View File

@ -1,207 +1,238 @@
<?php <?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. * This is a helper class for the SS installer.
* *
* It does all the specific checking for SQLiteDatabase * It does all the specific checking for SQLiteDatabase
* to ensure that the configuration is setup correctly. * 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
*
* @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) {
$error = null;
try {
if(!file_exists($databaseConfig['path'])) {
self::create_db_dir($databaseConfig['path']);
self::secure_db_dir($databaseConfig['path']);
}
$file = $databaseConfig['path'] . '/' . $databaseConfig['database'];
$conn = null;
switch($databaseConfig['type']) {
case 'SQLite3Database':
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']);
}
break;
case 'SQLite3PDODatabase':
// May throw a PDOException if fails
$conn = @new PDO("sqlite:$file");
break;
default:
$error = 'Invalid connection type';
return null;
}
if($conn) {
return $conn;
} else {
$error = 'Unknown connection error';
return null;
}
} catch(Exception $ex) {
$error = $ex->getMessage();
return null;
}
}
public function requireDatabaseFunctions($databaseConfig) {
$data = DatabaseAdapterRegistry::get_adapter($databaseConfig['type']);
return !empty($data['supported']);
}
public function requireDatabaseServer($databaseConfig) { /**
$path = $databaseConfig['path']; * Create a connection of the appropriate type
$error = ''; *
$success = false; * @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)
{
$error = null;
try {
if (!file_exists($databaseConfig['path'])) {
self::create_db_dir($databaseConfig['path']);
self::secure_db_dir($databaseConfig['path']);
}
$file = $databaseConfig['path'] . '/' . $databaseConfig['database'];
$conn = null;
if(!$path) { switch ($databaseConfig['type']) {
$error = 'No database path provided'; case 'SQLite3Database':
} elseif(is_writable($path) || (!file_exists($path) && is_writable(dirname($path)))) { if (empty($databaseConfig['key'])) {
// check if folder is writeable $conn = @new SQLite3($file, SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE);
$success = true; } else {
} else { $conn = @new SQLite3(
$error = "Permission denied"; $file,
} SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE,
$databaseConfig['key']
);
}
break;
case 'SQLite3PDODatabase':
// May throw a PDOException if fails
$conn = @new PDO("sqlite:$file");
break;
default:
$error = 'Invalid connection type: ' . $databaseConfig['type'];
return null;
}
return array( if ($conn) {
'success' => $success, return $conn;
'error' => $error, } else {
'path' => $path $error = 'Unknown connection error';
); return null;
} }
} catch (Exception $ex) {
$error = $ex->getMessage();
return null;
}
}
/** public function requireDatabaseFunctions($databaseConfig)
* Ensure a database connection is possible using credentials provided. {
* $data = DatabaseAdapterRegistry::get_adapter($databaseConfig['type']);
* @todo Validate path return !empty($data['supported']);
* }
* @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) {
// Do additional validation around file paths
if(empty($databaseConfig['path'])) return array(
'success' => false,
'error' => "Missing directory path"
);
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(
'success' => false,
'error' => sprintf('Cannot create path: "%s"', $path)
);
$dirSecured = self::secure_db_dir($path);
if(!$dirSecured) return array(
'success' => false,
'error' => sprintf('Cannot secure path through .htaccess: "%s"', $path)
);
$conn = $this->createConnection($databaseConfig, $error); public function requireDatabaseServer($databaseConfig)
$success = !empty($conn); {
$path = $databaseConfig['path'];
return array( $error = '';
'success' => $success, $success = false;
'connection' => $conn,
'error' => $error
);
}
public function getDatabaseVersion($databaseConfig) { if (!$path) {
$version = 0; $error = 'No database path provided';
} elseif (is_writable($path) || (!file_exists($path) && is_writable(dirname($path)))) {
switch($databaseConfig['type']) { // check if folder is writeable
case 'SQLite3Database': $success = true;
$info = SQLite3::version(); } else {
$version = trim($info['versionString']); $error = "Permission denied";
break; }
case 'SQLite3PDODatabase':
// Fallback to using sqlite_version() query
$conn = $this->createConnection($databaseConfig, $error);
if($conn) {
$version = $conn->getAttribute(PDO::ATTR_SERVER_VERSION);
}
break;
}
return $version; return array(
} 'success' => $success,
'error' => $error,
'path' => $path
);
}
public function requireDatabaseVersion($databaseConfig) { /**
$success = false; * Ensure a database connection is possible using credentials provided.
$error = ''; *
$version = $this->getDatabaseVersion($databaseConfig); * @todo Validate path
*
* @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)
{
// Do additional validation around file paths
if (empty($databaseConfig['path'])) {
return array(
'success' => false,
'error' => "Missing directory path"
);
}
if (empty($databaseConfig['database'])) {
return array(
'success' => false,
'error' => "Missing database filename"
);
}
if($version) { // Create and secure db directory
$success = version_compare($version, '3.3', '>='); $path = $databaseConfig['path'];
if(!$success) { $dirCreated = self::create_db_dir($path);
$error = "Your SQLite3 library version is $version. It's recommended you use at least 3.3."; if (!$dirCreated) {
} return array(
} 'success' => false,
'error' => sprintf('Cannot create path: "%s"', $path)
);
}
$dirSecured = self::secure_db_dir($path);
if (!$dirSecured) {
return array(
'success' => false,
'error' => sprintf('Cannot secure path through .htaccess: "%s"', $path)
);
}
return array( $conn = $this->createConnection($databaseConfig, $error);
'success' => $success, $success = !empty($conn);
'error' => $error
);
}
public function requireDatabaseOrCreatePermissions($databaseConfig) { return array(
$conn = $this->createConnection($databaseConfig, $error); 'success' => $success,
$success = $alreadyExists = !empty($conn); 'connection' => $conn,
return array( 'error' => $error
'success' => $success, );
'alreadyExists' => $alreadyExists, }
);
} public function getDatabaseVersion($databaseConfig)
{
/** $version = 0;
* Creates the provided directory and prepares it for
* storing SQLlite. Use {@link secure_db_dir()} to /** @skipUpgrade */
* secure it against unauthorized access. switch ($databaseConfig['type']) {
* case 'SQLite3Database':
* @param String $path Absolute path, usually with a hidden folder. $info = SQLite3::version();
* @return boolean $version = trim($info['versionString']);
*/ break;
public static function create_db_dir($path) { case 'SQLite3PDODatabase':
return file_exists($path) || mkdir($path); // Fallback to using sqlite_version() query
} $conn = $this->createConnection($databaseConfig, $error);
if ($conn) {
/** $version = $conn->getAttribute(PDO::ATTR_SERVER_VERSION);
* Secure the provided directory via web-access }
* by placing a .htaccess file in it. break;
* This is just required if the database directory }
* is placed within a publically accessible webroot (the
* default path is in a hidden folder within assets/). return $version;
* }
* @param String $path Absolute path, containing a SQLite datatbase
* @return boolean public function requireDatabaseVersion($databaseConfig)
*/ {
public static function secure_db_dir($path) { $success = false;
return (is_writeable($path)) ? file_put_contents($path . '/.htaccess', 'deny from all') : false; $error = '';
} $version = $this->getDatabaseVersion($databaseConfig);
public function requireDatabaseAlterPermissions($databaseConfig) { if ($version) {
// no concept of table-specific permissions; If you can connect you can alter schema $success = version_compare($version, '3.3', '>=');
return array( if (!$success) {
'success' => true, $error = "Your SQLite3 library version is $version. It's recommended you use at least 3.3.";
'applies' => false }
); }
}
return array(
'success' => $success,
'error' => $error
);
}
public function requireDatabaseOrCreatePermissions($databaseConfig)
{
$conn = $this->createConnection($databaseConfig, $error);
$success = $alreadyExists = !empty($conn);
return array(
'success' => $success,
'alreadyExists' => $alreadyExists,
);
}
/**
* Creates the provided directory and prepares it for
* storing SQLlite. Use {@link secure_db_dir()} to
* secure it against unauthorized access.
*
* @param String $path Absolute path, usually with a hidden folder.
* @return boolean
*/
public static function create_db_dir($path)
{
return file_exists($path) || mkdir($path);
}
/**
* Secure the provided directory via web-access
* by placing a .htaccess file in it.
* This is just required if the database directory
* is placed within a publically accessible webroot (the
* default path is in a hidden folder within assets/).
*
* @param String $path Absolute path, containing a SQLite datatbase
* @return boolean
*/
public static function secure_db_dir($path)
{
return (is_writeable($path)) ? file_put_contents($path . '/.htaccess', 'deny from all') : false;
}
public function requireDatabaseAlterPermissions($databaseConfig)
{
// no concept of table-specific permissions; If you can connect you can alter schema
return array(
'success' => true,
'applies' => false
);
}
} }

View File

@ -1,7 +1,7 @@
{ {
"name": "silverstripe/sqlite3", "name": "silverstripe/sqlite3",
"description": "Adds SQLite3 support to SilverStripe", "description": "Adds SQLite3 support to SilverStripe",
"type": "silverstripe-module", "type": "silverstripe-vendormodule",
"keywords": ["silverstripe", "sqlite3", "database"], "keywords": ["silverstripe", "sqlite3", "database"],
"authors": [ "authors": [
{ {
@ -14,11 +14,21 @@
} }
], ],
"require": { "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
} }

12
phpcs.xml.dist Normal file
View File

@ -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>