mirror of
https://github.com/pandorafms/pandorafms.git
synced 2025-09-26 11:29:12 +02:00
9839ef76de
* include/db/postgresql.php, include/db/mysql.php, include/db/oracle.php, include/functions_db.php, operation/agentes/datos_agente.php: Merged from 4.0 branch. Fixed history database connection when the main database and the history database are on the same host. Allow switching between the main database and the history database to retrieve module data. git-svn-id: https://svn.code.sf.net/p/pandora/code/trunk@7078 c3f86ba8-e40f-0410-aaad-9ba5e7f4b01f
1157 lines
34 KiB
PHP
1157 lines
34 KiB
PHP
<?php
|
|
|
|
// Pandora FMS - http://pandorafms.com
|
|
// ==================================================
|
|
// Copyright (c) 2005-2011 Artica Soluciones Tecnologicas
|
|
// Please see http://pandorafms.org for full contribution list
|
|
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public License
|
|
// as published by the Free Software Foundation; version 2
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
/**
|
|
* @package Include
|
|
* @subpackage DataBase
|
|
*/
|
|
|
|
include_once($config['homedir'] . "/include/functions_extensions.php");
|
|
include_once($config['homedir'] . "/include/functions_groups.php");
|
|
include_once($config['homedir'] . "/include/functions_agents.php");
|
|
include_once($config['homedir'] . "/include/functions_modules.php");
|
|
include_once($config['homedir'] . "/include/functions_alerts.php");
|
|
include_once($config['homedir'] . "/include/functions_users.php");
|
|
include_once($config['homedir'] . "/include/functions_ui.php");
|
|
|
|
function db_select_engine() {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
require_once ($config['homedir'] . '/include/db/mysql.php');
|
|
break;
|
|
case "postgresql":
|
|
require_once ($config['homedir'] . '/include/db/postgresql.php');
|
|
break;
|
|
case "oracle":
|
|
require_once ($config['homedir'] . '/include/db/oracle.php');
|
|
break;
|
|
}
|
|
}
|
|
|
|
function db_connect($host = null, $db = null, $user = null, $pass = null, $port = null, $critical = true) {
|
|
global $config;
|
|
static $error = 0;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
$return = mysql_connect_db($host, $db, $user, $pass, $port);
|
|
break;
|
|
case "postgresql":
|
|
$return = postgresql_connect_db($host, $db, $user, $pass, $port);
|
|
break;
|
|
case "oracle":
|
|
$return = oracle_connect_db($host, $db, $user, $pass, $port);
|
|
break;
|
|
default:
|
|
$return = false;
|
|
}
|
|
|
|
// Something went wrong
|
|
if ($return === false) {
|
|
if ($critical) {
|
|
include ($config["homedir"]."/general/error_authconfig.php");
|
|
exit;
|
|
}
|
|
else if ($error == 0) {
|
|
// Display the error once even if multiple connection attempts are made
|
|
$error = 1;
|
|
ui_print_error_message (__("Error connecting to database %s at %s.", $db, $host));
|
|
}
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* When you delete (with the function "db_process_sql_delete" or other) any row in
|
|
* any table, some times the cache save the data just deleted, because you
|
|
* must use "db_clean_cache".
|
|
*/
|
|
|
|
/**
|
|
*
|
|
* Escape string to set it properly to use in sql queries
|
|
*
|
|
* @param string String to be cleaned.
|
|
*
|
|
* @return string String cleaned.
|
|
*/
|
|
function db_escape_string_sql($string) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_escape_string_sql($string);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_escape_string_sql($string);
|
|
break;
|
|
case "oracle":
|
|
return oracle_escape_string_sql($string);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds an audit log entry (new function in 3.0)
|
|
*
|
|
* @param string $accion Action description
|
|
* @param string $descripcion Long action description
|
|
* @param string $id User id, by default is the user that login.
|
|
* @param string $ip The ip to make the action, by default is $_SERVER['REMOTE_ADDR'] or $config["remote_addr"]
|
|
* @param string $info The extended info for enterprise audit, by default is empty string.
|
|
*
|
|
* @return int Return the id of row in tsesion or false in case of fail.
|
|
*/
|
|
function db_pandora_audit($accion, $descripcion, $user_id = false, $ip = false, $info = '') {
|
|
global $config;
|
|
|
|
if ($ip !== false) {
|
|
if (isset($config["remote_addr"])) {
|
|
$ip = $config["remote_addr"];
|
|
}
|
|
else {
|
|
if ($_SERVER['REMOTE_ADDR']) {
|
|
$ip = $_SERVER['REMOTE_ADDR'];
|
|
}
|
|
else {
|
|
$ip = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($user_id !== false) {
|
|
$id = $user_id;
|
|
}
|
|
else {
|
|
if (isset($config["id_user"])) {
|
|
$id = $config["id_user"];
|
|
}
|
|
else $id = 0;
|
|
}
|
|
|
|
$accion = io_safe_input($accion);
|
|
$descripcion = io_safe_input($descripcion);
|
|
|
|
switch ($config['dbtype']){
|
|
case "mysql":
|
|
case "postgresql":
|
|
$values = array('id_usuario' => $id,
|
|
'accion' => $accion,
|
|
'ip_origen' => $ip,
|
|
'descripcion' => $descripcion,
|
|
'fecha' => date('Y-m-d H:i:s'),
|
|
'utimestamp' => time());
|
|
break;
|
|
case "oracle":
|
|
$values = array('id_usuario' => $id,
|
|
'accion' => $accion,
|
|
'ip_origen' => $ip,
|
|
'descripcion' => $descripcion,
|
|
'fecha' => '#to_date(\'' . date('Y-m-d H:i:s') .
|
|
'\',\'YYYY-MM-DD HH24:MI:SS\')',
|
|
'utimestamp' => time());
|
|
break;
|
|
}
|
|
$id_audit = db_process_sql_insert('tsesion', $values);
|
|
|
|
enterprise_include_once('include/functions_audit.php');
|
|
enterprise_hook('audit_pandora_enterprise', array($id_audit, $info));
|
|
|
|
return $id_audit;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Log in a user into Pandora.
|
|
*
|
|
* @param string $id_user User id
|
|
* @param string $ip Client user IP address.
|
|
*/
|
|
function db_logon ($id_user, $ip) {
|
|
db_pandora_audit("Logon", "Logged in", $id_user, $ip);
|
|
|
|
// Update last registry of user to set last logon. How do we audit when the user was created then?
|
|
process_user_contact ($id_user);
|
|
}
|
|
|
|
/**
|
|
* Log out a user into Pandora.
|
|
*
|
|
* @param string $id_user User id
|
|
* @param string $ip Client user IP address.
|
|
*/
|
|
function db_logoff ($id_user, $ip) {
|
|
db_pandora_audit("Logoff", "Logged out", $id_user, $ip);
|
|
}
|
|
|
|
$sql_cache = array ('saved' => 0);
|
|
|
|
/**
|
|
* Get the first value of the first row of a table in the database.
|
|
*
|
|
* @param string Field name to get
|
|
* @param string Table to retrieve the data
|
|
* @param string Field to filter elements
|
|
* @param string Condition the field must have
|
|
*
|
|
* @return mixed Value of first column of the first row. False if there were no row.
|
|
*/
|
|
function db_get_value($field, $table, $field_search = 1, $condition = 1, $search_history_db = false) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_value($field, $table, $field_search, $condition, $search_history_db);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_value($field, $table, $field_search, $condition, $search_history_db);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_value($field, $table, $field_search, $condition, $search_history_db);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the first value of the first row of a table in the database from an
|
|
* array with filter conditions.
|
|
*
|
|
* Example:
|
|
* <code>
|
|
* db_get_value_filter ('name', 'talert_templates',
|
|
* array ('value' => 2, 'type' => 'equal'));
|
|
* // Equivalent to:
|
|
* // SELECT name FROM talert_templates WHERE value = 2 AND type = 'equal' LIMIT 1
|
|
*
|
|
* db_get_value_filter ('description', 'talert_templates',
|
|
* array ('name' => 'My alert', 'type' => 'regex'), 'OR');
|
|
* // Equivalent to:
|
|
* // SELECT description FROM talert_templates WHERE name = 'My alert' OR type = 'equal' LIMIT 1
|
|
* </code>
|
|
*
|
|
* @param string Field name to get
|
|
* @param string Table to retrieve the data
|
|
* @param array Conditions to filter the element. See db_format_array_where_clause_sql()
|
|
* for the format
|
|
* @param string Join operator for the elements in the filter.
|
|
*
|
|
* @return mixed Value of first column of the first row. False if there were no row.
|
|
*/
|
|
function db_get_value_filter ($field, $table, $filter, $where_join = 'AND') {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_value_filter($field, $table, $filter, $where_join);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_value_filter($field, $table, $filter, $where_join);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_value_filter($field, $table, $filter, $where_join);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the first value of the first row of a table result from query.
|
|
*
|
|
* @param string SQL select statement to execute.
|
|
*
|
|
* @return the first value of the first row of a table result from query.
|
|
*
|
|
*/
|
|
function db_get_value_sql($sql, $dbconnection = false) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_value_sql($sql, $dbconnection);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_value_sql($sql, $dbconnection);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_value_sql($sql, $dbconnection);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the first row of an SQL database query.
|
|
*
|
|
* @param string SQL select statement to execute.
|
|
*
|
|
* @return mixed The first row of the result or false
|
|
*/
|
|
function db_get_row_sql($sql, $search_history_db = false) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_row_sql($sql, $search_history_db);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_row_sql($sql, $search_history_db);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_row_sql($sql, $search_history_db);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the first row of a database query into a table.
|
|
*
|
|
* The SQL statement executed would be something like:
|
|
* "SELECT (*||$fields) FROM $table WHERE $field_search = $condition"
|
|
*
|
|
* @param string Table to get the row
|
|
* @param string Field to filter elements
|
|
* @param string Condition the field must have.
|
|
* @param mixed Fields to select (array or string or false/empty for *)
|
|
*
|
|
* @return mixed The first row of a database query or false.
|
|
*/
|
|
function db_get_row ($table, $field_search, $condition, $fields = false) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_row($table, $field_search, $condition, $fields);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_row($table, $field_search, $condition, $fields);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_row($table, $field_search, $condition, $fields);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the row of a table in the database using a complex filter.
|
|
*
|
|
* @param string Table to retrieve the data (warning: not cleaned)
|
|
* @param mixed Filters elements. It can be an indexed array
|
|
* (keys would be the field name and value the expected value, and would be
|
|
* joined with an AND operator) or a string, including any SQL clause (without
|
|
* the WHERE keyword). Example:
|
|
<code>
|
|
Both are similars:
|
|
db_get_row_filter ('table', array ('disabled', 0));
|
|
db_get_row_filter ('table', 'disabled = 0');
|
|
|
|
Both are similars:
|
|
db_get_row_filter ('table', array ('disabled' => 0, 'history_data' => 0), 'name, description', 'OR');
|
|
db_get_row_filter ('table', 'disabled = 0 OR history_data = 0', 'name, description');
|
|
db_get_row_filter ('table', array ('disabled' => 0, 'history_data' => 0), array ('name', 'description'), 'OR');
|
|
</code>
|
|
* @param mixed Fields of the table to retrieve. Can be an array or a coma
|
|
* separated string. All fields are retrieved by default
|
|
* @param string Condition to join the filters (AND, OR).
|
|
*
|
|
* @return mixed Array of the row or false in case of error.
|
|
*/
|
|
function db_get_row_filter($table, $filter, $fields = false, $where_join = 'AND') {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_row_filter($table, $filter, $fields, $where_join);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_row_filter($table, $filter, $fields, $where_join);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_row_filter($table, $filter, $fields, $where_join);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a single field in the databse from a SQL query.
|
|
*
|
|
* @param string SQL statement to execute
|
|
* @param mixed Field number or row to get, beggining by 0. Default: 0
|
|
*
|
|
* @return mixed The selected field of the first row in a select statement.
|
|
*/
|
|
|
|
function db_get_sql ($sql, $field = 0, $search_history_db = false) {
|
|
$result = db_get_all_rows_sql ($sql, $search_history_db);
|
|
|
|
if ($result === false)
|
|
return false;
|
|
|
|
$ax = 0;
|
|
foreach ($result[0] as $f){
|
|
if ($field == $ax)
|
|
return $f;
|
|
$ax++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all the result rows using an SQL statement.
|
|
*
|
|
* @param string SQL statement to execute.
|
|
* @param bool If want to search in history database also
|
|
* @param bool If want to use cache (true by default)
|
|
*
|
|
* @return mixed A matrix with all the values returned from the SQL statement or
|
|
* false in case of empty result
|
|
*/
|
|
function db_get_all_rows_sql($sql, $search_history_db = false, $cache = true, $dbconnection = false) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_all_rows_sql($sql, $search_history_db, $cache, $dbconnection);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_all_rows_sql($sql, $search_history_db, $cache, $dbconnection);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_all_rows_sql($sql, $search_history_db, $cache, $dbconnection);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all the rows of a table in the database that matches a filter.
|
|
*
|
|
* @param string Table to retrieve the data (warning: not cleaned)
|
|
* @param mixed Filters elements. It can be an indexed array
|
|
* (keys would be the field name and value the expected value, and would be
|
|
* joined with an AND operator) or a string, including any SQL clause (without
|
|
* the WHERE keyword). Example:
|
|
* <code>
|
|
* Both are similars:
|
|
* db_get_all_rows_filter ('table', array ('disabled', 0));
|
|
* db_get_all_rows_filter ('table', 'disabled = 0');
|
|
*
|
|
* Both are similars:
|
|
* db_get_all_rows_filter ('table', array ('disabled' => 0, 'history_data' => 0), 'name', 'OR');
|
|
* db_get_all_rows_filter ('table', 'disabled = 0 OR history_data = 0', 'name');
|
|
* </code>
|
|
* @param mixed Fields of the table to retrieve. Can be an array or a coma
|
|
* separated string. All fields are retrieved by default
|
|
* @param string Condition of the filter (AND, OR).
|
|
* @param bool $returnSQL Return a string with SQL instead the data, by default false.
|
|
*
|
|
* @return mixed Array of the row or false in case of error.
|
|
*/
|
|
function db_get_all_rows_filter($table, $filter = array(), $fields = false, $where_join = 'AND', $search_history_db = false, $returnSQL = false) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_all_rows_filter($table, $filter, $fields, $where_join, $search_history_db, $returnSQL);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_all_rows_filter($table, $filter, $fields, $where_join, $search_history_db, $returnSQL);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_all_rows_filter($table, $filter, $fields, $where_join, $search_history_db, $returnSQL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get row by row the DB by SQL query. The first time pass the SQL query and
|
|
* rest of times pass none for iterate in table and extract row by row, and
|
|
* the end return false.
|
|
*
|
|
* @param bool $new Default true, if true start to query.
|
|
* @param resource $result The resource of mysql for access to query.
|
|
* @param string $sql
|
|
* @return mixed The row or false in error.
|
|
*/
|
|
function db_get_all_row_by_steps_sql($new = true, &$result, $sql = null) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_all_row_by_steps_sql($new, $result, $sql);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_all_row_by_steps_sql($new, $result, $sql);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_all_row_by_steps_sql($new, $result, $sql);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the count of rows of query.
|
|
*
|
|
* @param $sql
|
|
* @return integer The count of rows of query.
|
|
*/
|
|
function db_get_num_rows($sql) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_num_rows($sql);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_num_rows($sql);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_num_rows($sql);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Error handler function when an SQL error is triggered.
|
|
*
|
|
* @param int Level of the error raised (not used, but required by set_error_handler()).
|
|
* @param string Contains the error message.
|
|
*
|
|
* @return bool True if error level is lower or equal than errno.
|
|
*/
|
|
function db_sql_error_handler ($errno, $errstr) {
|
|
global $config;
|
|
|
|
/* If debug is activated, this will also show the backtrace */
|
|
if (ui_debug ($errstr))
|
|
return false;
|
|
|
|
if (error_reporting () <= $errno)
|
|
return false;
|
|
|
|
echo "<strong>SQL error</strong>: ".$errstr."<br />\n";
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Add a database query to the debug trace.
|
|
*
|
|
* This functions does nothing if the config['debug'] flag is not set. If a
|
|
* sentence was repeated, then the 'saved' counter is incremented.
|
|
*
|
|
* @param string SQL sentence.
|
|
* @param mixed Query result. On error, error string should be given.
|
|
* @param int Affected rows after running the query.
|
|
* @param mixed Extra parameter for future values.
|
|
*/
|
|
function db_add_database_debug_trace ($sql, $result = false, $affected = false, $extra = false) {
|
|
global $config;
|
|
|
|
if (! isset ($config['debug']))
|
|
return false;
|
|
|
|
if (! isset ($config['db_debug']))
|
|
$config['db_debug'] = array ();
|
|
|
|
if (isset ($config['db_debug'][$sql])) {
|
|
$config['db_debug'][$sql]['saved']++;
|
|
return;
|
|
}
|
|
|
|
$var = array ();
|
|
$var['sql'] = $sql;
|
|
$var['result'] = $result;
|
|
$var['affected'] = $affected;
|
|
$var['saved'] = 0;
|
|
$var['extra'] = $extra;
|
|
|
|
$config['db_debug'][$sql] = $var;
|
|
}
|
|
|
|
/**
|
|
* Clean the cache for to have errors and ghost rows when you do "select <table>",
|
|
* "delete <table>" and "select <table>".
|
|
*
|
|
* @return None
|
|
*/
|
|
function db_clean_cache() {
|
|
global $sql_cache;
|
|
|
|
$sql_cache = array ('saved' => 0);
|
|
}
|
|
|
|
/**
|
|
* This function comes back with an array in case of SELECT
|
|
* in case of UPDATE, DELETE etc. with affected rows
|
|
* an empty array in case of SELECT without results
|
|
* Queries that return data will be cached so queries don't get repeated
|
|
*
|
|
* @param string SQL statement to execute
|
|
*
|
|
* @param string What type of info to return in case of INSERT/UPDATE.
|
|
* 'affected_rows' will return mysql_affected_rows (default value)
|
|
* 'insert_id' will return the ID of an autoincrement value
|
|
* 'info' will return the full (debug) information of a query
|
|
*
|
|
* @param string $status The status and type of query (support only postgreSQL).
|
|
*
|
|
* @param bool $autocommit (Only oracle) Set autocommit transaction mode true/false
|
|
*
|
|
* @return mixed An array with the rows, columns and values in a multidimensional array or false in error
|
|
*/
|
|
function db_process_sql($sql, $rettype = "affected_rows", $dbconnection = '', $cache = true, &$status = null, $autocommit = true) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return @mysql_db_process_sql($sql, $rettype, $dbconnection, $cache);
|
|
break;
|
|
case "postgresql":
|
|
return @postgresql_db_process_sql($sql, $rettype, $dbconnection, $cache, $status);
|
|
break;
|
|
case "oracle":
|
|
return @oracle_db_process_sql($sql, $rettype, $dbconnection, $cache, $status, $autocommit);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all the rows in a table of the database.
|
|
*
|
|
* @param string Database table name.
|
|
* @param string Field to order by.
|
|
* @param string $order The type of order, by default 'ASC'.
|
|
*
|
|
* @return mixed A matrix with all the values in the table
|
|
*/
|
|
function db_get_all_rows_in_table ($table, $order_field = "", $order = 'ASC') {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_all_rows_in_table($table, $order_field, $order);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_all_rows_in_table($table, $order_field, $order);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_all_rows_in_table($table, $order_field, $order);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all the rows in a table of the databes filtering from a field.
|
|
*
|
|
* @param string Database table name.
|
|
* @param string Field of the table.
|
|
* @param string Condition the field must have to be selected.
|
|
* @param string Field to order by.
|
|
*
|
|
* @return mixed A matrix with all the values in the table that matches the condition in the field or false
|
|
*/
|
|
function db_get_all_rows_field_filter($table, $field, $condition, $order_field = "") {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_all_rows_field_filter($table, $field, $condition, $order_field);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_all_rows_field_filter($table, $field, $condition, $order_field);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_all_rows_field_filter($table, $field, $condition, $order_field);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get all the rows in a table of the databes filtering from a field.
|
|
*
|
|
* @param string Database table name.
|
|
* @param string Field of the table.
|
|
*
|
|
* @return mixed A matrix with all the values in the table that matches the condition in the field
|
|
*/
|
|
function db_get_all_fields_in_table($table, $field = '', $condition = '', $order_field = '') {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_all_fields_in_table($table, $field, $condition, $order_field);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_all_fields_in_table($table, $field, $condition, $order_field);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_all_fields_in_table($table, $field, $condition, $order_field);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Formats an array of values into a SQL string.
|
|
*
|
|
* This function is useful to generate an UPDATE SQL sentence from a list of
|
|
* values. Example code:
|
|
*
|
|
* <code>
|
|
* $values = array ();
|
|
* $values['name'] = "Name";
|
|
* $values['description'] = "Long description";
|
|
* $sql = 'UPDATE table SET '.db_format_array_to_update_sql ($values).' WHERE id=1';
|
|
* echo $sql;
|
|
* </code>
|
|
* Will return:
|
|
* <code>
|
|
* UPDATE table SET `name` = "Name", `description` = "Long description" WHERE id=1
|
|
* </code>
|
|
*
|
|
* @param array Values to be formatted in an array indexed by the field name.
|
|
*
|
|
* @return string Values joined into an SQL string that can fits into an UPDATE
|
|
* sentence.
|
|
*/
|
|
function db_format_array_to_update_sql($values) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_format_array_to_update_sql($values);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_format_array_to_update_sql($values);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_format_array_to_update_sql($values);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Formats an array of values into a SQL where clause string.
|
|
*
|
|
* This function is useful to generate a WHERE clause for a SQL sentence from
|
|
* a list of values. Example code:
|
|
<code>
|
|
$values = array ();
|
|
$values['name'] = "Name";
|
|
$values['description'] = "Long description";
|
|
$values['limit'] = $config['block_size']; // Assume it's 20
|
|
$sql = 'SELECT * FROM table WHERE '.db_format_array_where_clause_sql ($values);
|
|
echo $sql;
|
|
</code>
|
|
* Will return:
|
|
* <code>
|
|
* SELECT * FROM table WHERE `name` = "Name" AND `description` = "Long description" LIMIT 20
|
|
* </code>
|
|
*
|
|
* @param array Values to be formatted in an array indexed by the field name.
|
|
* There are special parameters such as 'limit' and 'offset' that will be used
|
|
* as ORDER, LIMIT and OFFSET clauses respectively. Since LIMIT and OFFSET are
|
|
* numerics, ORDER can receive a field name or a SQL function and a the ASC or
|
|
* DESC clause. Examples:
|
|
<code>
|
|
$values = array ();
|
|
$values['value'] = 10;
|
|
$sql = 'SELECT * FROM table WHERE '.db_format_array_where_clause_sql ($values);
|
|
// SELECT * FROM table WHERE VALUE = 10
|
|
|
|
$values = array ();
|
|
$values['value'] = 10;
|
|
$values['order'] = 'name DESC';
|
|
$sql = 'SELECT * FROM table WHERE '.db_format_array_where_clause_sql ($values);
|
|
// SELECT * FROM table WHERE VALUE = 10 ORDER BY name DESC
|
|
|
|
</code>
|
|
* @param string Join operator. AND by default.
|
|
* @param string A prefix to be added to the string. It's useful when limit and
|
|
* offset could be given to avoid this cases:
|
|
<code>
|
|
$values = array ();
|
|
$values['limit'] = 10;
|
|
$values['offset'] = 20;
|
|
$sql = 'SELECT * FROM table WHERE '.db_format_array_where_clause_sql ($values);
|
|
// Wrong SQL: SELECT * FROM table WHERE LIMIT 10 OFFSET 20
|
|
|
|
$values = array ();
|
|
$values['limit'] = 10;
|
|
$values['offset'] = 20;
|
|
$sql = 'SELECT * FROM table WHERE '.db_format_array_where_clause_sql ($values, 'AND', 'WHERE');
|
|
// Good SQL: SELECT * FROM table LIMIT 10 OFFSET 20
|
|
|
|
$values = array ();
|
|
$values['value'] = 5;
|
|
$values['limit'] = 10;
|
|
$values['offset'] = 20;
|
|
$sql = 'SELECT * FROM table WHERE '.db_format_array_where_clause_sql ($values, 'AND', 'WHERE');
|
|
// Good SQL: SELECT * FROM table WHERE value = 5 LIMIT 10 OFFSET 20
|
|
</code>
|
|
*
|
|
* @return string Values joined into an SQL string that can fits into the WHERE
|
|
* clause of an SQL sentence.
|
|
|
|
// IMPORTANT!!! OFFSET parameter is not allowed for Oracle because Oracle needs to recode the complete query.
|
|
// use oracle_format_query() function instead.
|
|
*/
|
|
function db_format_array_where_clause_sql ($values, $join = 'AND', $prefix = false) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_format_array_where_clause_sql($values, $join, $prefix);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_format_array_where_clause_sql($values, $join, $prefix);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_format_array_where_clause_sql($values, $join, $prefix);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete query without commit transaction
|
|
*
|
|
* @param string Table name
|
|
* @param string Field of the filter condition
|
|
* @param string Value of the filter
|
|
*
|
|
* @result Rows deleted or false if something goes wrong
|
|
*/
|
|
function db_process_delete_temp ($table, $row, $value) {
|
|
global $error; //Globalize the errors variable
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
case "postgresql":
|
|
$result = db_process_sql_delete ($table, $row.' = '.$value);
|
|
break;
|
|
case "oracle":
|
|
if (is_int ($value) || is_bool ($value) ||
|
|
is_float ($value) || is_double ($value)) {
|
|
$result = oracle_db_process_sql_delete_temp ($table, $row . ' = ' . $value);
|
|
}
|
|
else {
|
|
$result = oracle_db_process_sql_delete_temp ($table, $row . " = '" . $value . "'");
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ($result === false) {
|
|
$error = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Inserts strings into database
|
|
*
|
|
* The number of values should be the same or a positive integer multiple as the number of rows
|
|
* If you have an associate array (eg. array ("row1" => "value1")) you can use this function with ($table, array_keys ($array), $array) in it's options
|
|
* All arrays and values should have been cleaned before passing. It's not neccessary to add quotes.
|
|
*
|
|
* @param string Table to insert into
|
|
* @param mixed A single value or array of values to insert (can be a multiple amount of rows)
|
|
* @param bool Whether to do autocommit or not (only Oracle)
|
|
*
|
|
* @return mixed False in case of error or invalid values passed. Affected rows otherwise
|
|
*/
|
|
function db_process_sql_insert($table, $values, $autocommit = true) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_process_sql_insert($table, $values);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_process_sql_insert($table, $values);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_process_sql_insert($table, $values, $autocommit);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates a database record.
|
|
*
|
|
* All values should be cleaned before passing. Quoting isn't necessary.
|
|
* Examples:
|
|
*
|
|
* <code>
|
|
* db_process_sql_update ('table', array ('field' => 1), array ('id' => $id));
|
|
* db_process_sql_update ('table', array ('field' => 1), array ('id' => $id, 'name' => $name));
|
|
* db_process_sql_update ('table', array ('field' => 1), array ('id' => $id, 'name' => $name), 'OR');
|
|
* db_process_sql_update ('table', array ('field' => 2), 'id in (1, 2, 3) OR id > 10');
|
|
* </code>
|
|
*
|
|
* @param string Table to insert into
|
|
* @param array An associative array of values to update
|
|
* @param mixed An associative array of field and value matches. Will be joined
|
|
* with operator specified by $where_join. A custom string can also be provided.
|
|
* If nothing is provided, the update will affect all rows.
|
|
* @param string When a $where parameter is given, this will work as the glue
|
|
* between the fields. "AND" operator will be use by default. Other values might
|
|
* be "OR", "AND NOT", "XOR"
|
|
* @param bool Transaction automatically commited or not
|
|
*
|
|
* @return mixed False in case of error or invalid values passed. Affected rows otherwise
|
|
*/
|
|
function db_process_sql_update($table, $values, $where = false, $where_join = 'AND', $autocommit = true) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_process_sql_update($table, $values, $where, $where_join);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_process_sql_update($table, $values, $where, $where_join);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_process_sql_update($table, $values, $where, $where_join, $autocommit);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete database records.
|
|
*
|
|
* All values should be cleaned before passing. Quoting isn't necessary.
|
|
* Examples:
|
|
*
|
|
* <code>
|
|
* db_process_sql_delete ('table', array ('id' => 1));
|
|
* // DELETE FROM table WHERE id = 1
|
|
* db_process_sql_delete ('table', array ('id' => 1, 'name' => 'example'));
|
|
* // DELETE FROM table WHERE id = 1 AND name = 'example'
|
|
* db_process_sql_delete ('table', array ('id' => 1, 'name' => 'example'), 'OR');
|
|
* // DELETE FROM table WHERE id = 1 OR name = 'example'
|
|
* db_process_sql_delete ('table', 'id in (1, 2, 3) OR id > 10');
|
|
* // DELETE FROM table WHERE id in (1, 2, 3) OR id > 10
|
|
* </code>
|
|
*
|
|
* @param string Table to insert into
|
|
* @param array An associative array of values to update
|
|
* @param mixed An associative array of field and value matches. Will be joined
|
|
* with operator specified by $where_join. A custom string can also be provided.
|
|
* If nothing is provided, the update will affect all rows.
|
|
* @param string When a $where parameter is given, this will work as the glue
|
|
* between the fields. "AND" operator will be use by default. Other values might
|
|
* be "OR", "AND NOT", "XOR"
|
|
*
|
|
* @return mixed False in case of error or invalid values passed. Affected rows otherwise
|
|
*/
|
|
function db_process_sql_delete($table, $where, $where_join = 'AND') {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_process_sql_delete($table, $where, $where_join);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_process_sql_delete($table, $where, $where_join);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_process_sql_delete($table, $where, $where_join);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Starts a database transaction.
|
|
*/
|
|
function db_process_sql_begin() {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_process_sql_begin();
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_process_sql_begin();
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_process_sql_begin();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Commits a database transaction.
|
|
*/
|
|
function db_process_sql_commit() {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_process_sql_commit();
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_process_sql_commit();
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_process_sql_commit();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rollbacks a database transaction.
|
|
*/
|
|
function db_process_sql_rollback() {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_process_sql_rollback();
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_process_sql_rollback();
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_process_sql_rollback();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints a database debug table with all the queries done in the page loading.
|
|
*
|
|
* This functions does nothing if the config['debug'] flag is not set.
|
|
*/
|
|
function db_print_database_debug () {
|
|
global $config;
|
|
|
|
if (! isset ($config['debug']))
|
|
return '';
|
|
|
|
echo '<div class="database_debug_title">'.__('Database debug').'</div>';
|
|
|
|
$table->id = 'database_debug';
|
|
$table->cellpadding = '0';
|
|
$table->width = '95%';
|
|
$table->align = array ();
|
|
$table->align[1] = 'left';
|
|
$table->size = array ();
|
|
$table->size[0] = '40px';
|
|
$table->size[2] = '30%';
|
|
$table->size[3] = '40px';
|
|
$table->size[4] = '40px';
|
|
$table->size[5] = '40px';
|
|
$table->data = array ();
|
|
$table->head = array ();
|
|
$table->head[0] = '#';
|
|
$table->head[1] = __('SQL sentence');
|
|
$table->head[2] = __('Result');
|
|
$table->head[3] = __('Rows');
|
|
$table->head[4] = __('Saved');
|
|
$table->head[5] = __('Time (ms)');
|
|
|
|
if (! isset ($config['db_debug']))
|
|
$config['db_debug'] = array ();
|
|
$i = 1;
|
|
foreach ($config['db_debug'] as $debug) {
|
|
$data = array ();
|
|
|
|
$data[0] = $i++;
|
|
$data[1] = $debug['sql'];
|
|
$data[2] = (empty ($debug['result']) ? __('OK') : $debug['result']);
|
|
$data[3] = $debug['affected'];
|
|
$data[4] = $debug['saved'];
|
|
$data[5] = (isset ($debug['extra']['time']) ? format_numeric ($debug['extra']['time'] * 1000, 0) : '');
|
|
|
|
array_push ($table->data, $data);
|
|
|
|
if (($i % 100) == 0) {
|
|
html_print_table ($table);
|
|
$table->data = array ();
|
|
}
|
|
}
|
|
|
|
html_print_table ($table);
|
|
}
|
|
|
|
/**
|
|
* Get last error.
|
|
*
|
|
* @return string Return the string error.
|
|
*/
|
|
function db_get_last_error() {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_last_error();
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_last_error();
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_last_error();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the type of field.
|
|
*
|
|
* @param string $table The table to examine the type of field.
|
|
* @param integer $field The field order in table.
|
|
*
|
|
* @return mixed Return the type name or False in error case.
|
|
*/
|
|
function db_get_type_field_table($table, $field) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_type_field_table($table, $field);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_type_field_table($table, $field);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_type_field_table($table, $field);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the element count of a table.
|
|
*
|
|
* @param string $sql SQL query to get the element count.
|
|
*
|
|
* @return int Return the number of elements in the table.
|
|
*/
|
|
function db_get_table_count($table, $search_history_db = false) {
|
|
global $config;
|
|
|
|
switch ($config["dbtype"]) {
|
|
case "mysql":
|
|
return mysql_db_get_table_count($table, $search_history_db);
|
|
break;
|
|
case "postgresql":
|
|
return postgresql_db_get_table_count($table, $search_history_db);
|
|
break;
|
|
case "oracle":
|
|
return oracle_db_get_table_count($table, $search_history_db);
|
|
break;
|
|
}
|
|
}
|
|
?>
|