mirror of
https://github.com/silverstripe/silverstripe-postgresql
synced 2024-10-22 17:05:45 +02:00
b148e2457c
This issue causes pagination to fail for search results on sites using the postgres db. Patch corrects the TotalItems in the returned List to show all items matching the search criteria rather than just the items returned in the current 'page' requested.
2296 lines
74 KiB
PHP
2296 lines
74 KiB
PHP
<?php
|
|
|
|
/**
|
|
* @package sapphire
|
|
* @subpackage model
|
|
*/
|
|
|
|
/**
|
|
* PostgreSQL connector class.
|
|
* @package sapphire
|
|
* @subpackage model
|
|
*/
|
|
class PostgreSQLDatabase extends SS_Database {
|
|
|
|
/**
|
|
* Connection to the DBMS.
|
|
* @var resource
|
|
*/
|
|
private $dbConn;
|
|
|
|
/**
|
|
* True if we are connected to a database.
|
|
* @var boolean
|
|
*/
|
|
private $active;
|
|
|
|
/**
|
|
* The name of the database.
|
|
* @var string
|
|
*/
|
|
private $database;
|
|
|
|
/*
|
|
* This holds the name of the original database
|
|
* So if you switch to another for unit tests, you
|
|
* can then switch back in order to drop the temp database
|
|
*/
|
|
private $database_original;
|
|
|
|
/**
|
|
* The database schema name.
|
|
* @var string
|
|
*/
|
|
private $schema;
|
|
|
|
/*
|
|
* This holds the parameters that the original connection was created with,
|
|
* so we can switch back to it if necessary (used for unit tests)
|
|
*/
|
|
private $parameters;
|
|
|
|
/*
|
|
* These two values describe how T-search will work.
|
|
* You can use either GiST or GIN, and '@@' (gist) or '@@@' (gin)
|
|
* Combinations of these two will also work, so you'll need to pick
|
|
* one which works best for you
|
|
*/
|
|
public $default_fts_cluster_method='GIN';
|
|
public $default_fts_search_method='@@@';
|
|
|
|
private $supportsTransactions=true;
|
|
|
|
/**
|
|
* Determines whether to check a database exists on the host by
|
|
* querying the 'postgres' database and running createDatabase.
|
|
*
|
|
* Some locked down systems prevent access to the 'postgres' table in
|
|
* which case you need to set this to false.
|
|
*/
|
|
public static $check_database_exists = true;
|
|
|
|
/**
|
|
* This holds a copy of all the constraint results that are returned
|
|
* via the function constraintExists(). This is a bit faster than
|
|
* repeatedly querying this column, and should allow the database
|
|
* to use it's built-in caching features for better queries.
|
|
*
|
|
* @var array
|
|
*/
|
|
private static $cached_constraints=array();
|
|
|
|
/**
|
|
*
|
|
* This holds a copy of all the queries that run through the function orderMoreSpecifically()
|
|
* It appears to be a performance bottleneck at times.
|
|
*
|
|
* @var array
|
|
*/
|
|
private static $cached_ordered_specifically=array();
|
|
|
|
/**
|
|
*
|
|
* This holds a copy of all the queries that run through the function fieldList()
|
|
* This is one of the most-often called functions, and repeats itself a great deal in the unit tests.
|
|
*
|
|
* @var array
|
|
*/
|
|
private static $cached_fieldlists=array();
|
|
|
|
/**
|
|
* Override the language that tsearch uses. By default it is 'english, but
|
|
* could be any of the supported languages that can be found in the
|
|
* pg_catalog.pg_ts_config table.
|
|
*
|
|
* @var string
|
|
*/
|
|
private $search_language='english';
|
|
|
|
/**
|
|
* Connect to a PostgreSQL database.
|
|
* @param array $parameters An map of parameters, which should include:
|
|
* - server: The server, eg, localhost
|
|
* - username: The username to log on with
|
|
* - password: The password to log on with
|
|
* - database: The database to connect to
|
|
*/
|
|
public function __construct($parameters) {
|
|
|
|
//We will store these connection parameters for use elsewhere (ie, unit tests)
|
|
$this->parameters=$parameters;
|
|
$this->connectDatabase();
|
|
|
|
$this->database_original=$this->database;
|
|
}
|
|
|
|
/*
|
|
* Uses whatever connection details are in the $parameters array to connect to a database of a given name
|
|
*/
|
|
function connectDatabase(){
|
|
|
|
$parameters=$this->parameters;
|
|
|
|
if(!$parameters)
|
|
return false;
|
|
|
|
($parameters['username']!='') ? $username=' user=' . $parameters['username'] : $username='';
|
|
($parameters['password']!='') ? $password=' password=\'' . $parameters['password'] . '\'' : $password='';
|
|
|
|
if(!isset($this->database))
|
|
$dbName=$parameters['database'];
|
|
else $dbName=$this->database;
|
|
|
|
$port = empty($parameters['port']) ? 5432 : $parameters['port'];
|
|
|
|
// First, we need to check that this database exists. To do this, we will connect to the 'postgres' database first
|
|
// some setups prevent access to this database so set PostgreSQLDatabase::$check_database_exists = false
|
|
if(self::$check_database_exists) {
|
|
// Close the old connection
|
|
if($this->dbConn) pg_close($this->dbConn);
|
|
$this->dbConn = pg_connect('host=' . $parameters['server'] . ' port=' . $port . ' dbname=postgres' . $username . $password);
|
|
|
|
if(!$this->dbConn) {
|
|
throw new ErrorException("Couldn't connect to PostgreSQL database");
|
|
} elseif(pg_connection_status($this->dbConn) != PGSQL_CONNECTION_OK) {
|
|
throw new ErrorException(pg_last_error($this->dbConn));
|
|
}
|
|
|
|
if(!$this->databaseExists($dbName)) {
|
|
$this->createDatabase($dbName);
|
|
}
|
|
}
|
|
|
|
// Close the old connection
|
|
if($this->dbConn) pg_close($this->dbConn);
|
|
|
|
//Now we can be sure that this database exists, so we can connect to it
|
|
$this->dbConn = pg_connect('host=' . $parameters['server'] . ' port=' . $port . ' dbname=' . $dbName . $username . $password);
|
|
|
|
if(!$this->dbConn) {
|
|
throw new ErrorException("Couldn't connect to PostgreSQL database");
|
|
} elseif(pg_connection_status($this->dbConn) != PGSQL_CONNECTION_OK) {
|
|
throw new ErrorException(pg_last_error($this->dbConn));
|
|
}
|
|
|
|
//By virtue of getting here, the connection is active:
|
|
$this->active=true;
|
|
$this->database = $dbName;
|
|
|
|
// Set up the schema if required
|
|
$schema = isset($parameters['schema']) ? $parameters['schema'] : $this->currentSchema();
|
|
// Edge-case - database with no schemas:
|
|
if(!$schema) $schema = "public";
|
|
|
|
if(!$this->schemaExists($schema))
|
|
$this->createSchema($schema);
|
|
|
|
$this->setSchema($schema);
|
|
|
|
// Set the timezone if required.
|
|
if(isset($parameters['timezone'])) $this->query(sprintf("SET SESSION TIME ZONE '%s'", $parameters['timezone']));
|
|
|
|
return true;
|
|
}
|
|
/**
|
|
* Not implemented, needed for PDO
|
|
*/
|
|
public function getConnect($parameters) {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Return the parameters used to construct this database connection
|
|
*/
|
|
public function getParameters() {
|
|
return $this->parameters;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this database supports collations
|
|
* TODO: get rid of this?
|
|
* @return boolean
|
|
*/
|
|
public function supportsCollations() {
|
|
return true;
|
|
}
|
|
|
|
public function supportsTimezoneOverride() {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get the version of PostgreSQL.
|
|
* @return string
|
|
*/
|
|
public function getVersion() {
|
|
$version = pg_version($this->dbConn);
|
|
if(isset($version['server'])) return $version['server'];
|
|
else return false;
|
|
}
|
|
|
|
/**
|
|
* Get the database server, namely PostgreSQL.
|
|
* @return string
|
|
*/
|
|
public function getDatabaseServer() {
|
|
return "postgresql";
|
|
}
|
|
|
|
public function query($sql, $errorLevel = E_USER_ERROR) {
|
|
|
|
if(isset($_REQUEST['previewwrite']) && in_array(strtolower(substr($sql,0,strpos($sql,' '))), array('insert','update','delete','replace'))) {
|
|
Debug::message("Will execute: $sql");
|
|
return;
|
|
}
|
|
|
|
if(isset($_REQUEST['showqueries'])) {
|
|
$starttime = microtime(true);
|
|
}
|
|
|
|
$handle = pg_query($this->dbConn, $sql);
|
|
|
|
if(isset($_REQUEST['showqueries'])) {
|
|
$endtime = round((microtime(true) - $starttime) * 1000, 1);
|
|
Debug::message("\n$sql\n{$endtime}ms\n", false);
|
|
}
|
|
|
|
DB::$lastQuery=$handle;
|
|
|
|
if(!$handle && $errorLevel) $this->databaseError("Couldn't run query: $sql | " . pg_last_error($this->dbConn), $errorLevel);
|
|
|
|
return new PostgreSQLQuery($this, $handle);
|
|
}
|
|
|
|
public function getGeneratedID($table) {
|
|
$result=DB::query("SELECT last_value FROM \"{$table}_ID_seq\";");
|
|
$row=$result->first();
|
|
return $row['last_value'];
|
|
}
|
|
|
|
/**
|
|
* OBSOLETE: Get the ID for the next new record for the table.
|
|
*
|
|
* @var string $table The name od the table.
|
|
* @return int
|
|
*/
|
|
public function getNextID($table) {
|
|
user_error('getNextID is OBSOLETE (and will no longer work properly)', E_USER_WARNING);
|
|
$result = $this->query("SELECT MAX(ID)+1 FROM \"$table\"")->value();
|
|
return $result ? $result : 1;
|
|
}
|
|
|
|
public function isActive() {
|
|
return $this->active ? true : false;
|
|
}
|
|
|
|
/*
|
|
* You can create a database based either on a supplied name, or from whatever is in the $this->database value
|
|
*/
|
|
public function createDatabase($name=false) {
|
|
if(!$name)
|
|
$name=$this->database;
|
|
|
|
$this->query("CREATE DATABASE \"$name\";");
|
|
|
|
$this->connectDatabase();
|
|
|
|
}
|
|
|
|
/**
|
|
* Drop the database that this object is currently connected to.
|
|
* Use with caution.
|
|
*/
|
|
public function dropDatabase() {
|
|
|
|
//First, we need to switch back to the original database so we can drop the current one
|
|
$db_to_drop=$this->database;
|
|
$this->selectDatabase($this->database_original);
|
|
|
|
$this->query("DROP DATABASE \"$db_to_drop\"");
|
|
}
|
|
|
|
/**
|
|
* Drop the database that this object is currently connected to.
|
|
* Use with caution.
|
|
*/
|
|
public function dropDatabaseByName($dbName) {
|
|
if($dbName!=$this->database)
|
|
$this->query("DROP DATABASE \"$dbName\";");
|
|
}
|
|
|
|
/**
|
|
* Returns the name of the currently selected database
|
|
*/
|
|
public function currentDatabase() {
|
|
return $this->database;
|
|
}
|
|
|
|
/**
|
|
* Switches to the given database.
|
|
* If the database doesn't exist, you should call createDatabase() after calling selectDatabase()
|
|
*/
|
|
public function selectDatabase($dbname) {
|
|
$parameters=$this->parameters;
|
|
($parameters['username']!='') ? $username=' user=' . $parameters['username'] : $username='';
|
|
($parameters['password']!='') ? $password=' password=\'' . $parameters['password'] . '\'' : $password='';
|
|
|
|
$port = empty($parameters['port']) ? 5432 : $parameters['port'];
|
|
|
|
$this->database = $dbname;
|
|
$this->tableList = $this->fieldList = $this->indexList = null;
|
|
|
|
// Switch to the database if it exists
|
|
if($this->databaseExists($dbname)) {
|
|
// Close old connection
|
|
if($this->dbConn) pg_close($this->dbConn);
|
|
$this->dbConn = pg_connect('host=' . $parameters['server'] . ' port=' . $port . ' dbname=' . $dbname . $username . $password);
|
|
|
|
if(!$this->dbConn) {
|
|
throw new ErrorException("Couldn't connect to PostgreSQL database");
|
|
} elseif(pg_connection_status($this->dbConn) != PGSQL_CONNECTION_OK) {
|
|
throw new ErrorException(pg_last_error($this->dbConn));
|
|
}
|
|
|
|
// Determine schema to use
|
|
$schema = isset($parameters['schema']) ? $parameters['schema'] : $this->currentSchema();
|
|
if(!$schema) $schema = "public";
|
|
|
|
// Choose the schema
|
|
if(!$this->schemaExists($schema)) $this->createSchema($schema);
|
|
$this->setSchema($schema);
|
|
|
|
// Set the timezone if required.
|
|
if(isset($parameters['timezone'])) $this->query(sprintf("SET SESSION TIME ZONE '%s'", $parameters['timezone']));
|
|
|
|
// Inactive database needs to be created; connect to the 'postgres' database in the meantime
|
|
} else {
|
|
// Close old connection
|
|
if($this->dbConn) pg_close($this->dbConn);
|
|
$this->dbConn = pg_connect('host=' . $parameters['server'] . ' port=' . $port . ' dbname=postgres' . $username . $password);
|
|
$this->active = false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns true if the named database exists.
|
|
*/
|
|
public function databaseExists($name) {
|
|
$SQL_name=$this->addslashes($name);
|
|
return $this->query("SELECT datname FROM pg_database WHERE datname='$SQL_name';")->first() ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Returns a column
|
|
*/
|
|
public function allDatabaseNames() {
|
|
return $this->query("SELECT datname FROM pg_database WHERE datistemplate=false;")->column();
|
|
}
|
|
|
|
/**
|
|
* Returns true if the schema exists in the current database
|
|
* @param string $name
|
|
* @return boolean
|
|
*/
|
|
public function schemaExists($name) {
|
|
$SQL_name = pg_escape_string($this->dbConn, $name);
|
|
return $this->query("SELECT nspname FROM pg_catalog.pg_namespace WHERE nspname = '{$SQL_name}';")->first() ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Creates a schema in the current database
|
|
* @param string $name
|
|
*/
|
|
public function createSchema($name) {
|
|
$SQL_name = pg_escape_string($this->dbConn, $name);
|
|
$this->query("CREATE SCHEMA \"{$SQL_name}\";");
|
|
}
|
|
|
|
/**
|
|
* Drops a schema from the database. Use carefully!
|
|
* @param string $name
|
|
*/
|
|
public function dropSchema($name) {
|
|
$SQL_name = pg_escape_string($this->dbConn, $name);
|
|
$this->query("DROP SCHEMA \"{$SQL_name}\" CASCADE;");
|
|
}
|
|
|
|
/**
|
|
* Returns the name of the current schema in use
|
|
*/
|
|
public function currentSchema() {
|
|
return $this->query('SELECT current_schema()')->value();
|
|
}
|
|
|
|
/**
|
|
* Utility method to manually set the schema to an alternative
|
|
* Check existance & sets search path to the supplied schema name
|
|
* @param string $schema
|
|
*/
|
|
public function setSchema($schema) {
|
|
if(!$this->schemaExists($schema))
|
|
$this->databaseError("Schema $schema does not exist");
|
|
$this->setSchemaSearchPath($schema);
|
|
$this->schema = $schema;
|
|
}
|
|
|
|
/**
|
|
* Override the schema search path. Search using the arguments supplied.
|
|
* NOTE: The search path is normally set through setSchema() and only
|
|
* one schema is selected. The facility to add more than one schema to
|
|
* the search path is provided as an advanced PostgreSQL feature for raw
|
|
* SQL queries. Sapphire cannot search for datamodel tables in alternate
|
|
* schemas, so be wary of using alternate schemas within the ORM environment.
|
|
* @param string $arg1 First schema to use
|
|
* @param string $arg2 Second schema to use
|
|
* @param string $argN Nth schema to use
|
|
*/
|
|
public function setSchemaSearchPath() {
|
|
if(func_num_args() == 0)
|
|
$this->databaseError('At least one Schema must be supplied to set a search path.');
|
|
$args = array_values(func_get_args());
|
|
foreach($args as $key => $schema)
|
|
$args[$key] = '"' . pg_escape_string($this->dbConn, $schema) . '"';
|
|
$args_SQL =implode(",", $args);
|
|
$this->query("SET search_path TO {$args_SQL}");
|
|
}
|
|
|
|
public function createTable($tableName, $fields = null, $indexes = null, $options = null, $extensions = null) {
|
|
|
|
$fieldSchemas = $indexSchemas = "";
|
|
if($fields) foreach($fields as $k => $v) $fieldSchemas .= "\"$k\" $v,\n";
|
|
if(isset($this->class)){
|
|
$addOptions = (isset($options[$this->class])) ? $options[$this->class] : null;
|
|
} else $addOptions=null;
|
|
|
|
//First of all, does this table already exist
|
|
$doesExist=$this->TableExists($tableName);
|
|
if($doesExist) {
|
|
// Table already exists, just return the name, in line with baseclass documentation.
|
|
return $tableName;
|
|
}
|
|
|
|
//If we have a fulltext search request, then we need to create a special column
|
|
//for GiST searches
|
|
$fulltexts='';
|
|
$triggers='';
|
|
if($indexes){
|
|
foreach($indexes as $name=>$this_index){
|
|
if(is_array($this_index) && $this_index['type']=='fulltext'){
|
|
$ts_details=$this->fulltext($this_index, $tableName, $name);
|
|
$fulltexts.=$ts_details['fulltexts'] . ', ';
|
|
$triggers.=$ts_details['triggers'];
|
|
}
|
|
}
|
|
}
|
|
|
|
if($indexes) foreach($indexes as $k => $v) $indexSchemas .= $this->getIndexSqlDefinition($tableName, $k, $v) . "\n";
|
|
|
|
//Do we need to create a tablespace for this item?
|
|
if($extensions && isset($extensions['tablespace'])){
|
|
|
|
$this->createOrReplaceTablespace($extensions['tablespace']['name'], $extensions['tablespace']['location']);
|
|
$tableSpace=' TABLESPACE ' . $extensions['tablespace']['name'];
|
|
} else
|
|
$tableSpace='';
|
|
|
|
$this->query("CREATE TABLE \"$tableName\" (
|
|
$fieldSchemas
|
|
$fulltexts
|
|
primary key (\"ID\")
|
|
)$tableSpace; $indexSchemas $addOptions");
|
|
|
|
if($triggers!=''){
|
|
$this->query($triggers);
|
|
}
|
|
|
|
//If we have a partitioning requirement, we do that here:
|
|
if($extensions && isset($extensions['partitions'])){
|
|
$this->createOrReplacePartition($tableName, $extensions['partitions'], $indexes, $extensions);
|
|
}
|
|
|
|
//Lastly, clustering goes here:
|
|
if($extensions && isset($extensions['cluster'])){
|
|
DB::query("CLUSTER \"$tableName\" USING \"{$extensions['cluster']}\";");
|
|
}
|
|
|
|
return $tableName;
|
|
}
|
|
|
|
/**
|
|
* Builds the internal Postgres index name given the silverstripe table and index name
|
|
* @param string $tableName
|
|
* @param string $indexName
|
|
* @param string $prefix The optional prefix for the index. Defaults to "ix" for indexes.
|
|
* @return string The postgres name of the index
|
|
*/
|
|
function buildPostgresIndexName($tableName, $indexName, $prefix = 'ix') {
|
|
|
|
// Assume all indexes also contain the table name
|
|
// MD5 the table/index name combo to keep it to a fixed length.
|
|
// Exclude the prefix so that the trigger name can be easily generated from the index name
|
|
$indexNamePG = "{$prefix}_" . md5("{$tableName}_{$indexName}");
|
|
|
|
// Limit to 63 characters
|
|
if (strlen($indexNamePG) > 63)
|
|
return substr($indexNamePG, 0, 63);
|
|
return $indexNamePG;
|
|
}
|
|
|
|
/**
|
|
* Builds the internal Postgres trigger name given the silverstripe table and trigger name
|
|
* @param string $tableName
|
|
* @param string $triggerName
|
|
* @return string The postgres name of the trigger
|
|
*/
|
|
function buildPostgresTriggerName($tableName, $triggerName) {
|
|
// Kind of cheating, but behaves the same way as indexes
|
|
return $this->buildPostgresIndexName($tableName, $triggerName, 'ts');
|
|
}
|
|
|
|
/**
|
|
* Alter a table's schema.
|
|
* @param $table The name of the table to alter
|
|
* @param $newFields New fields, a map of field name => field schema
|
|
* @param $newIndexes New indexes, a map of index name => index type
|
|
* @param $alteredFields Updated fields, a map of field name => field schema
|
|
* @param $alteredIndexes Updated indexes, a map of index name => index type
|
|
*/
|
|
public function alterTable($tableName, $newFields = null, $newIndexes = null, $alteredFields = null, $alteredIndexes = null, $alteredOptions = null, $advancedOptions = null) {
|
|
|
|
$alterList = array();
|
|
if($newFields) foreach($newFields as $fieldName => $fieldSpec) {
|
|
$alterList[] = "ADD \"$fieldName\" $fieldSpec";
|
|
}
|
|
|
|
if ($alteredFields) foreach ($alteredFields as $indexName => $indexSpec) {
|
|
$val = $this->alterTableAlterColumn($tableName, $indexName, $indexSpec);
|
|
if (!empty($val)) $alterList[] = $val;
|
|
}
|
|
|
|
//Do we need to do anything with the tablespaces?
|
|
if($alteredOptions && isset($advancedOptions['tablespace'])){
|
|
$this->createOrReplaceTablespace($advancedOptions['tablespace']['name'], $advancedOptions['tablespace']['location']);
|
|
$this->query("ALTER TABLE \"$tableName\" SET TABLESPACE {$advancedOptions['tablespace']['name']};");
|
|
}
|
|
|
|
//DB ABSTRACTION: we need to change the constraints to be a separate 'add' command,
|
|
//see http://www.postgresql.org/docs/8.1/static/sql-altertable.html
|
|
$alterIndexList=Array();
|
|
//Pick up the altered indexes here:
|
|
$fieldList = $this->fieldList($tableName);
|
|
$fulltexts=false;
|
|
$drop_triggers=false;
|
|
$triggers=false;
|
|
if($alteredIndexes) foreach($alteredIndexes as $indexName=>$indexSpec) {
|
|
|
|
$indexSpec = $this->parseIndexSpec($indexName, $indexSpec);
|
|
$indexNamePG = $this->buildPostgresIndexName($tableName, $indexName);
|
|
|
|
if($indexSpec['type']=='fulltext') {
|
|
//For full text indexes, we need to drop the trigger, drop the index, AND drop the column
|
|
|
|
//Go and get the tsearch details:
|
|
$ts_details = $this->fulltext($indexSpec, $tableName, $indexName);
|
|
|
|
//Drop this column if it already exists:
|
|
|
|
//No IF EXISTS option is available for Postgres <9.0
|
|
if(array_key_exists($ts_details['ts_name'], $fieldList)){
|
|
$fulltexts.="ALTER TABLE \"{$tableName}\" DROP COLUMN \"{$ts_details['ts_name']}\";";
|
|
}
|
|
|
|
// We'll execute these later:
|
|
$triggerNamePG = $this->buildPostgresTriggerName($tableName, $indexName);
|
|
$drop_triggers.= "DROP TRIGGER IF EXISTS \"$triggerNamePG\" ON \"$tableName\";";
|
|
$fulltexts .= "ALTER TABLE \"{$tableName}\" ADD COLUMN {$ts_details['fulltexts']};";
|
|
$triggers .= $ts_details['triggers'];
|
|
}
|
|
|
|
// Create index action (including fulltext)
|
|
$alterIndexList[] = "DROP INDEX IF EXISTS \"$indexNamePG\";";
|
|
$createIndex = $this->getIndexSqlDefinition($tableName, $indexName, $indexSpec);
|
|
if($createIndex!==false) $alterIndexList[] = $createIndex;
|
|
}
|
|
|
|
//Add the new indexes:
|
|
if($newIndexes) foreach($newIndexes as $indexName => $indexSpec){
|
|
|
|
$indexSpec = $this->parseIndexSpec($indexName, $indexSpec);
|
|
$indexNamePG = $this->buildPostgresIndexName($tableName, $indexName);
|
|
//If we have a fulltext search request, then we need to create a special column
|
|
//for GiST searches
|
|
//Pick up the new indexes here:
|
|
if($indexSpec['type']=='fulltext') {
|
|
$ts_details=$this->fulltext($indexSpec, $tableName, $indexName);
|
|
if(!isset($fieldList[$ts_details['ts_name']])){
|
|
$fulltexts.="ALTER TABLE \"{$tableName}\" ADD COLUMN {$ts_details['fulltexts']};";
|
|
$triggers.=$ts_details['triggers'];
|
|
}
|
|
}
|
|
|
|
//Check that this index doesn't already exist:
|
|
$indexes=$this->indexList($tableName);
|
|
if(isset($indexes[$indexName])){
|
|
$alterIndexList[] = "DROP INDEX IF EXISTS \"$indexNamePG\";";
|
|
}
|
|
|
|
$createIndex=$this->getIndexSqlDefinition($tableName, $indexName, $indexSpec);
|
|
if($createIndex!==false)
|
|
$alterIndexList[] = $createIndex;
|
|
}
|
|
|
|
if($alterList) {
|
|
$alterations = implode(",\n", $alterList);
|
|
$this->query("ALTER TABLE \"$tableName\" " . $alterations);
|
|
}
|
|
|
|
//Do we need to create a tablespace for this item?
|
|
if($advancedOptions && isset($advancedOptions['extensions']['tablespace'])){
|
|
$extensions=$advancedOptions['extensions'];
|
|
$this->createOrReplaceTablespace($extensions['tablespace']['name'], $extensions['tablespace']['location']);
|
|
}
|
|
|
|
if($alteredOptions && isset($this->class) && isset($alteredOptions[$this->class])) {
|
|
$this->query(sprintf("ALTER TABLE \"%s\" %s", $tableName, $alteredOptions[$this->class]));
|
|
Database::alteration_message(
|
|
sprintf("Table %s options changed: %s", $tableName, $alteredOptions[$this->class]),
|
|
"changed"
|
|
);
|
|
}
|
|
|
|
//Create any fulltext columns and triggers here:
|
|
if($fulltexts) $this->query($fulltexts);
|
|
if($drop_triggers) $this->query($drop_triggers);
|
|
|
|
if($triggers) {
|
|
$this->query($triggers);
|
|
|
|
$triggerbits=explode(';', $triggers);
|
|
foreach($triggerbits as $trigger){
|
|
$trigger_fields=$this->triggerFieldsFromTrigger($trigger);
|
|
|
|
if($trigger_fields){
|
|
//We need to run a simple query to force the database to update the triggered columns
|
|
$this->query("UPDATE \"{$tableName}\" SET \"{$trigger_fields[0]}\"=\"$trigger_fields[0]\";");
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach($alterIndexList as $alteration) $this->query($alteration);
|
|
|
|
//If we have a partitioning requirement, we do that here:
|
|
if($advancedOptions && isset($advancedOptions['partitions'])){
|
|
$this->createOrReplacePartition($tableName, $advancedOptions['partitions']);
|
|
}
|
|
|
|
//Lastly, clustering goes here:
|
|
if ($advancedOptions && isset($advancedOptions['cluster'])) {
|
|
$clusterIndex = $this->buildPostgresIndexName($tableName, $advancedOptions['cluster']);
|
|
DB::query("CLUSTER \"$tableName\" USING \"$clusterIndex\";");
|
|
} else {
|
|
//Check that clustering is not on this table, and if it is, remove it:
|
|
|
|
//This is really annoying. We need the oid of this table:
|
|
$stats=DB::query("SELECT relid FROM pg_stat_user_tables WHERE relname='" . $this->addslashes($tableName) . "';")->first();
|
|
$oid=$stats['relid'];
|
|
|
|
//Now we can run a long query to get the clustered status:
|
|
//If anyone knows a better way to get the clustered status, then feel free to replace this!
|
|
$clustered=DB::query("SELECT c2.relname, i.indisclustered FROM pg_catalog.pg_class c, pg_catalog.pg_class c2, pg_catalog.pg_index i WHERE c.oid = '$oid' AND c.oid = i.indrelid AND i.indexrelid = c2.oid AND indisclustered='t';")->first();
|
|
|
|
if($clustered)
|
|
DB::query("ALTER TABLE \"$tableName\" SET WITHOUT CLUSTER;");
|
|
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Creates an ALTER expression for a column in PostgreSQL
|
|
*
|
|
* @param $tableName Name of the table to be altered
|
|
* @param $colName Name of the column to be altered
|
|
* @param $colSpec String which contains conditions for a column
|
|
* @return string
|
|
*/
|
|
private function alterTableAlterColumn($tableName, $colName, $colSpec){
|
|
// First, we split the column specifications into parts
|
|
// TODO: this returns an empty array for the following string: int(11) not null auto_increment
|
|
// on second thoughts, why is an auto_increment field being passed through?
|
|
|
|
$pattern = '/^([\w()]+)\s?((?:not\s)?null)?\s?(default\s[\w\']+)?\s?(check\s[\w()\'",\s]+)?$/i';
|
|
preg_match($pattern, $colSpec, $matches);
|
|
|
|
if(sizeof($matches)==0) return '';
|
|
|
|
if($matches[1]=='serial8') return '';
|
|
|
|
if(isset($matches[1])) {
|
|
$alterCol = "ALTER COLUMN \"$colName\" TYPE $matches[1]\n";
|
|
|
|
// SET null / not null
|
|
if(!empty($matches[2])) {
|
|
$alterCol .= ",\nALTER COLUMN \"$colName\" SET $matches[2]";
|
|
}
|
|
|
|
// SET default (we drop it first, for reasons of precaution)
|
|
if(!empty($matches[3])) {
|
|
$alterCol .= ",\nALTER COLUMN \"$colName\" DROP DEFAULT";
|
|
$alterCol .= ",\nALTER COLUMN \"$colName\" SET $matches[3]";
|
|
}
|
|
|
|
// SET check constraint (The constraint HAS to be dropped)
|
|
$existing_constraint=$this->query("SELECT conname FROM pg_constraint WHERE conname='{$tableName}_{$colName}_check';")->value();
|
|
if(isset($matches[4])) {
|
|
//Take this new constraint and see what's outstanding from the target table:
|
|
$constraint_bits=explode('(', $matches[4]);
|
|
$constraint_values=trim($constraint_bits[2], ')');
|
|
$constraint_values_bits=explode(',', $constraint_values);
|
|
$default=trim($constraint_values_bits[0], " '");
|
|
|
|
//Now go and convert anything that's not in this list to 'Page'
|
|
//We have to run this as a query, not as part of the alteration queries due to the way they are constructed.
|
|
$updateConstraint='';
|
|
$updateConstraint.="UPDATE \"{$tableName}\" SET \"$colName\"='$default' WHERE \"$colName\" NOT IN ($constraint_values);";
|
|
if($this->hasTable("{$tableName}_Live")) {
|
|
$updateConstraint.="UPDATE \"{$tableName}_Live\" SET \"$colName\"='$default' WHERE \"$colName\" NOT IN ($constraint_values);";
|
|
}
|
|
if($this->hasTable("{$tableName}_versions")) {
|
|
$updateConstraint.="UPDATE \"{$tableName}_versions\" SET \"$colName\"='$default' WHERE \"$colName\" NOT IN ($constraint_values);";
|
|
}
|
|
|
|
DB::query($updateConstraint);
|
|
}
|
|
|
|
//First, delete any existing constraint on this column, even if it's no longer an enum
|
|
if($existing_constraint)
|
|
$alterCol .= ",\nDROP CONSTRAINT \"{$tableName}_{$colName}_check\"";
|
|
|
|
//Now create the constraint (if we've asked for one)
|
|
if(!empty($matches[4]))
|
|
$alterCol .= ",\nADD CONSTRAINT \"{$tableName}_{$colName}_check\" $matches[4]";
|
|
}
|
|
|
|
return isset($alterCol) ? $alterCol : '';
|
|
}
|
|
|
|
public function renameTable($oldTableName, $newTableName) {
|
|
$this->query("ALTER TABLE \"$oldTableName\" RENAME TO \"$newTableName\"");
|
|
unset(self::$cached_fieldlists[$oldTableName]);
|
|
}
|
|
|
|
/**
|
|
* Repairs and reindexes the table. This might take a long time on a very large table.
|
|
* @var string $tableName The name of the table.
|
|
* @return boolean Return true if the table has integrity after the method is complete.
|
|
*/
|
|
public function checkAndRepairTable($tableName) {
|
|
|
|
$this->runTableCheckCommand("VACUUM FULL ANALYZE \"$tableName\"");
|
|
$this->runTableCheckCommand("REINDEX TABLE \"$tableName\"");
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Helper function used by checkAndRepairTable.
|
|
* @param string $sql Query to run.
|
|
* @return boolean Returns true no matter what; we're not currently checking the status of the command
|
|
*/
|
|
protected function runTableCheckCommand($sql) {
|
|
$testResults = $this->query($sql);
|
|
return true;
|
|
}
|
|
|
|
public function createField($tableName, $fieldName, $fieldSpec) {
|
|
$this->query("ALTER TABLE \"$tableName\" ADD \"$fieldName\" $fieldSpec");
|
|
}
|
|
|
|
/**
|
|
* Change the database type of the given field.
|
|
* @param string $tableName The name of the tbale the field is in.
|
|
* @param string $fieldName The name of the field to change.
|
|
* @param string $fieldSpec The new field specification
|
|
*/
|
|
public function alterField($tableName, $fieldName, $fieldSpec) {
|
|
$this->query("ALTER TABLE \"$tableName\" CHANGE \"$fieldName\" \"$fieldName\" $fieldSpec");
|
|
}
|
|
|
|
/**
|
|
* Change the database column name of the given field.
|
|
*
|
|
* @param string $tableName The name of the table the field is in.
|
|
* @param string $oldName The name of the field to change.
|
|
* @param string $newName The new name of the field
|
|
*/
|
|
public function renameField($tableName, $oldName, $newName) {
|
|
$fieldList = $this->fieldList($tableName);
|
|
if(array_key_exists($oldName, $fieldList)) {
|
|
$this->query("ALTER TABLE \"$tableName\" RENAME COLUMN \"$oldName\" TO \"$newName\"");
|
|
|
|
//Remove this from the cached list:
|
|
unset(self::$cached_fieldlists[$tableName]);
|
|
|
|
}
|
|
}
|
|
|
|
public function fieldList($table) {
|
|
//Query from http://www.alberton.info/postgresql_meta_info.html
|
|
//This gets us more information than we need, but I've included it all for the moment....
|
|
|
|
//if(!isset(self::$cached_fieldlists[$table])){
|
|
$fields = $this->query("SELECT ordinal_position, column_name, data_type, column_default, is_nullable, character_maximum_length, numeric_precision, numeric_scale FROM information_schema.columns WHERE table_name = '" . $this->addslashes($table) . "' ORDER BY ordinal_position;");
|
|
|
|
$output = array();
|
|
if($fields) foreach($fields as $field) {
|
|
|
|
switch($field['data_type']){
|
|
case 'character varying':
|
|
//Check to see if there's a constraint attached to this column:
|
|
//$constraint=$this->query("SELECT conname,pg_catalog.pg_get_constraintdef(r.oid, true) FROM pg_catalog.pg_constraint r WHERE r.contype = 'c' AND conname='" . $table . '_' . $field['column_name'] . "_check' ORDER BY 1;")->first();
|
|
$constraint=$this->constraintExists($table . '_' . $field['column_name'] . '_check');
|
|
if($constraint){
|
|
//Now we need to break this constraint text into bits so we can see what we have:
|
|
//Examples:
|
|
//CHECK ("CanEditType"::text = ANY (ARRAY['LoggedInUsers'::character varying, 'OnlyTheseUsers'::character varying, 'Inherit'::character varying]::text[]))
|
|
//CHECK ("ClassName"::text = 'PageComment'::text)
|
|
|
|
//TODO: replace all this with a regular expression!
|
|
$value=$constraint['pg_get_constraintdef'];
|
|
$value=substr($value, strpos($value,'='));
|
|
$value=str_replace("''", "'", $value);
|
|
|
|
$in_value=false;
|
|
$constraints=Array();
|
|
$current_value='';
|
|
for($i=0; $i<strlen($value); $i++){
|
|
$char=substr($value, $i, 1);
|
|
if($in_value)
|
|
$current_value.=$char;
|
|
|
|
if($char=="'"){
|
|
if(!$in_value)
|
|
$in_value=true;
|
|
else {
|
|
$in_value=false;
|
|
$constraints[]=substr($current_value, 0, -1);
|
|
$current_value='';
|
|
}
|
|
}
|
|
}
|
|
|
|
if(sizeof($constraints)>0){
|
|
//Get the default:
|
|
$default=trim(substr($field['column_default'], 0, strpos($field['column_default'], '::')), "'");
|
|
$output[$field['column_name']]=$this->enum(Array('default'=>$default, 'name'=>$field['column_name'], 'enums'=>$constraints));
|
|
}
|
|
} else{
|
|
$output[$field['column_name']]='varchar(' . $field['character_maximum_length'] . ')';
|
|
}
|
|
break;
|
|
|
|
case 'numeric':
|
|
$output[$field['column_name']]='decimal(' . $field['numeric_precision'] . ',' . $field['numeric_scale'] . ') default ' . (int)$field['column_default'];
|
|
break;
|
|
|
|
case 'integer':
|
|
$output[$field['column_name']]='integer default ' . (int)$field['column_default'];
|
|
break;
|
|
|
|
case 'timestamp without time zone':
|
|
$output[$field['column_name']]='timestamp';
|
|
break;
|
|
|
|
case 'smallint':
|
|
$output[$field['column_name']]='smallint default ' . (int)$field['column_default'];
|
|
break;
|
|
|
|
case 'time without time zone':
|
|
$output[$field['column_name']]='time';
|
|
break;
|
|
|
|
case 'double precision':
|
|
$output[$field['column_name']]='float';
|
|
break;
|
|
|
|
default:
|
|
$output[$field['column_name']] = $field;
|
|
}
|
|
|
|
}
|
|
|
|
// self::$cached_fieldlists[$table]=$output;
|
|
//}
|
|
|
|
//return self::$cached_fieldlists[$table];
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* This allows the cached values for a table's field list to be erased.
|
|
* If $tablename is empty, then the whole cache is erased.
|
|
*
|
|
* @param string $tableName
|
|
*
|
|
* @return boolean
|
|
*/
|
|
function clearCachedFieldlist($tableName=false){
|
|
if($tableName) unset(self::$cached_fieldlists[$tableName]);
|
|
else self::$cached_fieldlists=array();
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Create an index on a table.
|
|
* @param string $tableName The name of the table.
|
|
* @param string $indexName The name of the index.
|
|
* @param string $indexSpec The specification of the index, see Database::requireIndex() for more details.
|
|
*/
|
|
public function createIndex($tableName, $indexName, $indexSpec) {
|
|
$createIndex=$this->getIndexSqlDefinition($tableName, $indexName, $indexSpec);
|
|
if($createIndex!==false) $this->query();
|
|
}
|
|
|
|
/*
|
|
* This takes the index spec which has been provided by a class (ie static $indexes = blah blah)
|
|
* and turns it into a proper string.
|
|
* Some indexes may be arrays, such as fulltext and unique indexes, and this allows database-specific
|
|
* arrays to be created.
|
|
* @see parseIndexSpec() for approximate inverse
|
|
*/
|
|
public function convertIndexSpec($indexSpec, $asDbValue=false, $table=''){
|
|
|
|
if(!$asDbValue){
|
|
if(is_array($indexSpec)){
|
|
//Here we create a db-specific version of whatever index we need to create.
|
|
switch($indexSpec['type']){
|
|
case 'fulltext':
|
|
$indexSpec='fulltext (' . $indexSpec['value'] . ')';
|
|
break;
|
|
case 'unique':
|
|
$indexSpec='unique (' . $indexSpec['value'] . ')';
|
|
break;
|
|
case 'hash':
|
|
$indexSpec='using hash (' . $indexSpec['value'] . ')';
|
|
break;
|
|
case 'index':
|
|
//The default index is 'btree', which we'll use by default (below):
|
|
default:
|
|
$indexSpec='using btree (' . $indexSpec['value'] . ')';
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
$indexSpec = $this->buildPostgresIndexName($table, $indexSpec);
|
|
}
|
|
return $indexSpec;
|
|
}
|
|
|
|
/**
|
|
* Splits a spec string safely, considering quoted columns, whitespace,
|
|
* and cleaning brackets
|
|
* @param string $spec The input index specification
|
|
* @return array List of columns in the spec
|
|
*/
|
|
function explodeColumnString($spec) {
|
|
// Remove any leading/trailing brackets and outlying modifiers
|
|
// E.g. 'unique (Title, "QuotedColumn");' => 'Title, "QuotedColumn"'
|
|
$containedSpec = preg_replace('/(.*\(\s*)|(\s*\).*)/', '', $spec);
|
|
|
|
// Split potentially quoted modifiers
|
|
// E.g. 'Title, "QuotedColumn"' => array('Title', 'QuotedColumn')
|
|
return preg_split('/"?\s*,\s*"?/', trim($containedSpec, '(") '));
|
|
}
|
|
|
|
/**
|
|
* Builds a properly quoted column list from an array
|
|
* @param array $columns List of columns to implode
|
|
* @return string A properly quoted list of column names
|
|
*/
|
|
function implodeColumnList($columns) {
|
|
if(empty($columns)) return '';
|
|
return '"' . implode('","', $columns) . '"';
|
|
}
|
|
|
|
/**
|
|
* Given an index specification in the form of a string ensure that each
|
|
* column name is property quoted, stripping brackets and modifiers.
|
|
* This index may also be in the form of a "CREATE INDEX..." sql fragment
|
|
* @param string $spec The input specification or query. E.g. 'unique (Column1, Column2)'
|
|
* @return string The properly quoted column list. E.g. '"Column1", "Column2"'
|
|
*/
|
|
function quoteColumnSpecString($spec) {
|
|
$bits = $this->explodeColumnString($spec);
|
|
return $this->implodeColumnList($bits);
|
|
}
|
|
|
|
/**
|
|
* Given an index spec determines the index type
|
|
* @param type $spec
|
|
* @return string
|
|
*/
|
|
function determineIndexType($spec) {
|
|
// check array spec
|
|
if(is_array($spec) && isset($spec['type'])) {
|
|
return $spec['type'];
|
|
} elseif (!is_array($spec) && preg_match('/(?<type>\w+)\s*\(/', $spec, $matchType)) {
|
|
return strtolower($matchType['type']);
|
|
} else {
|
|
return 'index';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts an array or string index spec into a universally useful array
|
|
* @see convertIndexSpec() for approximate inverse
|
|
* @param string|array $spec
|
|
* @return array The resulting spec array with the required fields name, type, and value
|
|
*/
|
|
function parseIndexSpec($name, $spec){
|
|
|
|
// Do minimal cleanup on any already parsed spec
|
|
if(is_array($spec)) {
|
|
$spec['value'] = $this->quoteColumnSpecString($spec['value']);
|
|
return $spec;
|
|
}
|
|
|
|
// Nicely formatted spec!
|
|
return array(
|
|
'name' => $name,
|
|
'value' => $this->quoteColumnSpecString($spec),
|
|
'type' => $this->determineIndexType($spec)
|
|
);
|
|
}
|
|
|
|
protected function getIndexSqlDefinition($tableName, $indexName, $indexSpec, $asDbValue=false) {
|
|
|
|
//TODO: create table partition support
|
|
//TODO: create clustering options
|
|
|
|
//NOTE: it is possible for *_renamed tables to have indexes whose names are not updates
|
|
//Therefore, we now check for the existance of indexes before we create them.
|
|
//This is techically a bug, since new tables will not be indexed.
|
|
|
|
// If requesting the definition rather than the DDL
|
|
if($asDbValue) {
|
|
$indexName=trim($indexName, '()');
|
|
return $indexName;
|
|
}
|
|
|
|
// Determine index name
|
|
$tableCol = $this->buildPostgresIndexName($tableName, $indexName);
|
|
|
|
// Consolidate/Cleanup spec into array format
|
|
$indexSpec = $this->parseIndexSpec($indexName, $indexSpec);
|
|
|
|
//Misc options first:
|
|
$fillfactor = $where = '';
|
|
if (isset($indexSpec['fillfactor'])) {
|
|
$fillfactor = 'WITH (FILLFACTOR = ' . $indexSpec['fillfactor'] . ')';
|
|
}
|
|
if (isset($indexSpec['where'])) {
|
|
$where = 'WHERE ' . $indexSpec['where'];
|
|
}
|
|
|
|
//create a type-specific index
|
|
// NOTE: hash should be removed. This is only here to demonstrate how other indexes can be made
|
|
// NOTE: Quote the index name to preserve case sensitivity
|
|
switch ($indexSpec['type']) {
|
|
case 'fulltext':
|
|
// @see fulltext() for the definition of the trigger that ts_$IndexName uses for fulltext searching
|
|
$spec = "create index \"$tableCol\" ON \"$tableName\" USING " . $this->default_fts_cluster_method . "(\"ts_" . $indexName . "\") $fillfactor $where";
|
|
break;
|
|
|
|
case 'unique':
|
|
$spec = "create unique index \"$tableCol\" ON \"$tableName\" (" . $indexSpec['value'] . ") $fillfactor $where";
|
|
break;
|
|
|
|
case 'btree':
|
|
$spec = "create index \"$tableCol\" ON \"$tableName\" USING btree (" . $indexSpec['value'] . ") $fillfactor $where";
|
|
break;
|
|
|
|
case 'hash':
|
|
//NOTE: this is not a recommended index type
|
|
$spec = "create index \"$tableCol\" ON \"$tableName\" USING hash (" . $indexSpec['value'] . ") $fillfactor $where";
|
|
break;
|
|
|
|
case 'index':
|
|
//'index' is the same as default, just a normal index with the default type decided by the database.
|
|
default:
|
|
$spec = "create index \"$tableCol\" ON \"$tableName\" (" . $indexSpec['value'] . ") $fillfactor $where";
|
|
}
|
|
return trim($spec) . ';';
|
|
}
|
|
|
|
function getDbSqlDefinition($tableName, $indexName, $indexSpec) {
|
|
return $this->getIndexSqlDefinition($tableName, $indexName, $indexSpec, true);
|
|
}
|
|
|
|
/**
|
|
* Alter an index on a table.
|
|
* @param string $tableName The name of the table.
|
|
* @param string $indexName The name of the index.
|
|
* @param string $indexSpec The specification of the index, see Database::requireIndex() for more details.
|
|
*/
|
|
public function alterIndex($tableName, $indexName, $indexSpec) {
|
|
$indexSpec = trim($indexSpec);
|
|
if($indexSpec[0] != '(') {
|
|
list($indexType, $indexFields) = explode(' ',$indexSpec,2);
|
|
} else {
|
|
$indexFields = $indexSpec;
|
|
}
|
|
|
|
if(!$indexType) {
|
|
$indexType = "index";
|
|
}
|
|
|
|
$this->query("DROP INDEX \"$indexName\"");
|
|
$this->query("ALTER TABLE \"$tableName\" ADD $indexType \"$indexName\" $indexFields");
|
|
}
|
|
|
|
/**
|
|
* Given a trigger name attempt to determine the columns upon which it acts
|
|
* @param string $triggerName Postgres trigger name
|
|
* @return array List of columns
|
|
*/
|
|
protected function extractTriggerColumns($triggerName)
|
|
{
|
|
$trigger = DB::query($statement = sprintf(
|
|
"SELECT tgargs FROM pg_catalog.pg_trigger WHERE tgname='%s'", $this->addslashes($triggerName)
|
|
))->first();
|
|
|
|
// Option 1: output as a string
|
|
if(strpos($trigger['tgargs'],'\000') !== false) {
|
|
$argList = explode('\000', $trigger['tgargs']);
|
|
array_pop($argList);
|
|
|
|
// Option 2: hex-encoded (not sure why this happens, depends on PGSQL config)
|
|
} else {
|
|
$bytes = str_split($trigger['tgargs'],2);
|
|
$argList = array();
|
|
$nextArg = "";
|
|
foreach($bytes as $byte) {
|
|
if($byte == "00") {
|
|
$argList[] = $nextArg;
|
|
$nextArg = "";
|
|
} else {
|
|
$nextArg .= chr(hexdec($byte));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Drop first two arguments (trigger name and config name) and implode into nice list
|
|
return array_slice($argList, 2);
|
|
}
|
|
|
|
/**
|
|
* Return the list of indexes in a table.
|
|
* @param string $table The table name.
|
|
* @return array
|
|
*/
|
|
public function indexList($table) {
|
|
|
|
//Retrieve a list of indexes for the specified table
|
|
$schema_SQL = pg_escape_string($this->dbConn, $this->schema);
|
|
$indexes=DB::query("SELECT tablename, indexname, indexdef FROM pg_catalog.pg_indexes WHERE tablename='" . $this->addslashes($table) . "' AND schemaname = '{$schema_SQL}';");
|
|
|
|
$indexList=Array();
|
|
foreach($indexes as $index) {
|
|
// Key for the indexList array. Differs from other DB implementations, which is why
|
|
// requireIndex() needed to be overridden
|
|
$indexName = $index['indexname'];
|
|
|
|
//We don't actually need the entire created command, just a few bits:
|
|
$prefix='';
|
|
|
|
//Check for uniques:
|
|
if(substr($index['indexdef'], 0, 13)=='CREATE UNIQUE') {
|
|
$prefix='unique ';
|
|
}
|
|
|
|
//check for hashes, btrees etc:
|
|
if(strpos(strtolower($index['indexdef']), 'using hash ')!==false) {
|
|
$prefix='using hash ';
|
|
}
|
|
|
|
//TODO: Fix me: btree is the default index type:
|
|
//if(strpos(strtolower($index['indexdef']), 'using btree ')!==false)
|
|
// $prefix='using btree ';
|
|
|
|
if(strpos(strtolower($index['indexdef']), 'using rtree ')!==false) {
|
|
$prefix='using rtree ';
|
|
}
|
|
|
|
// For fulltext indexes we need to extract the columns from another source
|
|
if (stristr($index['indexdef'], 'using gin')) {
|
|
$prefix = 'fulltext ';
|
|
// Extract trigger information from postgres
|
|
$triggerName = preg_replace('/^ix_/', 'ts_', $index['indexname']);
|
|
$columns = $this->extractTriggerColumns($triggerName);
|
|
$columnString = $this->implodeColumnList($columns);
|
|
} else {
|
|
$columnString = $this->quoteColumnSpecString($index['indexdef']);
|
|
}
|
|
|
|
$indexList[$indexName]['indexname'] = $index['indexname'];
|
|
$indexList[$indexName]['spec'] = "$prefix($columnString)";
|
|
}
|
|
|
|
return isset($indexList) ? $indexList : null;
|
|
|
|
}
|
|
|
|
/**
|
|
* Generate the given index in the database, modifying whatever already exists as necessary.
|
|
*
|
|
* The keys of the array are the names of the index.
|
|
* The values of the array can be one of:
|
|
* - true: Create a single column index on the field named the same as the index.
|
|
* - array('type' => 'index|unique|fulltext', 'value' => 'FieldA, FieldB'): This gives you full
|
|
* control over the index.
|
|
*
|
|
* @param string $table The table name.
|
|
* @param string $index The index name.
|
|
* @param string|boolean $spec The specification of the index. See requireTable() for more information.
|
|
*/
|
|
function requireIndex($table, $index, $spec) {
|
|
$newTable = false;
|
|
|
|
//DB Abstraction: remove this ===true option as a possibility?
|
|
if($spec === true) {
|
|
$spec = "(\"$index\")";
|
|
}
|
|
|
|
//Indexes specified as arrays cannot be checked with this line: (it flattens out the array)
|
|
if(!is_array($spec)) {
|
|
$spec = preg_replace('/\s*,\s*/', ',', $spec);
|
|
}
|
|
|
|
if(!isset($this->tableList[strtolower($table)])) $newTable = true;
|
|
|
|
if(!$newTable && !isset($this->indexList[$table])) {
|
|
$this->indexList[$table] = $this->indexList($table);
|
|
}
|
|
|
|
//Fix up the index for database purposes
|
|
$index=DB::getConn()->getDbSqlDefinition($table, $index, null, true);
|
|
|
|
//Fix the key for database purposes
|
|
$index_alt = $this->buildPostgresIndexName($table, $index);
|
|
|
|
if(!$newTable) {
|
|
if(isset($this->indexList[$table][$index_alt])) {
|
|
if(is_array($this->indexList[$table][$index_alt])) {
|
|
$array_spec = $this->indexList[$table][$index_alt]['spec'];
|
|
} else {
|
|
$array_spec = $this->indexList[$table][$index_alt];
|
|
}
|
|
}
|
|
}
|
|
|
|
if($newTable || !isset($this->indexList[$table][$index_alt])) {
|
|
$this->transCreateIndex($table, $index, $spec);
|
|
$this->alterationMessage("Index $table.$index: created as " . DB::getConn()->convertIndexSpec($spec),"created");
|
|
} else if($array_spec != DB::getConn()->convertIndexSpec($spec)) {
|
|
$this->transAlterIndex($table, $index, $spec);
|
|
$spec_msg=DB::getConn()->convertIndexSpec($spec);
|
|
$this->alterationMessage("Index $table.$index: changed to $spec_msg <i style=\"color: #AAA\">(from {$array_spec})</i>","changed");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a list of all the tables in the database.
|
|
* Table names will all be in lowercase.
|
|
* @return array
|
|
*/
|
|
public function tableList() {
|
|
$schema_SQL = pg_escape_string($this->dbConn, $this->schema);
|
|
$tables=array();
|
|
foreach($this->query("SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname = '{$schema_SQL}' AND tablename NOT ILIKE 'pg\\\_%' AND tablename NOT ILIKE 'sql\\\_%'") as $record) {
|
|
//$table = strtolower(reset($record));
|
|
$table = reset($record);
|
|
$tables[$table] = $table;
|
|
}
|
|
|
|
//Return an empty array if there's nothing in this database
|
|
return $tables;
|
|
}
|
|
|
|
/**
|
|
* Determines if a table exists
|
|
* @param string $tableName
|
|
* @return boolean
|
|
*/
|
|
function TableExists($tableName){
|
|
$schema_SQL = pg_escape_string($this->dbConn, $this->schema);
|
|
$result=$this->query("SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname = '{$schema_SQL}' AND tablename='" . $this->addslashes($tableName) . "';")->first();
|
|
|
|
return !empty($result);
|
|
}
|
|
|
|
/**
|
|
* Find out what the constraint information is, given a constraint name.
|
|
* We also cache this result, so the next time we don't need to do a
|
|
* query all over again.
|
|
*
|
|
* @param string $constraint
|
|
*/
|
|
function constraintExists($constraint){
|
|
if(!isset(self::$cached_constraints[$constraint])){
|
|
$exists=DB::query("SELECT conname,pg_catalog.pg_get_constraintdef(r.oid, true) FROM pg_catalog.pg_constraint r WHERE r.contype = 'c' AND conname='$constraint' ORDER BY 1;")->first();
|
|
self::$cached_constraints[$constraint]=$exists;
|
|
}
|
|
|
|
return self::$cached_constraints[$constraint];
|
|
}
|
|
|
|
/**
|
|
* Return the number of rows affected by the previous operation.
|
|
* @return int
|
|
*/
|
|
public function affectedRows() {
|
|
return pg_affected_rows(DB::$lastQuery);
|
|
}
|
|
|
|
/**
|
|
* A function to return the field names and datatypes for the particular table
|
|
*/
|
|
public function tableDetails($tableName){
|
|
$schema_SQL = pg_escape_string($this->dbConn, $this->schema);
|
|
$query="SELECT a.attname as \"Column\", pg_catalog.format_type(a.atttypid, a.atttypmod) as \"Datatype\" FROM pg_catalog.pg_attribute a WHERE a.attnum > 0 AND NOT a.attisdropped AND a.attrelid = ( SELECT c.oid FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE c.relname ~ '^($tableName)$' AND pg_catalog.pg_table_is_visible(c.oid) AND n.nspname = '{$schema_SQL}');";
|
|
|
|
$result=DB::query($query);
|
|
|
|
$table=Array();
|
|
while($row=pg_fetch_assoc($result)){
|
|
$table[]=Array('Column'=>$row['Column'], 'DataType'=>$row['DataType']);
|
|
}
|
|
|
|
return $table;
|
|
}
|
|
|
|
/**
|
|
* Pass a legit trigger name and it will be dropped
|
|
* This assumes that the trigger has been named in a unique fashion
|
|
*/
|
|
function dropTrigger($triggerName, $tableName){
|
|
$exists=DB::query("SELECT tgname FROM pg_trigger WHERE tgname='$triggerName';")->first();
|
|
if($exists){
|
|
DB::query("DROP trigger $triggerName ON \"$tableName\";");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This will return the fields that the trigger is monitoring
|
|
* @param string $trigger
|
|
*
|
|
* @return array
|
|
*/
|
|
function triggerFieldsFromTrigger($trigger){
|
|
|
|
if($trigger){
|
|
$tsvector='tsvector_update_trigger';
|
|
$ts_pos=strpos($trigger, $tsvector);
|
|
$details=trim(substr($trigger, $ts_pos+strlen($tsvector)), '();');
|
|
//Now split this into bits:
|
|
$bits=explode(',', $details);
|
|
|
|
$fields=$bits[2];
|
|
|
|
$field_bits=explode(',', str_replace('"', '', $fields));
|
|
$result=array();
|
|
foreach($field_bits as $field_bit)
|
|
$result[]=trim($field_bit);
|
|
|
|
return $result;
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Delete all entries from the table instead of truncating it.
|
|
*
|
|
* This gives a massive speed improvement compared to using TRUNCATE, with
|
|
* the caveat that primary keys are not reset etc.
|
|
*
|
|
* @see DatabaseAdmin::clearAllData()
|
|
*
|
|
* @param string $table
|
|
*/
|
|
public function clearTable($table) {
|
|
$this->query('DELETE FROM "'.$table.'";');
|
|
}
|
|
|
|
/**
|
|
* Return a boolean type-formatted string
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function boolean($values, $asDbValue=false){
|
|
//Annoyingly, we need to do a good ol' fashioned switch here:
|
|
($values['default']) ? $default='1' : $default='0';
|
|
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
if($asDbValue)
|
|
return Array('data_type'=>'smallint');
|
|
else {
|
|
if($values['arrayValue']!='')
|
|
$default='';
|
|
else
|
|
$default=' default ' . (int)$values['default'];
|
|
|
|
return "smallint{$values['arrayValue']}" . $default;
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return a date type-formatted string
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function date($values){
|
|
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
return "date{$values['arrayValue']}";
|
|
}
|
|
|
|
/**
|
|
* Return a decimal type-formatted string
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function decimal($values, $asDbValue=false){
|
|
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
// Avoid empty strings being put in the db
|
|
if($values['precision'] == '') {
|
|
$precision = 1;
|
|
} else {
|
|
$precision = $values['precision'];
|
|
}
|
|
|
|
$defaultValue = '';
|
|
if(isset($values['default']) && is_numeric($values['default'])) {
|
|
$defaultValue = ' default ' . $values['default'];
|
|
}
|
|
|
|
if($asDbValue)
|
|
return Array('data_type'=>'numeric', 'precision'=>$precision);
|
|
else return "decimal($precision){$values['arrayValue']}$defaultValue";
|
|
}
|
|
|
|
/**
|
|
* Return a enum type-formatted string
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function enum($values){
|
|
//Enums are a bit different. We'll be creating a varchar(255) with a constraint of all the usual enum options.
|
|
//NOTE: In this one instance, we are including the table name in the values array
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
if($values['arrayValue']!='')
|
|
$default='';
|
|
else
|
|
$default=" default '{$values['default']}'";
|
|
|
|
return "varchar(255){$values['arrayValue']}" . $default . " check (\"" . $values['name'] . "\" in ('" . implode('\', \'', $values['enums']) . "'))";
|
|
|
|
}
|
|
|
|
/**
|
|
* Return a float type-formatted string
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function float($values, $asDbValue=false){
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
if($asDbValue)
|
|
return Array('data_type'=>'double precision');
|
|
else return "float{$values['arrayValue']}";
|
|
}
|
|
|
|
/**
|
|
* Return a float type-formatted string cause double is not supported
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function double($values, $asDbValue=false){
|
|
return $this->float($values, $asDbValue);
|
|
}
|
|
|
|
/**
|
|
* Return a int type-formatted string
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function int($values, $asDbValue=false){
|
|
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
if($asDbValue)
|
|
return Array('data_type'=>'integer', 'precision'=>'32');
|
|
else {
|
|
if($values['arrayValue']!='')
|
|
$default='';
|
|
else
|
|
$default=' default ' . (int)$values['default'];
|
|
|
|
return "integer{$values['arrayValue']}" . $default;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return a datetime type-formatted string
|
|
* For PostgreSQL, we simply return the word 'timestamp', no other parameters are necessary
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function SS_Datetime($values, $asDbValue=false){
|
|
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
if($asDbValue)
|
|
return Array('data_type'=>'timestamp without time zone');
|
|
else
|
|
return "timestamp{$values['arrayValue']}";
|
|
}
|
|
|
|
/**
|
|
* Return a text type-formatted string
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function text($values, $asDbValue=false){
|
|
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
if($asDbValue)
|
|
return Array('data_type'=>'text');
|
|
else
|
|
return "text{$values['arrayValue']}";
|
|
}
|
|
|
|
/**
|
|
* Return a time type-formatted string
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function time($values){
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
return "time{$values['arrayValue']}";
|
|
}
|
|
|
|
/**
|
|
* Return a varchar type-formatted string
|
|
*
|
|
* @params array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function varchar($values, $asDbValue=false){
|
|
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
if(!isset($values['precision']))
|
|
$values['precision']=255;
|
|
|
|
if($asDbValue)
|
|
return Array('data_type'=>'varchar', 'precision'=>$values['precision']);
|
|
else
|
|
return "varchar({$values['precision']}){$values['arrayValue']}";
|
|
}
|
|
|
|
/*
|
|
* Return a 4 digit numeric type. MySQL has a proprietary 'Year' type.
|
|
* For Postgres, we'll use a 4 digit numeric
|
|
*/
|
|
public function year($values, $asDbValue=false){
|
|
|
|
if(!isset($values['arrayValue']))
|
|
$values['arrayValue']='';
|
|
|
|
//TODO: the DbValue result does not include the numeric_scale option (ie, the ,0 value in 4,0)
|
|
if($asDbValue)
|
|
return Array('data_type'=>'decimal', 'precision'=>'4');
|
|
else
|
|
return "decimal(4,0){$values['arrayValue']}";
|
|
}
|
|
|
|
function escape_character($escape=false){
|
|
if($escape)
|
|
return "\\\"";
|
|
else
|
|
return "\"";
|
|
}
|
|
|
|
/**
|
|
* Create a fulltext search datatype for PostgreSQL
|
|
* This will also return a trigger to be applied to this table
|
|
*
|
|
* @todo: create custom functions to allow weighted searches
|
|
*
|
|
* @param array $spec
|
|
*/
|
|
function fulltext($this_index, $tableName, $name){
|
|
//For full text search, we need to create a column for the index
|
|
$columns = $this->quoteColumnSpecString($this_index['value']);
|
|
|
|
$fulltexts = "\"ts_$name\" tsvector";
|
|
$triggerName = $this->buildPostgresTriggerName($tableName, $name);
|
|
$language = $this->get_search_language();
|
|
|
|
$this->dropTrigger($triggerName, $tableName);
|
|
$triggers = "CREATE TRIGGER \"$triggerName\" BEFORE INSERT OR UPDATE
|
|
ON \"$tableName\" FOR EACH ROW EXECUTE PROCEDURE
|
|
tsvector_update_trigger(\"ts_$name\", 'pg_catalog.$language', $columns);";
|
|
|
|
return Array('name' => $name, 'ts_name' => "ts_{$name}", 'fulltexts' => $fulltexts, 'triggers' => $triggers);
|
|
}
|
|
|
|
/**
|
|
* This returns the column which is the primary key for each table
|
|
* In Postgres, it is a SERIAL8, which is the equivalent of an auto_increment
|
|
*
|
|
* @return string
|
|
*/
|
|
function IdColumn($asDbValue=false){
|
|
if($asDbValue)
|
|
return 'bigint';
|
|
else return 'serial8 not null';
|
|
}
|
|
|
|
/**
|
|
* Returns true if this table exists
|
|
*/
|
|
function hasTable($tableName) {
|
|
$schema_SQL = pg_escape_string($this->dbConn, $this->schema);
|
|
$result = $this->query("SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname = '{$schema_SQL}' AND tablename = '" . $this->addslashes($tableName) . "'");
|
|
|
|
if ($result->numRecords() > 0) return true;
|
|
else return false;
|
|
}
|
|
|
|
/**
|
|
* Returns the SQL command to get all the tables in this database
|
|
*/
|
|
function allTablesSQL(){
|
|
$schema_SQL = pg_escape_string($this->dbConn, $this->schema);
|
|
return "SELECT table_name FROM information_schema.tables WHERE table_schema='{$schema_SQL}' AND table_type='BASE TABLE';";
|
|
}
|
|
|
|
/**
|
|
* Return enum values for the given field
|
|
* @todo Make a proper implementation
|
|
*/
|
|
function enumValuesForField($tableName, $fieldName) {
|
|
//return array('SiteTree','Page');
|
|
$constraints=$this->constraintExists("{$tableName}_{$fieldName}_check");
|
|
$classes=Array();
|
|
if($constraints)
|
|
$classes=$this->EnumValuesFromConstraint($constraints['pg_get_constraintdef']);
|
|
|
|
return $classes;
|
|
}
|
|
|
|
/**
|
|
* Get the actual enum fields from the constraint value:
|
|
*/
|
|
private function EnumValuesFromConstraint($constraint){
|
|
$constraint=substr($constraint, strpos($constraint, 'ANY (ARRAY[')+11);
|
|
$constraint=substr($constraint, 0, -11);
|
|
$constraints=Array();
|
|
$segments=explode(',', $constraint);
|
|
foreach($segments as $this_segment){
|
|
$bits=preg_split('/ *:: */', $this_segment);
|
|
array_unshift($constraints, trim($bits[0], " '"));
|
|
}
|
|
|
|
return $constraints;
|
|
}
|
|
|
|
/**
|
|
* Because NOW() doesn't always work...
|
|
* MSSQL, I'm looking at you
|
|
*
|
|
*/
|
|
function now(){
|
|
return 'NOW()';
|
|
}
|
|
|
|
/*
|
|
* Returns the database-specific version of the random() function
|
|
*/
|
|
function random(){
|
|
return 'RANDOM()';
|
|
}
|
|
|
|
/*
|
|
* This is a lookup table for data types.
|
|
* For instance, Postgres uses 'INT', while MySQL uses 'UNSIGNED'
|
|
* So this is a DB-specific list of equivilents.
|
|
*/
|
|
function dbDataType($type){
|
|
$values=Array(
|
|
'unsigned integer'=>'INT'
|
|
);
|
|
|
|
if(isset($values[$type]))
|
|
return $values[$type];
|
|
else return '';
|
|
}
|
|
|
|
/*
|
|
* This will return text which has been escaped in a database-friendly manner
|
|
* Using PHP's addslashes method won't work in MSSQL
|
|
*/
|
|
function addslashes($value){
|
|
if($this->dbConn) return pg_escape_string($this->dbConn, $value);
|
|
else return pg_escape_string($value);
|
|
}
|
|
|
|
/*
|
|
* This changes the index name depending on database requirements.
|
|
*/
|
|
|
|
function modifyIndex($index, $spec) {
|
|
return $index;
|
|
}
|
|
|
|
/**
|
|
* The core search engine configuration.
|
|
* @todo Properly extract the search functions out of the core.
|
|
*
|
|
* @param string $keywords Keywords as a space separated string
|
|
* @return object DataObjectSet of result pages
|
|
*/
|
|
public function searchEngine($classesToSearch, $keywords, $start, $pageLength, $sortBy = "ts_rank DESC", $extraFilter = "", $booleanSearch = false, $alternativeFileFilter = "", $invertedMatch = false) {
|
|
//Fix the keywords to be ts_query compatitble:
|
|
//Spaces must have pipes
|
|
//@TODO: properly handle boolean operators here.
|
|
$keywords=trim($keywords);
|
|
$keywords=str_replace(' ', ' | ', $keywords);
|
|
$keywords=str_replace('"', "'", $keywords);
|
|
|
|
$keywords = Convert::raw2sql(trim($keywords));
|
|
$htmlEntityKeywords = htmlentities($keywords, ENT_NOQUOTES);
|
|
|
|
//We can get a list of all the tsvector columns though this query:
|
|
//We know what tables to search in based on the $classesToSearch variable:
|
|
$result=DB::query("SELECT table_name, column_name, data_type FROM information_schema.columns WHERE data_type='tsvector' AND table_name in ('" . implode("', '", $classesToSearch) . "');");
|
|
if (!$result->numRecords()) throw new Exception('there are no full text columns to search');
|
|
|
|
$tables=Array();
|
|
|
|
// Make column selection lists
|
|
$select = array(
|
|
'SiteTree' => array(
|
|
"\"ClassName\"",
|
|
"\"SiteTree\".\"ID\"",
|
|
"\"ParentID\"",
|
|
"\"Title\"",
|
|
"\"URLSegment\"",
|
|
"\"Content\"",
|
|
"\"LastEdited\"",
|
|
"\"Created\"",
|
|
"NULL AS \"Filename\"",
|
|
"NULL AS \"Name\"",
|
|
"\"CanViewType\""
|
|
),
|
|
'File' => array(
|
|
"\"ClassName\"",
|
|
"\"File\".\"ID\"",
|
|
"0 AS \"ParentID\"",
|
|
"\"Title\"",
|
|
"NULL AS \"URLSegment\"",
|
|
"\"Content\"",
|
|
"\"LastEdited\"",
|
|
"\"Created\"",
|
|
"\"Filename\"",
|
|
"\"Name\"",
|
|
"NULL AS \"CanViewType\""
|
|
)
|
|
);
|
|
|
|
foreach($result as $row){
|
|
if($row['table_name']=='SiteTree') {
|
|
$showInSearch="AND \"ShowInSearch\"=1 ";
|
|
} elseif($row['table_name']=='File') {
|
|
// File.ShowInSearch was added later, keep the database driver backwards compatible
|
|
// by checking for its existence first
|
|
$fields = $this->fieldList($row['table_name']);
|
|
if(array_key_exists('ShowInSearch', $fields)) $showInSearch="AND \"ShowInSearch\"=1 ";
|
|
else $showInSearch='';
|
|
} else {
|
|
$showInSearch='';
|
|
}
|
|
|
|
//public function extendedSQL($filter = "", $sort = "", $limit = "", $join = "", $having = ""){
|
|
$where = "\"" . $row['table_name'] . "\".\"" . $row['column_name'] . "\" " . $this->default_fts_search_method . ' q ' . $showInSearch;
|
|
$query = DataList::create($row['table_name'])->where($where, '')->dataQuery()->query();
|
|
|
|
$query->addFrom(array('tsearch' => ", to_tsquery('" . $this->get_search_language() . "', '$keywords') AS q"));
|
|
$query->setSelect(array());
|
|
|
|
foreach($select[$row['table_name']] as $clause) {
|
|
if(preg_match('/^(.*) +AS +"?([^"]*)"?/i', $clause, $matches)) {
|
|
$query->selectField($matches[1], $matches[2]);
|
|
} else {
|
|
$query->selectField($clause);
|
|
}
|
|
}
|
|
|
|
$query->selectField("ts_rank(\"{$row['table_name']}\".\"{$row['column_name']}\", q)", 'Relevance');
|
|
$query->setOrderBy(array());
|
|
|
|
//Add this query to the collection
|
|
$tables[] = $query->sql();
|
|
}
|
|
|
|
$limit=$pageLength;
|
|
$offset=$start;
|
|
|
|
if($keywords)
|
|
$orderBy=" ORDER BY $sortBy";
|
|
else $orderBy='';
|
|
|
|
$fullQuery = "SELECT * FROM (" . implode(" UNION ", $tables) . ") AS q1 $orderBy LIMIT $limit OFFSET $offset";
|
|
|
|
// Get the total items in this search
|
|
$totalItemsQuery = "SELECT COUNT(*) AS totalitems FROM (" . implode(" UNION ", $tables) . ") AS q1";
|
|
$totalCount = DB::query($totalItemsQuery);
|
|
|
|
// Get records
|
|
$records = DB::query($fullQuery);
|
|
foreach($records as $record){
|
|
$objects[] = new $record['ClassName']($record);
|
|
}
|
|
|
|
if(isset($objects)) $results = new ArrayList($objects);
|
|
else $results = new ArrayList();
|
|
$list = new PaginatedList($results);
|
|
$list->setLimitItems(false);
|
|
$list->setPageStart($start);
|
|
$list->setPageLength($pageLength);
|
|
$list->setTotalItems($totalCount->value());
|
|
return $list;
|
|
}
|
|
|
|
/*
|
|
* Does this database support transactions?
|
|
*/
|
|
public function supportsTransactions(){
|
|
return $this->supportsTransactions;
|
|
}
|
|
|
|
/*
|
|
* This is a quick lookup to discover if the database supports particular extensions
|
|
*/
|
|
public function supportsExtensions($extensions=Array('partitions', 'tablespaces', 'clustering')){
|
|
if(isset($extensions['partitions']))
|
|
return true;
|
|
elseif(isset($extensions['tablespaces']))
|
|
return true;
|
|
elseif(isset($extensions['clustering']))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @deprecated 1.0 Use transactionStart() (method required for 2.4.x)
|
|
*/
|
|
public function startTransaction($transaction_mode=false, $session_characteristics=false){
|
|
$this->transactionStart($transaction_mode, $session_characteristics);
|
|
}
|
|
|
|
/*
|
|
* Start a prepared transaction
|
|
* See http://developer.postgresql.org/pgdocs/postgres/sql-set-transaction.html for details on transaction isolation options
|
|
*/
|
|
public function transactionStart($transaction_mode=false, $session_characteristics=false){
|
|
DB::query('BEGIN;');
|
|
|
|
if($transaction_mode)
|
|
DB::query('SET TRANSACTION ' . $transaction_mode . ';');
|
|
|
|
if($session_characteristics)
|
|
DB::query('SET SESSION CHARACTERISTICS AS TRANSACTION ' . $session_characteristics . ';');
|
|
}
|
|
|
|
/*
|
|
* Create a savepoint that you can jump back to if you encounter problems
|
|
*/
|
|
public function transactionSavepoint($savepoint){
|
|
DB::query("SAVEPOINT $savepoint;");
|
|
}
|
|
|
|
/*
|
|
* Rollback or revert to a savepoint if your queries encounter problems
|
|
* If you encounter a problem at any point during a transaction, you may
|
|
* need to rollback that particular query, or return to a savepoint
|
|
*/
|
|
public function transactionRollback($savepoint=false){
|
|
|
|
if($savepoint)
|
|
DB::query("ROLLBACK TO $savepoint;");
|
|
else
|
|
DB::query('ROLLBACK;');
|
|
|
|
}
|
|
|
|
/**
|
|
* @deprecated 1.0 Use transactionEnd() (method required for 2.4.x)
|
|
*/
|
|
public function endTransaction(){
|
|
$this->transactionEnd();
|
|
}
|
|
|
|
/*
|
|
* Commit everything inside this transaction so far
|
|
*/
|
|
public function transactionEnd(){
|
|
DB::query('COMMIT;');
|
|
}
|
|
|
|
/*
|
|
* Given a tablespace and and location, either create a new one
|
|
* or update the existing one
|
|
*/
|
|
public function createOrReplaceTablespace($name, $location){
|
|
$existing=DB::query("SELECT spcname, spclocation FROM pg_tablespace WHERE spcname='$name';")->first();
|
|
|
|
//NOTE: this location must be empty for this to work
|
|
//We can't seem to change the location of the tablespace through any ALTER commands :(
|
|
|
|
//If a tablespace with this name exists, but the location has changed, then drop the current one
|
|
//if($existing && $location!=$existing['spclocation'])
|
|
// DB::query("DROP TABLESPACE $name;");
|
|
|
|
//If this is a new tablespace, or we have dropped the current one:
|
|
if(!$existing || ($existing && $location!=$existing['spclocation']))
|
|
DB::query("CREATE TABLESPACE $name LOCATION '$location';");
|
|
|
|
}
|
|
|
|
public function createOrReplacePartition($tableName, $partitions, $indexes, $extensions){
|
|
|
|
//We need the plpgsql language to be installed for this to work:
|
|
$this->createLanguage('plpgsql');
|
|
|
|
$trigger='CREATE OR REPLACE FUNCTION ' . $tableName . '_insert_trigger() RETURNS TRIGGER AS $$ BEGIN ';
|
|
$first=true;
|
|
|
|
//Do we need to create a tablespace for this item?
|
|
if($extensions && isset($extensions['tablespace'])){
|
|
$this->createOrReplaceTablespace($extensions['tablespace']['name'], $extensions['tablespace']['location']);
|
|
$tableSpace=' TABLESPACE ' . $extensions['tablespace']['name'];
|
|
} else
|
|
$tableSpace='';
|
|
|
|
foreach($partitions as $partition_name=>$partition_value){
|
|
//Check that this child table does not already exist:
|
|
if(!$this->TableExists($partition_name)){
|
|
DB::query("CREATE TABLE \"$partition_name\" (CHECK (" . str_replace('NEW.', '', $partition_value) . ")) INHERITS (\"$tableName\")$tableSpace;");
|
|
} else {
|
|
//Drop the constraint, we will recreate in in the next line
|
|
$existing_constraint=$this->query("SELECT conname FROM pg_constraint WHERE conname='{$partition_name}_pkey';");
|
|
if($existing_constraint){
|
|
DB::query("ALTER TABLE \"$partition_name\" DROP CONSTRAINT \"{$partition_name}_pkey\";");
|
|
}
|
|
$this->dropTrigger(strtolower('trigger_' . $tableName . '_insert'), $tableName);
|
|
}
|
|
|
|
DB::query("ALTER TABLE \"$partition_name\" ADD CONSTRAINT \"{$partition_name}_pkey\" PRIMARY KEY (\"ID\");");
|
|
|
|
if($first){
|
|
$trigger.='IF';
|
|
$first=false;
|
|
} else
|
|
$trigger.='ELSIF';
|
|
|
|
$trigger.=" ($partition_value) THEN INSERT INTO \"$partition_name\" VALUES (NEW.*);";
|
|
|
|
if($indexes){
|
|
// We need to propogate the indexes through to the child pages.
|
|
// Some of this code is duplicated, and could be tidied up
|
|
foreach($indexes as $name=>$this_index){
|
|
|
|
if($this_index['type']=='fulltext'){
|
|
$fillfactor=$where='';
|
|
if(isset($this_index['fillfactor']))
|
|
$fillfactor='WITH (FILLFACTOR = ' . $this_index['fillfactor'] . ')';
|
|
if(isset($this_index['where']))
|
|
$where='WHERE ' . $this_index['where'];
|
|
|
|
DB::query("CREATE INDEX \"" . $this->buildPostgresIndexName($partition_name, $this_index['name']) . "\" ON \"" . $partition_name . "\" USING " . $this->default_fts_cluster_method . "(\"ts_" . $name . "\") $fillfactor $where");
|
|
$ts_details=$this->fulltext($this_index, $partition_name, $name);
|
|
DB::query($ts_details['triggers']);
|
|
} else {
|
|
|
|
if(is_array($this_index))
|
|
$index_name=$this_index['name'];
|
|
else $index_name=trim($this_index, '()');
|
|
|
|
$createIndex=$this->getIndexSqlDefinition($partition_name, $index_name, $this_index);
|
|
if($createIndex!==false)
|
|
DB::query($createIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Lastly, clustering goes here:
|
|
if($extensions && isset($extensions['cluster'])){
|
|
DB::query("CLUSTER \"$partition_name\" USING \"{$extensions['cluster']}\";");
|
|
}
|
|
}
|
|
|
|
$trigger.='ELSE RAISE EXCEPTION \'Value id out of range. Fix the ' . $tableName . '_insert_trigger() function!\'; END IF; RETURN NULL; END; $$ LANGUAGE plpgsql;';
|
|
$trigger.='CREATE TRIGGER trigger_' . $tableName . '_insert BEFORE INSERT ON "' . $tableName . '" FOR EACH ROW EXECUTE PROCEDURE ' . $tableName . '_insert_trigger();';
|
|
|
|
DB::query($trigger);
|
|
|
|
}
|
|
|
|
/*
|
|
* This will create a language if it doesn't already exist.
|
|
* This is used by the createOrReplacePartition function, which needs plpgsql
|
|
*/
|
|
public function createLanguage($language){
|
|
$result=DB::query("SELECT lanname FROM pg_language WHERE lanname='$language';")->first();
|
|
|
|
if(!$result){
|
|
DB::query("CREATE LANGUAGE $language;");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate a WHERE clause for text matching.
|
|
*
|
|
* @param String $field Quoted field name
|
|
* @param String $value Escaped search. Can include percentage wildcards.
|
|
* @param boolean $exact Exact matches or wildcard support.
|
|
* @param boolean $negate Negate the clause.
|
|
* @param boolean $caseSensitive Enforce case sensitivity if TRUE or FALSE.
|
|
* Stick with default collation if set to NULL.
|
|
* @return String SQL
|
|
*/
|
|
public function comparisonClause($field, $value, $exact = false, $negate = false, $caseSensitive = null) {
|
|
if($exact && $caseSensitive === null) {
|
|
$comp = ($negate) ? '!=' : '=';
|
|
} else {
|
|
$comp = ($caseSensitive === true) ? 'LIKE' : 'ILIKE';
|
|
if($negate) $comp = 'NOT ' . $comp;
|
|
}
|
|
|
|
return sprintf("%s %s '%s'", $field, $comp, $value);
|
|
}
|
|
|
|
/**
|
|
* Function to return an SQL datetime expression that can be used with Postgres
|
|
* used for querying a datetime in a certain format
|
|
* @param string $date to be formated, can be either 'now', literal datetime like '1973-10-14 10:30:00' or field name, e.g. '"SiteTree"."Created"'
|
|
* @param string $format to be used, supported specifiers:
|
|
* %Y = Year (four digits)
|
|
* %m = Month (01..12)
|
|
* %d = Day (01..31)
|
|
* %H = Hour (00..23)
|
|
* %i = Minutes (00..59)
|
|
* %s = Seconds (00..59)
|
|
* %U = unix timestamp, can only be used on it's own
|
|
* @return string SQL datetime expression to query for a formatted datetime
|
|
*/
|
|
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(
|
|
'/%Y/' => 'YYYY',
|
|
'/%m/' => 'MM',
|
|
'/%d/' => 'DD',
|
|
'/%H/' => 'HH24',
|
|
'/%i/' => 'MI',
|
|
'/%s/' => 'SS',
|
|
);
|
|
$format = preg_replace(array_keys($translate), array_values($translate), $format);
|
|
|
|
if(preg_match('/^now$/i', $date)) {
|
|
$date = "NOW()";
|
|
} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date)) {
|
|
$date = "TIMESTAMP '$date'";
|
|
}
|
|
|
|
if($format == '%U') return "FLOOR(EXTRACT(epoch FROM $date))";
|
|
|
|
return "to_char($date, TEXT '$format')";
|
|
|
|
}
|
|
|
|
/**
|
|
* Function to return an SQL datetime expression that can be used with Postgres
|
|
* used for querying a datetime addition
|
|
* @param string $date, can be either 'now', literal datetime like '1973-10-14 10:30:00' or field name, e.g. '"SiteTree"."Created"'
|
|
* @param string $interval to be added, use the format [sign][integer] [qualifier], e.g. -1 Day, +15 minutes, +1 YEAR
|
|
* supported qualifiers:
|
|
* - years
|
|
* - months
|
|
* - days
|
|
* - hours
|
|
* - minutes
|
|
* - seconds
|
|
* This includes the singular forms as well
|
|
* @return string SQL datetime expression to query for a datetime (YYYY-MM-DD hh:mm:ss) which is the result of the addition
|
|
*/
|
|
function datetimeIntervalClause($date, $interval) {
|
|
|
|
if(preg_match('/^now$/i', $date)) {
|
|
$date = "NOW()";
|
|
} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date)) {
|
|
$date = "TIMESTAMP '$date'";
|
|
}
|
|
|
|
// ... when being too precise becomes a pain. we need to cut of the fractions.
|
|
// TIMESTAMP(0) doesn't work because it rounds instead flooring
|
|
return "CAST(SUBSTRING(CAST($date + INTERVAL '$interval' AS VARCHAR) FROM 1 FOR 19) AS TIMESTAMP)";
|
|
}
|
|
|
|
/**
|
|
* Function to return an SQL datetime expression that can be used with Postgres
|
|
* used for querying a datetime substraction
|
|
* @param string $date1, can be either 'now', literal datetime like '1973-10-14 10:30:00' or field name, e.g. '"SiteTree"."Created"'
|
|
* @param string $date2 to be substracted of $date1, can be either 'now', literal datetime like '1973-10-14 10:30:00' or field name, e.g. '"SiteTree"."Created"'
|
|
* @return string SQL datetime expression to query for the interval between $date1 and $date2 in seconds which is the result of the substraction
|
|
*/
|
|
function datetimeDifferenceClause($date1, $date2) {
|
|
|
|
if(preg_match('/^now$/i', $date1)) {
|
|
$date1 = "NOW()";
|
|
} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date1)) {
|
|
$date1 = "TIMESTAMP '$date1'";
|
|
}
|
|
|
|
if(preg_match('/^now$/i', $date2)) {
|
|
$date2 = "NOW()";
|
|
} else if(preg_match('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/i', $date2)) {
|
|
$date2 = "TIMESTAMP '$date2'";
|
|
}
|
|
|
|
return "(FLOOR(EXTRACT(epoch FROM $date1)) - FLOOR(EXTRACT(epoch from $date2)))";
|
|
}
|
|
|
|
/**
|
|
* Return a set type-formatted string
|
|
* This is used for Multi-enum support, which isn't actually supported by Postgres.
|
|
* Throws a user error to show our lack of support, and return an "int", specifically for sapphire
|
|
* tests that test multi-enums. This results in a test failure, but not crashing the test run.
|
|
*
|
|
* @param array $values Contains a tokenised list of info about this data type
|
|
* @return string
|
|
*/
|
|
public function set($values){
|
|
user_error("PostGreSQL does not support multi-enum");
|
|
return "int";
|
|
}
|
|
|
|
/**
|
|
* Set the current language for the tsearch functions
|
|
*
|
|
* @todo: somehow link this to the locale options?
|
|
*
|
|
* @param string $lang
|
|
*/
|
|
public function set_search_language($lang){
|
|
$this->search_language=$lang;
|
|
}
|
|
|
|
/**
|
|
* Returns the current language for the tsearch functions
|
|
*
|
|
* @param string $lang
|
|
*/
|
|
public function get_search_language(){
|
|
return $this->search_language;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A result-set from a PostgreSQL database.
|
|
* @package sapphire
|
|
* @subpackage model
|
|
*/
|
|
class PostgreSQLQuery extends SS_Query {
|
|
/**
|
|
* The MySQLDatabase object that created this result set.
|
|
* @var PostgreSQLDatabase
|
|
*/
|
|
private $database;
|
|
|
|
/**
|
|
* The internal Postgres handle that points to the result set.
|
|
* @var resource
|
|
*/
|
|
private $handle;
|
|
|
|
/**
|
|
* Hook the result-set given into a Query class, suitable for use by sapphire.
|
|
* @param database The database object that created this query.
|
|
* @param handle the internal Postgres handle that is points to the resultset.
|
|
*/
|
|
public function __construct(PostgreSQLDatabase $database, $handle) {
|
|
$this->database = $database;
|
|
$this->handle = $handle;
|
|
}
|
|
|
|
public function __destruct() {
|
|
if(is_resource($this->handle)) pg_free_result($this->handle);
|
|
}
|
|
|
|
public function seek($row) {
|
|
return pg_result_seek($this->handle, $row);
|
|
}
|
|
|
|
public function numRecords() {
|
|
return pg_num_rows($this->handle);
|
|
}
|
|
|
|
public function nextRecord() {
|
|
if($data = pg_fetch_assoc($this->handle)) {
|
|
return $data;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|
|
|