CoreLibs/development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Base transfer to namespace complete

Browse Source 
All libraries have been transformed to namespace layout
This commit is contained in:
Clemens Schwaighofer
2018-03-23 19:10:58 +09:00
parent 5474ae2dda
commit 9086196f7d
22 changed files with 2262 additions and 1858 deletions
Download Patch File Download Diff File Expand all files Collapse all files

228
www/lib/CoreLibs/DB/Extended/ArrayIO.inc
View File

@@ -4,7 +4,7 @@
* CREATED: 2002/12/17
* VERSION: 0.4.0
* RELEASED LICENSE: GNU GPL 3
* SHORT DESCRIPTION:
* SHORT DESC :RIPTION:
* DB Array IO Class:
* writes, reads or deletes a complete array (one data set) in/out a
* table from the connected DB.
@@ -14,9 +14,9 @@
*
* PRIVATE VARIABLES
*
* PUBLIC METHODS
* PUBLIC METHOD:S
*
* PRIVATE METHODS
* PRIVATE METHOD:S
*
* HISTORY:
* 2005/07/07 (cs) updated array class for postgres: set 0 & NULL if int field given, insert uses () values () syntax
@@ -36,11 +36,10 @@
// as it actually has nothing to do with this one here ? (or at least
// put into separete function in this class)
// try to include file from LIBS path, or from normal path
_spl_autoload('Class.DB.IO.inc');
namespace CoreLibs\DB\Extended;
// subclass for one array handling
class db_array_io extends db_io
class ArrayIO extends \CoreLibs\DB\IO
{
// main calss variables
public $table_array; // the array from the table to work on
@@ -48,14 +47,14 @@ class db_array_io extends db_io
public $pk_name; // the primary key from this table
public $pk_id; // the PK id
// METHOD db_array_io
// PARAMS db_config -> db_io class init vars
// table_array -> the array from the table
// table_name -> name of the table (for the array)
// db_debug -> turn on db_io debug output (DB_DEBUG as global var does the same)
// RETURN none
// DESC constructor for the array io class, set the
// primary key name automatically (from array)
// METHOD: db_array_io
// PARAMS: db_config -> db_io class init vars
// table_array -> the array from the table
// table_name -> name of the table (for the array)
// db_debug -> turn on db_io debug output (DB_DEBUG as global var does the same)
// RETURN: none
// DESC : constructor for the array io class, set the
// primary key name automatically (from array)
public function __construct($db_config, $table_array, $table_name, $debug = 0, $db_debug = 0, $echo = 1, $print = 0)
{
// instance db_io class
@@ -90,14 +89,15 @@ class db_array_io extends db_io
parent::__destruct();
}
// METHOD convert_data
// PARAMS string -> the string that should be changed
// RETURN string -> the altered string
// DESC changes all previously alterd HTML code into visible one,
// works for <b>,<i>, and <a> (thought <a> can be / or should
// be handled with the magic links functions
// used with the read function
public function convert_data($text)
// METHOD: convertData
// WAS : convert_data
// PARAMS: string -> the string that should be changed
// RETURN: string -> the altered string
// DESC : changes all previously alterd HTML code into visible one,
// works for <b>,<i>, and <a> (thought <a> can be / or should
// be handled with the magic links functions
// used with the read function
public function convertData($text)
{
$text = str_replace('&lt;b&gt;', '<b>', $text);
$text = str_replace('&lt;/b&gt;', '</b>', $text);
@@ -110,11 +110,12 @@ class db_array_io extends db_io
return $text;
}
// METHOD convert_entities
// PARAMS string -> string to be changed
// RETURN string -> altered string
// DESC changeds all HTML entities into non HTML ones
public function convert_entities($text)
// METHOD: convertEntities
// WAS : convert_entities
// PARAMS: string -> string to be changed
// RETURN: string -> altered string
// DESC : changeds all HTML entities into non HTML ones
public function convertEntities($text)
{
$text = str_replace('&lt;', '<', $text);
$text = str_replace('&gt;', '>', $text);
@@ -124,11 +125,12 @@ class db_array_io extends db_io
return $text;
}
// METHOD db_dump_array
// PARAMS none
// RETURN returns the current array
// DESC dumps the current data
public function db_dump_array($write = 0)
// METHOD: dbDumpArray
// WAS : db_dump_array
// PARAMS: none
// RETURN: returns the current array
// DESC : dumps the current data
public function dbDumpArray($write = 0)
{
reset($this->table_array);
while (list($column, $data_array) = each($this->table_array)) {
@@ -141,24 +143,12 @@ class db_array_io extends db_io
return $string;
}
// METHOD _db_error
// PARAMS none
// RETURN none
// DESC writes errors to internal error string
/* function _db_error()
{
// if error occured
if ($this->error_id)
{
$this->error_msg['db'] .= "<b>-DB_ARRAY-error-></b> ".$this->error_id.": ".$this->error_string[$this->error_id]." <br>";
}
} */
// METHOD db_check_pk_set
// PARAMS none
// RETURN none
// DESC checks if pk is set and if not, set from pk_id and if this also not set return 0
public function db_check_pk_set()
// METHOD: dbCheckPkSet
// WAS : db_check_pk_set
// PARAMS: none
// RETURN: none
// DESC : checks if pk is set and if not, set from pk_id and if this also not set return 0
public function dbCheckPkSet()
{
// if pk_id is set, overrule ...
if ($this->pk_id) {
@@ -168,18 +158,19 @@ class db_array_io extends db_io
if (!$this->table_array[$this->pk_name]["value"]) {
// if no PK found, error ...
$this->error_id = 21;
$this->_db_error();
$this->__dbError();
return 0;
} else {
return 1;
}
}
// METHOD db_reset_array
// PARAMS reset_pk -> if set reset the pk too
// RETURN none
// DESC resets the whole array
public function db_reset_array($reset_pk = 0)
// METHOD: dbResetArray
// WAS : db_reset_array
// PARAMS: reset_pk -> if set reset the pk too
// RETURN: none
// DESC : resets the whole array
public function dbResetArray($reset_pk = 0)
{
reset($this->table_array);
while (list($column, $data_array) = each($this->table_array)) {
@@ -191,16 +182,17 @@ class db_array_io extends db_io
}
}
// METHOD db_delete
// PARAMS optional the table_array, if not given uses class var
// RETURN 1 for successfull delete or 0 for error
// DESC deletes one dataset
public function db_delete($table_array = 0)
// METHOD: dbDelete
// WAS : db_delete
// PARAMS: optional the table_array, if not given uses class var
// RETURN: 1 for successfull delete or 0 for error
// DESC : deletes one dataset
public function dbDelete($table_array = 0)
{
if (is_array($table_array)) {
$this->table_array = $table_array;
}
if (!$this->db_check_pk_set()) {
if (!$this->dbCheckPkSet()) {
return $this->table_array;
}
// delete query
@@ -209,7 +201,7 @@ class db_array_io extends db_io
// delete files and build FK query
reset($this->table_array);
while (list($column, $data_array) = each($this->table_array)) {
// suchen nach bildern und löschen ...
// suchen nach bildern und lschen ...
if ($this->table_array[$column]["file"] && file_exists($this->table_array[$column]["url"].$this->table_array[$column]["value"])) {
if (file_exists($this->table_array[$column]["path"].$this->table_array[$column]["value"])) {
unlink($this->table_array[$column]["path"].$this->table_array[$column]["value"]);
@@ -227,7 +219,7 @@ class db_array_io extends db_io
}
$q_where .= $column." = ".$this->table_array[$column]["value"];
}
// allgemeines zurücksetzen des arrays
// allgemeines zurcksetzen des arrays
unset($this->table_array[$column]["value"]);
}
@@ -237,24 +229,25 @@ class db_array_io extends db_io
}
// if 0, error
unset($this->pk_id);
if (!$this->db_exec($q)) {
if (!$this->dbExec($q)) {
$this->error_id=22;
$this->_db_error();
$this->__dbError();
}
return $this->table_array;
}
// METHOD db_read
// PARAMS edit -> if 1 data will not be altered for output, optional the table_array, if not given uses class var
// RETURN true or false for reading
// DESC reads one row into the array
public function db_read($edit = 0, $table_array = 0)
// METHOD: dbRead
// WAS : db_read
// PARAMS: edit -> if 1 data will not be altered for output, optional the table_array, if not given uses class var
// RETURN: true or false for reading
// DESC : reads one row into the array
public function dbRead($edit = 0, $table_array = 0)
{
// if array give, overrules internal array
if (is_array($table_array)) {
$this->table_array = $table_array;
}
if (!$this->db_check_pk_set()) {
if (!$this->dbCheckPkSet()) {
return $this->table_array;
}
reset($this->table_array);
@@ -283,12 +276,12 @@ class db_array_io extends db_io
}
// if query was executed okay, else set error
if ($this->db_exec($q)) {
if ($res = $this->db_fetch_array()) {
if ($this->dbExec($q)) {
if ($res = $this->dbFetchArray()) {
reset($this->table_array);
while (list($column, $data_array) = each($this->table_array)) {
// wenn "edit" dann gib daten wie in DB zurück, ansonten aufbereiten für ausgabe
// ?? sollte das nicht draußen ??? man weis ja net was da drin steht --> is noch zu überlegen
// wenn "edit" dann gib daten wie in DB zurck, ansonten aufbereiten fr ausgabe
// ?? sollte das nicht drauen ??? man weis ja net was da drin steht --> is noch zu berlegen
// echo "EDIT: $edit | Spalte: $column | type: ".$this->table_array[$column]["type"]." | Res: ".$res[$column]."<br>";
if ($edit) {
$this->table_array[$column]["value"] = $res[$column];
@@ -297,25 +290,26 @@ class db_array_io extends db_io
$this->table_array[$column]["HIDDEN_value"] = $res[$column];
}
} else {
$this->table_array[$column]["value"] = $this->convert_data(nl2br($res[$column]));
$this->table_array[$column]["value"] = $this->convertData(nl2br($res[$column]));
// had to put out the htmlentities from the line above as it breaks japanese characters
}
}
}
// possible db_fetch_array errors ...
// possible dbFetchArray errors ...
$this->pk_id = $this->table_array[$this->pk_name]["value"];
} else {
$this->error_id = 22;
$this->_db_error();
$this->__dbError();
}
return $this->table_array;
}
// METHOD db_write
// PARAMS addslashes -> if 1 will make an addslashes for each array field, optional the table_array, if not given uses class var
// RETURN true or false on write
// DESC writes on set into DB or updates one set (if PK exists)
public function db_write($addslashes = 0, $table_array = 0)
// METHOD: dbWrite
// WAS : db_write
// PARAMS: addslashes -> if 1 will make an addslashes for each array field, optional the table_array, if not given uses class var
// RETURN: true or false on write
// DESC : writes on set into DB or updates one set (if PK exists)
public function dbWrite($addslashes = 0, $table_array = 0)
{
if (is_array($table_array)) {
$this->table_array = $table_array;
@@ -427,9 +421,9 @@ class db_array_io extends db_io
$q_data .= "'";
// if add slashes do convert & add slashes else write AS is
if ($addslashes) {
$q_data .= $this->db_escape_string($this->convert_entities($this->table_array[$column]["value"]));
$q_data .= $this->dbEscapeString($this->convertEntities($this->table_array[$column]["value"]));
} else {
$q_data .= $this->db_escape_string($this->table_array[$column]["value"]);
$q_data .= $this->dbEscapeString($this->table_array[$column]["value"]);
}
$q_data .= "'";
}
@@ -454,7 +448,7 @@ class db_array_io extends db_io
if (!$this->table_array[$this->pk_name]["value"]) {
// max id, falls INSERT
$q = "SELECT MAX(".$this->pk_name.") + 1 AS pk_id FROM ".$this->table_name;
$res = $this->db_return_row($q);
$res = $this->dbReturnRow($q);
if (!$res["pk_id"]) {
$res["pk_id"] = 1;
}
@@ -482,9 +476,9 @@ class db_array_io extends db_io
// $this->pk_id = $this->table_array[$this->pk_name]["value"];
}
// return success or not
if (!$this->db_exec($q)) {
if (!$this->dbExec($q)) {
$this->error_id = 22;
$this->_db_error();
$this->__dbError();
}
// set primary key
if ($insert) {
@@ -494,4 +488,60 @@ class db_array_io extends db_io
// return the table if needed
return $this->table_array;
}
// *************************************************************
// COMPATIBILITY METHODS
// those methods are deprecated function call names
// they exist for backwards compatibility only
// *************************************************************
public function convert_data($text)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
return $this->convertData($text);
}
public function convert_entities($text)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
return $this->convertEntities($text);
}
public function db_dump_array($write = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
return $this->dbDumpArray($write);
}
public function db_check_pk_set()
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
return $this->dbCheckPkSet();
}
public function db_reset_array($reset_pk = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
return $this->dbResetArray($reset_pk);
}
public function db_delete($table_array = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
return $this->dbDelete($table_array);
}
public function db_read($edit = 0, $table_array = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
return $this->dbRead($edit, $table_array);
}
public function db_write($addslashes = 0, $table_array = 0)
{
error_log('DEPRECATED CALL: '.__METHOD__.', '.__FILE__.':'.__LINE__.', '.debug_backtrace()[0]['file'].':'.debug_backtrace()[0]['line']);
return $this->dbWrite($addslashes, $table_array);
}
} // end of class
# __END__

1066
www/lib/CoreLibs/DB/IO.inc
View File

File diff suppressed because it is too large Load Diff

143
www/lib/CoreLibs/DB/SQL/PgSQL.inc
View File

@@ -3,8 +3,12 @@
* AUTHOR: Clemens "Gullevek" Schwaighofer (www.gullevek.org)
* CREATED: 2003/04/09
* SHORT DESCRIPTION:
* 2018/3/23, the whole class system is transformed to namespaces
* also all internal class calls are converted to camel case
*
* pgsql wrapper calls
* HISTORY:
*
* HISTORY:
* 2008/04/16 (cs) wrapper for pg escape string
* 2007/01/11 (cs) add prepare/execute for postgres
* 2006/09/12 (cs) in case db_query retuns false, save the query and run the query through the send/get procedure to get correct error data from the db
@@ -37,7 +41,9 @@
*
*/
class db_pgsql
namespace CoreLibs\DB\SQL;
class PgSQL
{
private $last_error_query;
private $dbh;
@@ -51,7 +57,12 @@ class db_pgsql
{
}
public function _db_last_error_query()
// METHOD: __dbLastErrorQuery
// WAS : _db_last_error_query
// PARAMS: none
// RETURN: true/false if last error is set
// DESC : queries last error query and returns true or false if error was set
public function __dbLastErrorQuery()
{
if ($this->last_error_query) {
return true;
@@ -60,11 +71,12 @@ class db_pgsql
}
}
// METHOD: _db_query
// METHOD: __dbQuery
// WAS : _db_query
// PARAMS: query
// RETURN: query result
// DESC : wrapper for gp_query, catches error and stores it in class var
public function _db_query($query)
public function __dbQuery($query)
{
$this->last_error_query = '';
// read out the query status and save the query if needed
@@ -75,20 +87,22 @@ class db_pgsql
return $result;
}
// METHOD: _db_send_query
// METHOD: __dbSendQuery
// WAS : _db_send_query
// PARAMS: query
// RETURN: true/false if query was sent successful
// DESC : sends an async query to the server
public function _db_send_query($query)
public function __dbSendQuery($query)
{
return pg_send_query($this->dbh, $query);
}
// METHOD: _db_get_result
// METHOD: __dbGetResult
// WAS : _db_get_result
// PARAMS: none
// RETURN: resource handler
// DESC : wrapper for pg_get_result
public function _db_get_result()
public function __dbGetResult()
{
$this->last_error_query = '';
$result = pg_get_result($this->dbh);
@@ -98,11 +112,12 @@ class db_pgsql
return $result;
}
// METHOD: _db_close
// METHOD: __dbClose
// WAS : _db_close
// PARAMS: none
// RETURN: none
// DESC : wrapper for pg_close
public function _db_close()
public function __dbClose()
{
if (is_resource($this->dbh)) {
if (pg_connection_status($this->dbh) === PGSQL_CONNECTION_OK) {
@@ -111,11 +126,12 @@ class db_pgsql
}
}
// METHOD: _db_prepare
// METHOD: __dbPrepare
// WAS : _db_prepare
// PARAMS: prepare name, query
// RETURN: prepared statement handler
// DESC : wrapper for pg_prepare
public function _db_prepare($name, $query)
public function __dbPrepare($name, $query)
{
$result = pg_prepare($this->dbh, $name, $query);
if (!$result) {
@@ -124,11 +140,12 @@ class db_pgsql
return $result;
}
// METHOD: _db_execute
// METHOD: __dbExecute
// WAS : _db_execute
// PARAMS: prepare name, data for query
// RETURN: returns status
// DESC : wrapper for pg_execute for running a prepared statement
public function _db_execute($name, $data)
public function __dbExecute($name, $data)
{
$result = pg_execute($this->dbh, $name, $data);
if (!$result) {
@@ -137,73 +154,80 @@ class db_pgsql
return $result;
}
// METHOD: _db_num_rows
// METHOD: __dbNumRows
// WAS : _db_num_rows
// PARAMS: cursor
// RETURN: rows
// DESC : wrapper for pg_num_rows
public function _db_num_rows($cursor)
public function __dbNumRows($cursor)
{
return pg_num_rows($cursor);
}
// METHOD: _db_num_fields
// METHOD: __dbNumFields
// WAS : _db_num_fields
// PARAMS: cursor
// RETURN: number for fields in query
// DESC : wrapper for pg_num_fields
public function _db_num_fields($cursor)
public function __dbNumFields($cursor)
{
return pg_num_fields($cursor);
}
// METHOD: _db_field_name
// METHOD: __dbFieldName
// WAS : _db_field_name
// PARAMS: cursor, field position
// RETURN: name of field
// DESC : wrapper for pg_field_name
public function _db_field_name($cursor, $i)
public function __dbFieldName($cursor, $i)
{
return pg_field_name($cursor, $i);
}
// METHOD: _db_fetch_array
// METHOD: __dbFetchArray
// WAS : _db_fetch_array
// PARAMS: cursor, opt result type
// RETURN: row
// DESC : wrapper for pg_fetch_array
public function _db_fetch_array($cursor, $result_type = '')
public function __dbFetchArray($cursor, $result_type = '')
{
// result type is passed on as is [should be checked]
if ($result_type) {
return pg_fetch_array($cursor, NULL, $result_type);
return pg_fetch_array($cursor, null, $result_type);
} else {
return pg_fetch_array($cursor);
}
}
// METHOD: _db_fetch_all
// METHOD: __dbFetchAll
// WAS : _db_fetch_all
// PARAMS: cursor
// RETURN: all rows as array
// DESC : wrapper for pg_fetch_array
public function _db_fetch_all($cursor)
public function __dbFetchAll($cursor)
{
return pg_fetch_all($cursor);
}
// METHOD: _db_affected_ros
// METHOD: __dbAffectedRows
// WAS : _db_affected_rows
// PARAMS: cursor
// RETURN: number for rows
// DESC : wrapper for pg_affected_rows
public function _db_affected_rows($cursor)
public function __dbAffectedRows($cursor)
{
return pg_affected_rows($cursor);
}
// METHOD: _db_insert_id
// METHOD: __dbInsertId
// WAS : _db_insert_id
// PARAMS: query, primary key name
// RETURN: last insert primary key
// DESC : reads the last inserted primary key for the query
// if ther is no pk_name tries to auto built it from the table name
// this only works if db schema is after "no plural names. and pk name is table name + _id
// detects schema prefix in table name
public function _db_insert_id($query, $pk_name)
public function __dbInsertId($query, $pk_name)
{
// only if an insert has been done
if (preg_match("/^insert /i", $query)) {
@@ -229,8 +253,8 @@ class db_pgsql
$q = "SELECT CURRVAL('$seq') AS insert_id";
// $this->currval_query = $q;
// I have to do manually or I overwrite the original insert internal vars ...
if ($q = $this->_db_query($q)) {
list($id) = $this->_db_fetch_array($q);
if ($q = $this->__dbQuery($q)) {
list($id) = $this->__dbFetchArray($q);
} else {
$id = array(-1, $q);
}
@@ -238,19 +262,20 @@ class db_pgsql
}
}
// METHOD: _db_primary_key
// METHOD: __dbPrimaryKey
// WAS : _db_primary_key
// PARAMS: table and optional schema
// RETURN: primary key name OR false if not possible
// DESC : queries database for the primary key name to this table in the selected schema
public function _db_primary_key($table, $schema = '')
public function __dbPrimaryKey($table, $schema = '')
{
if ($table) {
// check if schema set is different from schema given, only needed if schema is not empty
$table_prefix = '';
if ($schema) {
$q = "SHOW search_path";
$cursor = $this->_db_query($q);
$search_path = $this->_db_fetch_array($cursor)['search_path'];
$cursor = $this->__dbQuery($q);
$search_path = $this->__dbFetchArray($cursor)['search_path'];
if ($search_path != $schema) {
$table_prefix = $schema.'.';
}
@@ -273,9 +298,9 @@ class db_pgsql
$q .= "pg_attribute.attrelid = pg_class.oid AND ";
$q .= "pg_attribute.attnum = any(pg_index.indkey) ";
$q .= "AND indisprimary";
$cursor = $this->_db_query($q);
$cursor = $this->__dbQuery($q);
if ($cursor) {
return $this->_db_fetch_array($cursor)['column_name'];
return $this->__dbFetchArray($cursor)['column_name'];
} else {
return false;
}
@@ -284,11 +309,12 @@ class db_pgsql
}
}
// METHOD: _db_connect
// METHOD: __dbConnect
// WAS : _db_connect
// PARAMS: host name, user name, password, database name, optional port (defaults to default postgres port), optional ssl (default allow)
// RETURN: database handler
// DESC : wrapper for pg_connect, writes out failure to screen if error occurs (hidden var)
public function _db_connect($db_host, $db_user, $db_pass, $db_name, $db_port = 5432, $db_ssl = 'allow')
public function __dbConnect($db_host, $db_user, $db_pass, $db_name, $db_port = 5432, $db_ssl = 'allow')
{
// to avoid empty db_port
if (!$db_port) {
@@ -301,11 +327,12 @@ class db_pgsql
return $this->dbh;
}
// METHOD: _db_print_error
// METHOD: __dbPrintError
// WAS : _db_print_error
// PARAMS: database handler, cursor
// RETURN: error string (HTML)
// DESC : reads the last error for this cursor
public function _db_print_error($cursor = '')
public function __dbPrintError($cursor = '')
{
// run the query again for the error result here
if (!$cursor && $this->last_error_query) {
@@ -318,47 +345,52 @@ class db_pgsql
}
}
// METHOD: _db_meta_data
// METHOD: __dbMetaData
// WAS : _db_meta_data
// PARAMS: table name
// RETURN: array with table data
// DESC : wrapper for pg_emta_data
public function _db_meta_data($table)
public function __dbMetaData($table)
{
return pg_meta_data($this->dbh, $table);
}
// METHOD: _db_escape_string
// METHOD: __dbEscapeString
// WAS : _db_escape_string
// PARAMS: string
// RETURN: escaped string for postgres
// DESC : wrapper for pg_escape_string
public function _db_escape_string($string)
public function __dbEscapeString($string)
{
return pg_escape_string($this->dbh, $string);
}
// METHOD: _db_escape_bytea
// METHOD: __dbEscapeBytea
// WAS : _db_escape_bytea
// PARAMS: string
// RETURN: escape bytes for postgres
// DESC : wrapper for pg_escape_bytea
public function _db_escape_bytea($bytea)
public function __dbEscapeBytea($bytea)
{
return pg_escape_bytea($this->dbh, $bytea);
}
// METHOD: _db_connection_busy
// METHOD: __dbConnectionBusy
// WAS : _db_connection_busy
// PARAMS: none
// RETURN: true/false for busy connection
// DESC : wrapper for pg_connection_busy
public function _db_connection_busy()
public function __dbConnectionBusy()
{
return pg_connection_busy($this->dbh);
}
// METHOD: _db_version
// METHOD: __dbVersion
// WAS : _db_version
// PARAMS: none
// RETURN: databse version
// DESC : wrapper for pg_version
public function _db_version()
public function __dbVersion()
{
// array has client, protocol, server
// we just need the server
@@ -366,13 +398,14 @@ class db_pgsql
return $v['server'];
}
// METHOD: _db_array_parse
// METHOD: __dbArrayParse
// WAS : _db_array_parse
// PARAMS: input text, output array [needed]
// [internal] limit: are we at the end of the parse
// [internal] offset: shift for {}
// RETURN: array with the elements
// DESC : postgresql array to php array
public function _db_array_parse($text, &$output, $limit = false, $offset = 1)
public function __dbArrayParse($text, &$output, $limit = false, $offset = 1)
{
if (false === $limit) {
$limit = strlen($text) - 1;
@@ -395,3 +428,5 @@ class db_pgsql
return $output;
}
}
# __END__

259
www/lib/CoreLibs/DB/SQL/TRAIT_db_pgsql.inc
View File

@@ -1,259 +0,0 @@
<?
/*********************************************************************
* AUTHOR: Clemens "Gullevek" Schwaighofer (www.gullevek.org)
* CREATED: 2003/04/09
* SHORT DESCRIPTION:
* pgsq; wrapper calls
* HISTORY:
* 2008/04/16 (cs) wrapper for pg escape string
* 2007/01/11 (cs) add prepare/execute for postgres
* 2006/09/12 (cs) in case db_query retuns false, save the query and run the query through the send/get procedure to get correct error data from the db
* 2006/06/26 (cs) added port for db connection
* 2006/04/03 (cs) added meta data for table
* 2005/07/25 (cs) removed the plural s remove, not needed and not 100% working
* 2005/07/07 (cs) the default it is table_name _ id
* 2005/01/19 (cs) changed the pgsql connect, so it dies if it can't connect to the DB
* 2004/09/30 (cs) layout cleanup
* /
/* collection of PostgreSQL wrappers
* REQUIRES 5.4 PHP!!! (should do check for this)
*
* pg_prepare
* pg_execute
* pg_num_rows
* pg_num_fields
* pg_field_name
* pg_affected_rows (*)
* pg_fetch_array
* pg_query
* pg_close
* pg_connect (*)
* pg_meta_data
* pg_escape_string
*
*/
trait db_pgsql
{
private $last_error_query;
private $currval_query;
// METHOD: _db_query
// PARAMS: query, database handler
// RETURN: query result
// DESC : wrapper for gp_query, catches error and stores it in class var
private function _db_query($query, $dbh)
{
// read out the query status and save the query if needed
$result = @pg_query($dbh, $query);
if (!$result) {
$this->last_error_query = $query;
}
return $result;
}
// METHOD: _db_close
// PARAMS: database handler
// RETURN: none
// DESC : wrapper for pg_close
private function _db_close($dbh)
{
pg_close($dbh);
}
// METHOD: _db_prepare
// PARAMS: database handler, prepare name, query
// RETURN: prepared statement handler
// DESC : wrapper for pg_prepare
private function _db_prepare($dbh, $name, $query)
{
return @pg_prepare($dbh, $name, $query);
}
// METHOD: _db_execute
// PARAMS: database handler, prepare name, data for query
// RETURN: returns status
// DESC : wrapper for pg_execute for running a prepared statement
private function _db_execute($dbh, $name, $data)
{
return @pg_execute($dbh, $name, $data);
}
// METHOD: _db_num_rows
// PARAMS: cursor
// RETURN: rows
// DESC : wrapper for pg_num_rows
private function _db_num_rows($cursor)
{
return pg_num_rows($cursor);
}
// METHOD: _db_num_fields
// PARAMS: cursor
// RETURN: number for fields in query
// DESC : wrapper for pg_num_fields
private function _db_num_fields($cursor)
{
return pg_num_fields($cursor);
}
// METHOD: _db_field_name
// PARAMS: cursor, field position
// RETURN: name of field
// DESC : wrapper for pg_field_name
private function _db_field_name($cursor, $i)
{
return pg_field_name($cursor, $i);
}
// METHOD: _db_fetch_array
// PARAMS: cursor
// RETURN: row
// DESC : wrapper for pg_fetch_array
private function _db_fetch_array($cursor)
{
return pg_fetch_array($cursor);
}
// METHOD: _db_affected_ros
// PARAMS: database handler, cursor
// RETURN: number for rows
// DESC : wrapper for pg_affected_rows
private function _db_affected_rows($dbh, $cursor)
{
return pg_affected_rows($cursor);
}
// METHOD: _db_insert_id
// PARAMS: database handler, query, primary key name
// RETURN: last insert primary key
// DESC : reads the last inserted primary key for the query
// if ther is no pk_name tries to auto built it from the table name
// this only works if db schema is after "no plural names. and pk name is table name + _id
// detects schema prefix in table name
private function _db_insert_id($dbh, $query, $pk_name)
{
// only if an insert has been done
if (preg_match("/^insert /i", $query)) {
// get table name from insert
$array = explode(' ', $query);
$_table = $array[2];
// if there is a dot inside, we need to split
if (strstr($_table, '.')) {
list ($schema, $table) = explode('.', $_table);
} else {
$table = $_table;
}
// no PK name given at all
if (!$pk_name) {
// if name is plurar, make it singular
// if (preg_match("/.*s$/i", $table))
// $table = substr($table, 0, -1);
// set pk_name to "id"
$pk_name = $table."_id";
}
$seq = (($schema) ? $schema.'.' : '').$table."_".$pk_name."_seq";
$q = "SELECT CURRVAL('$seq') AS insert_id";
$this->currval_query = $q;
//echo "Q: $q<Br>";
// I have to do manually or I overwrite the original insert internal vars ...
if ($q = @pg_query($dbh, $q)) {
list($id) = pg_fetch_array($q);
} else {
$id = array(-1, $q);
}
return $id;
}
}
// METHOD: _db_connect
// PARAMS: host name, user name, password, database name, optional port (defaults to default postgres port), optional ssl (default allow)
// RETURN: database handler
// DESC : wrapper for pg_connect, writes out failure to screen if error occurs (hidden var)
private function _db_connect($db_host, $db_user, $db_pass, $db_name, $db_port = 5432, $db_ssl = 'allow')
{
// to avoid empty db_port
if (!$db_port) {
$db_port = 5432;
}
$this->dbh = @pg_connect("host=".$db_host." port=".$db_port." user=".$db_user." password=".$db_pass." dbname=".$db_name." sslmode=".$db_ssl);
if (!$this->dbh) {
die("<!-- Can't connect [host=".$db_host." port=".$db_port." user=".$db_user." password=XXXX dbname=".$db_name." sslmode=".$db_ssl."] //-->");
}
return $this->dbh;
}
// METHOD: _db_print_error
// PARAMS: database handler, cursor
// RETURN: error string (HTML)
// DESC : reads the last error for this cursor
private function _db_print_error($dbh, $cursor = '')
{
// run the query again for the error result here
if (!$cursor && $this->last_error_query) {
pg_send_query($dbh, $this->last_error_query);
$this->last_error_query = "";
$cursor = pg_get_result($dbh);
}
if (pg_result_error($cursor)) {
return "<span style=\"color: red;\"><b>-PostgreSQL-Error-></b> ".pg_result_error($cursor)."</span><br>";
}
}
// METHOD: _db_meta_data
// PARAMS: database handler, table name
// RETURN: array with table data
// DESC : wrapper for pg_emta_data
private function _db_meta_data($dbh, $table)
{
return @pg_meta_data($dbh, $table);
}
// METHOD: _db_escape_string
// PARAMS: string
// RETURN: escaped string for postgres
// DESC : wrapper for pg_escape_string
private function _db_escape_string($string)
{
return pg_escape_string($this->dbh, $string);
}
// METHOD: _db_escape_bytea
// PARAMS: string
// RETURN: escape bytes for postgres
// DESC : wrapper for pg_escape_bytea
private function _db_escape_bytea($bytea)
{
return pg_escape_bytea($this->dbh, $bytea);
}
// METHOD: _db_array_parse
// PARAMS: input text, output array [needed]
// [internal] limit: are we at the end of the parse
// [internal] offset: shift for {}
// RETURN: array with the elements
// DESC : postgresql array to php array
private function _db_array_parse($text, &$output, $limit = false, $offset = 1)
{
if (false === $limit) {
$limit = strlen($text) - 1;
$output = array();
}
if ('{}' != $text) {
do {
if ('{' != $text{$offset}) {
preg_match("/(\\{?\"([^\"\\\\]|\\\\.)*\"|[^,{}]+)+([,}]+)/", $text, $match, 0, $offset);
$offset += strlen($match[0]);
$output[] = ('"' != $match[1]{0} ? $match[1] : stripcslashes(substr($match[1], 1, -1)));
if ('},' == $match[3]) {
return $offset;
}
} else {
$offset = pg_array_parse($text, $output[], $limit, $offset + 1);
}
} while ($limit > $offset);
}
return $output;
}
}

375
www/lib/CoreLibs/DB/SQL/db_pgsql_pdo.inc
View File

@@ -1,375 +0,0 @@
<?
/*********************************************************************
* AUTHOR: Clemens "Gullevek" Schwaighofer (www.gullevek.org)
* CREATED: 2014/12/3
* SHORT DESCRIPTION:
* pgsql pdo wrapper calls
* HISTORY:
* /
/* collection of PostgreSQL wrappers
* REQUIRES 5.x PHP with compiled pdo pgsql (--with-pdo-pgsql)
*
*/
class db_pgsql
{
private $last_error_query;
private $dbh;
private $cursor = array();
// METHOD: __construct
// PARAMS: none
// RETURN: none
// DESC : class constructor
public function __construct()
{
}
public function _db_last_error_query()
{
if ($this->last_error_query) {
return true;
} else {
return false;
}
}
// METHOD: _db_query
// PARAMS: query
// RETURN: cursor
// DESC : was wrapper for pg_query, now it runs pepare and execute in one set. uses the query md5 as the cursor name
public function _db_query($query)
{
$this->last_error_query = '';
/* // read out the query status and save the query if needed
$result = @pg_query($this->dbh, $query);
if (!$result)
$this->last_error_query = $query; */
$cursor = $this->_db_prepare(md5($query), $query);
$result = $this->_db_execute(md5($query), array ());
if (!$result) {
$this->last_error_query = $query;
}
return $cursor;
}
// METHOD: _db_query_result
// PARAMS: query
// RETURN: result from query
// DESC : only valid for the pdo version here. use with care
public function _db_query_result($query)
{
return $this->dbh->query($query);
}
// METHOD: _db_send_query
// PARAMS: query
// RETURN: true/false if query was sent successful
// DESC : sends an async query to the server
public function _db_send_query($query)
{
// return @pg_send_query($this->dbh, $query);
}
// METHOD: _db_get_result
// PARAMS: none
// RETURN: resource handler
// DESC : wrapper for pg_get_result
public function _db_get_result()
{
$this->last_error_query = '';
/* $result = pg_get_result($this->dbh);
if ($error = pg_result_error($result)) {
$this->last_error_query = $error;
}*/
return $result;
}
// METHOD: _db_close
// PARAMS: none
// RETURN: none
// DESC : wrapper for pg_close
public function _db_close()
{
if (is_array($this->cursor)) {
foreach ($this->cursor as $key => $data) {
$this->cursor[$key]->closeCursor;
$this->cursor[$key] = null;
}
}
$this->dbh = null;
}
// METHOD: _db_prepare
// PARAMS: prepare name, query
// RETURN: prepared statement handler
// DESC : wrapper for pg_prepare
public function _db_prepare($name, $query)
{
// return @pg_prepare($this->dbh, $name, $query);
$this->cursor[$name] = $this->dbh->prepare($query);
return $this->cursor[$name];
}
// METHOD: _db_execute
// PARAMS: prepare name, data for query
// RETURN: returns status
// DESC : wrapper for pg_execute for running a prepared statement
public function _db_execute($name, $data)
{
// return @pg_execute($this->dbh, $name, $data);
return $this->cursor[$name]->execute($data);
}
// METHOD: _db_num_rows
// PARAMS: cursor
// RETURN: rows
// DESC : wrapper for pg_num_rows
public function _db_num_rows($cursor)
{
// return pg_num_rows($cursor);
return $cusor->rowCount();
}
// METHOD: _db_num_fields
// PARAMS: cursor
// RETURN: number for fields in query
// DESC : wrapper for pg_num_fields
public function _db_num_fields($cursor)
{
// return pg_num_fields($cursor);
return $cursor->columnCount();
}
// METHOD: _db_field_name
// PARAMS: cursor, field position
// RETURN: name of field
// DESC : wrapper for pg_field_name
public function _db_field_name($cursor, $i)
{
// return pg_field_name($cursor, $i);
}
// METHOD: _db_fetch_array
// PARAMS: cursor
// RETURN: row
// DESC : wrapper for pg_fetch_array
public function _db_fetch_array($cursor)
{
// return pg_fetch_array($cursor);
return $cursor->fetch();
}
// METHOD: _db_affected_ros
// PARAMS: cursor
// RETURN: number for rows
// DESC : wrapper for pg_affected_rows
public function _db_affected_rows($cursor)
{
// return pg_affected_rows($cursor);
return $cusor->rowCount();
}
// METHOD: _db_insert_id
// PARAMS: query, primary key name
// RETURN: last insert primary key
// DESC : reads the last inserted primary key for the query
// if ther is no pk_name tries to auto built it from the table name
// this only works if db schema is after "no plural names. and pk name is table name + _id
// detects schema prefix in table name
public function _db_insert_id($query, $pk_name)
{
// only if an insert has been done
if (preg_match("/^insert /i", $query)) {
$schema = '';
// get table name from insert
$array = explode(' ', $query);
$_table = $array[2];
// if there is a dot inside, we need to split
if (strstr($_table, '.')) {
list($schema, $table) = explode('.', $_table);
} else {
$table = $_table;
}
// no PK name given at all
if (!$pk_name) {
// if name is plural, make it singular
// if (preg_match("/.*s$/i", $table))
// $table = substr($table, 0, -1);
// set pk_name to "id"
$pk_name = $table."_id";
}
$seq = (($schema) ? $schema.'.' : '').$table."_".$pk_name."_seq";
$q = "SELECT CURRVAL('$seq') AS insert_id";
// I have to do manually or I overwrite the original insert internal vars ...
$row = $this->_db_query_result($q);
if ($row['insert_id']) {
$id = $row['insert_id'];
} else {
$id = array(-1, $q);
}
return $id;
}
}
// METHOD: _db_primary_key
// PARAMS: table and optional schema
// RETURN: primary key name OR false if not possible
// DESC : queries database for the primary key name to this table in the selected schema
public function _db_primary_key($table, $schema = '')
{
if ($table) {
// check if schema set is different from schema given, only needed if schema is not empty
$table_prefix = '';
if ($schema) {
$q = "SHOW search_path";
// $cursor = $this->_db_query($q);
// $search_path = $this->_db_fetch_array($cursor)['search_path'];
$search_path = $this->_db_query_result($q)['search_path'];
if ($search_path != $schema) {
$table_prefix = $schema.'.';
}
}
// read from table the PK name
// faster primary key get
$q = "SELECT pg_attribute.attname AS column_name, format_type(pg_attribute.atttypid, pg_attribute.atttypmod) AS type ";
$q .= "FROM pg_index, pg_class, pg_attribute ";
if ($schema) {
$q .= ", pg_namespace ";
}
$q .= "WHERE ";
// regclass translates the OID to the name
$q .= "pg_class.oid = '".$table_prefix.$table."'::regclass AND ";
$q .= "indrelid = pg_class.oid AND ";
if ($schema) {
$q .= "nspname = '".$schema."' AND ";
$q .= "pg_class.relnamespace = pg_namespace.oid AND ";
}
$q .= "pg_attribute.attrelid = pg_class.oid AND ";
$q .= "pg_attribute.attnum = any(pg_index.indkey) ";
$q .= "AND indisprimary";
$row = $this->_db_query_result($q);
if ($row === false) {
return false;
} else {
return $row['column_name'];
}
} else {
return false;
}
}
// METHOD: _db_connect
// PARAMS: host name, user name, password, database name, optional port (defaults to default postgres port), optional ssl (default allow)
// RETURN: database handler
// DESC : wrapper for pg_connect, writes out failure to screen if error occurs (hidden var)
public function _db_connect($db_host, $db_user, $db_pass, $db_name, $db_port = 5432, $db_ssl = 'allow')
{
// to avoid empty db_port
if (!$db_port) {
$db_port = 5432;
}
try {
$this->dbh = new PDO('pgsql:host='.$db_host.';dbname='.$db_name.';port='.$db_port.';sslmode='.$db_ssl, $db_user, $db_pass);
} catch (PDOException $e) {
print "Error!: ".$e->getMessage()."\n";
die("<!-- Can't connect [host=".$db_host." port=".$db_port." user=".$db_user." password=XXXX dbname=".$db_name." sslmode=".$db_ssl."]: ".$e->getMEssage()."//-->");
}
return $this->dbh;
}
// METHOD: _db_print_error
// PARAMS: database handler, cursor
// RETURN: error string (HTML)
// DESC : reads the last error for this cursor
public function _db_print_error($cursor = '')
{
/* // run the query again for the error result here
if (!$cursor && $this->last_error_query)
{
pg_send_query($this->dbh, $this->last_error_query);
$this->last_error_query = '';
$cursor = pg_get_result($this->dbh);
}
if (pg_result_error($cursor))
return "<span style=\"color: red;\"><b>-PostgreSQL-Error-></b> ".pg_result_error($cursor)."</span><br>"; */
}
// METHOD: _db_meta_data
// PARAMS: table name
// RETURN: array with table data
// DESC : wrapper for pg_emta_data
public function _db_meta_data($table)
{
// return @pg_meta_data($this->dbh, $table);
}
// METHOD: _db_escape_string
// PARAMS: string
// RETURN: escaped string for postgres
// DESC : wrapper for pg_escape_string
public function _db_escape_string($string)
{
// return pg_escape_string($this->dbh, $string);
}
// METHOD: _db_escape_bytea
// PARAMS: string
// RETURN: escape bytes for postgres
// DESC : wrapper for pg_escape_bytea
public function _db_escape_bytea($bytea)
{
// return pg_escape_bytea($this->dbh, $bytea);
}
// METHOD: _db_connection_busy
// PARAMS: none
// RETURN: true/false for busy connection
// DESC : wrapper for pg_connection_busy
public function _db_connection_busy()
{
// return pg_connection_busy($this->dbh);
}
// METHOD: _db_version
// PARAMS: none
// RETURN: databse version
// DESC : wrapper for pg_version
public function _db_version()
{
// array has client, protocol, server
// we just need the server
$v = pg_version($this->dbh);
return $v['server'];
}
// METHOD: _db_array_parse
// PARAMS: input text, output array [needed]
// [internal] limit: are we at the end of the parse
// [internal] offset: shift for {}
// RETURN: array with the elements
// DESC : postgresql array to php array
public function _db_array_parse($text, &$output, $limit = false, $offset = 1)
{
if (false === $limit) {
$limit = strlen($text) - 1;
$output = array();
}
if ('{}' != $text) {
do {
if ('{' != $text{$offset}) {
preg_match("/(\\{?\"([^\"\\\\]|\\\\.)*\"|[^,{}]+)+([,}]+)/", $text, $match, 0, $offset);
$offset += strlen($match[0]);
$output[] = ('"' != $match[1]{0} ? $match[1] : stripcslashes(substr($match[1], 1, -1)));
if ('},' == $match[3]) {
return $offset;
}
} else {
$offset = pg_array_parse($text, $output[], $limit, $offset + 1);
}
} while ($limit > $offset);
}
return $output;
}
}