1991 lines
63 KiB
PHP
Executable File
1991 lines
63 KiB
PHP
Executable File
<?php
|
|
namespace phpformbuilder\database;
|
|
|
|
/**
|
|
* Ultimate MySQL Wrapper Class
|
|
*
|
|
* @version 3.0
|
|
* @author Jeff L. Williams
|
|
* @link http://www.phpclasses.org/ultimatemysql
|
|
*
|
|
* Contributions from
|
|
* Frank P. Walentynowicz
|
|
* Larry Wakeman
|
|
* Nicola Abbiuso
|
|
* Douglas Gintz
|
|
* Emre Erkan
|
|
* Vincent van Daal
|
|
* Michael Ansaldi
|
|
* Ryan Tse
|
|
*/
|
|
|
|
class Mysql
|
|
{
|
|
// SET THESE VALUES TO MATCH YOUR DATA CONNECTION
|
|
private $db_host = "localhost"; // server name
|
|
private $db_user = ""; // user name
|
|
private $db_pass = ""; // password
|
|
private $db_dbname = ""; // database name
|
|
private $db_host_local = "localhost"; // server name
|
|
private $db_user_local = "root"; // user name
|
|
private $db_pass_local = ""; // password
|
|
private $db_dbname_local = "test"; // database name
|
|
private $db_charset = "utf8"; // optional character set (i.e. utf8)
|
|
private $db_pcon = false; // use persistent connection?
|
|
|
|
// constants for sqlValue function
|
|
const SQLVALUE_BIT = "bit";
|
|
const SQLVALUE_BOOLEAN = "boolean";
|
|
const SQLVALUE_DATE = "date";
|
|
const SQLVALUE_DATETIME = "datetime";
|
|
const SQLVALUE_NUMBER = "number";
|
|
const SQLVALUE_T_F = "t-f";
|
|
const SQLVALUE_TEXT = "text";
|
|
const SQLVALUE_TIME = "time";
|
|
const SQLVALUE_Y_N = "y-n";
|
|
|
|
// class-internal variables - do not change
|
|
public $mysql_link = 0; // mysql link resource
|
|
private $active_row = -1; // current row
|
|
private $error_desc = ""; // last mysql error string
|
|
private $error_number = 0; // last mysql error number
|
|
private $in_transaction = false; // used for transactions
|
|
private $last_insert_id; // last id of record inserted
|
|
private $last_result; // last mysql query result
|
|
private $last_sql = ""; // last mysql query
|
|
private $time_diff = 0; // holds the difference in time
|
|
private $time_start = 0; // start time for the timer
|
|
|
|
/**
|
|
* Determines if an error throws an exception
|
|
*
|
|
* @var boolean Set to true to throw error exceptions
|
|
*/
|
|
public $throw_exceptions = false;
|
|
|
|
/**
|
|
* Constructor: Opens the connection to the database
|
|
*
|
|
* @param boolean $connect (Optional) Auto-connect when object is created
|
|
* @param string $database (Optional) Database name
|
|
* @param string $server (Optional) Host address
|
|
* @param string $username (Optional) User name
|
|
* @param string $password (Optional) Password
|
|
* @param string $charset (Optional) Character set
|
|
*/
|
|
public function __construct($connect = true, $database = DBNAME, $server = DBHOST, $username = DBUSER, $password = DBPASS, $charset = null)
|
|
{
|
|
if ($database !== null) {
|
|
$this->db_dbname = $database;
|
|
}
|
|
if ($server !== null) {
|
|
$this->db_host = $server;
|
|
}
|
|
if ($username !== null) {
|
|
$this->db_user = $username;
|
|
}
|
|
if ($password !== null) {
|
|
$this->db_pass = $password;
|
|
}
|
|
if ($charset !== null) {
|
|
$this->db_charset = $charset;
|
|
}
|
|
|
|
if (strlen($this->db_host) > 0 &&
|
|
strlen($this->db_user) > 0) {
|
|
if ($connect && (!$this->isConnected())) {
|
|
$this->open();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Destructor: Closes the connection to the database
|
|
*
|
|
*/
|
|
public function __destruct()
|
|
{
|
|
$this->close();
|
|
}
|
|
|
|
/**
|
|
* Automatically does an INSERT or UPDATE depending if an existing record
|
|
* exists in a table
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @param array $valuesArray An associative array containing the column
|
|
* names as keys and values as data. The values
|
|
* must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect)
|
|
* @param array $whereArray An associative array containing the column
|
|
* names as keys and values as data. The values
|
|
* must be SQL ready (i.e. quotes around strings,
|
|
* formatted dates, ect).
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function autoInsertUpdate($tableName, $valuesArray, $whereArray)
|
|
{
|
|
$this->resetError();
|
|
$this->selectRows($tableName, $whereArray);
|
|
if (! $this->error()) {
|
|
if ($this->hasRecords()) {
|
|
return $this->updateRows($tableName, $valuesArray, $whereArray);
|
|
} else {
|
|
return $this->insertRow($tableName, $valuesArray);
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the internal pointer is at the beginning of the records
|
|
*
|
|
* @return boolean TRUE if at the first row or false if not
|
|
*/
|
|
public function beginningOfSeek()
|
|
{
|
|
$this->resetError();
|
|
if ($this->isConnected()) {
|
|
if ($this->active_row < 1) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* [STATIC] Builds a comma delimited list of columns for use with SQL
|
|
*
|
|
* @param array $valuesArray An array containing the column names.
|
|
* @param boolean $addQuotes (Optional) TRUE to add quotes
|
|
* @param boolean $showAlias (Optional) TRUE to show column alias
|
|
* @return string Returns the SQL column list
|
|
*/
|
|
private static function buildSQLColumns($columns, $addQuotes = true, $showAlias = true)
|
|
{
|
|
if ($addQuotes) {
|
|
$quote = "`";
|
|
} else {
|
|
$quote = "";
|
|
}
|
|
switch (gettype($columns)) {
|
|
case "array":
|
|
$sql = "";
|
|
foreach ($columns as $key => $value) {
|
|
// Build the columns
|
|
if (strlen($sql) == 0) {
|
|
$sql = $quote . $value . $quote;
|
|
} else {
|
|
$sql .= ", " . $quote . $value . $quote;
|
|
}
|
|
if ($showAlias && is_string($key) && (! empty($key))) {
|
|
$sql .= ' AS "' . $key . '"';
|
|
}
|
|
}
|
|
|
|
return $sql;
|
|
break;
|
|
case "string":
|
|
return $quote . $columns . $quote;
|
|
break;
|
|
default:
|
|
return false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* [STATIC] Builds a SQL DELETE statement
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @param array $whereArray (Optional) An associative array containing the
|
|
* column names as keys and values as data. The
|
|
* values must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect). If not specified
|
|
* then all values in the table are deleted.
|
|
* @return string Returns the SQL DELETE statement
|
|
*/
|
|
public static function buildSQLDelete($tableName, $whereArray = null)
|
|
{
|
|
$sql = "DELETE FROM `" . $tableName . "`";
|
|
if (! is_null($whereArray)) {
|
|
$sql .= self::buildSQLWhereClause($whereArray);
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* [STATIC] Builds a SQL INSERT statement
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @param array $valuesArray An associative array containing the column
|
|
* names as keys and values as data. The values
|
|
* must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect)
|
|
* @return string Returns a SQL INSERT statement
|
|
*/
|
|
public static function buildSQLInsert($tableName, $valuesArray)
|
|
{
|
|
$columns = self::buildSQLColumns(array_keys($valuesArray));
|
|
$values = self::buildSQLColumns($valuesArray, false, false);
|
|
$sql = "INSERT INTO `" . $tableName .
|
|
"` (" . $columns . ") VALUES (" . $values . ")";
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Builds a simple SQL SELECT statement
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @param array $whereArray (Optional) An associative array containing the
|
|
* column names as keys and values as data. The
|
|
* values must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect)
|
|
* @param array/string $columns (Optional) The column or list of columns to select
|
|
* @param array/string $sortColumns (Optional) Column or list of columns to sort by
|
|
* @param boolean $sortAscending (Optional) TRUE for ascending; false for descending
|
|
* This only works if $sortColumns are specified
|
|
* @param integer/string $limit (Optional) The limit of rows to return
|
|
* @return string Returns a SQL SELECT statement
|
|
*/
|
|
public static function buildSQLSelect($tableName, $whereArray = null, $columns = null, $sortColumns = null, $sortAscending = true, $limit = null)
|
|
{
|
|
if (! is_null($columns)) {
|
|
$sql = self::buildSQLColumns($columns);
|
|
} else {
|
|
$sql = "*";
|
|
}
|
|
$sql = "SELECT " . $sql . " FROM `" . $tableName . "`";
|
|
if (is_array($whereArray)) {
|
|
$sql .= self::buildSQLWhereClause($whereArray);
|
|
}
|
|
if (! is_null($sortColumns)) {
|
|
$sql .= " ORDER BY " .
|
|
self::buildSQLColumns($sortColumns, true, false) .
|
|
" " . ($sortAscending ? "ASC" : "DESC");
|
|
}
|
|
if (! is_null($limit)) {
|
|
$sql .= " LIMIT " . $limit;
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* [STATIC] Builds a SQL UPDATE statement
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @param array $valuesArray An associative array containing the column
|
|
* names as keys and values as data. The values
|
|
* must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect)
|
|
* @param array $whereArray (Optional) An associative array containing the
|
|
* column names as keys and values as data. The
|
|
* values must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect). If not specified
|
|
* then all values in the table are updated.
|
|
* @return string Returns a SQL UPDATE statement
|
|
*/
|
|
public static function buildSQLUpdate($tableName, $valuesArray, $whereArray = null)
|
|
{
|
|
$sql = "";
|
|
foreach ($valuesArray as $key => $value) {
|
|
if (strlen($sql) == 0) {
|
|
$sql = "`" . $key . "` = " . $value;
|
|
} else {
|
|
$sql .= ", `" . $key . "` = " . $value;
|
|
}
|
|
}
|
|
$sql = "UPDATE `" . $tableName . "` SET " . $sql;
|
|
if (is_array($whereArray)) {
|
|
$sql .= self::buildSQLWhereClause($whereArray);
|
|
}
|
|
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* [STATIC] Builds a SQL WHERE clause from an array.
|
|
* If a key is specified, the key is used at the field name and the value
|
|
* as a comparison. If a key is not used, the value is used as the clause.
|
|
*
|
|
* @param array $whereArray An associative array containing the column
|
|
* names as keys and values as data. The values
|
|
* must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect)
|
|
* @return string Returns a string containing the SQL WHERE clause
|
|
*/
|
|
public static function buildSQLWhereClause($whereArray)
|
|
{
|
|
$where = "";
|
|
foreach ($whereArray as $key => $value) {
|
|
if (strlen($where) == 0) {
|
|
if (is_null($value)) {
|
|
$where = " WHERE `" . $key . "` IS NULL";
|
|
} elseif (is_string($key)) {
|
|
$where = " WHERE `" . $key . "` = " . $value;
|
|
} else {
|
|
$where = " WHERE " . $value;
|
|
}
|
|
} else {
|
|
if (is_null($value)) {
|
|
$where = " AND `" . $key . "` IS NULL";
|
|
} elseif (is_string($key)) {
|
|
$where .= " AND `" . $key . "` = " . $value;
|
|
} else {
|
|
$where .= " AND " . $value;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $where;
|
|
}
|
|
|
|
/**
|
|
* Close current MySQL connection
|
|
*
|
|
* @return object Returns TRUE on success or false on error
|
|
*/
|
|
public function close()
|
|
{
|
|
$this->resetError();
|
|
$this->active_row = -1;
|
|
$success = $this->release();
|
|
if ($success) {
|
|
$success = @mysqli_close($this->mysql_link);
|
|
if (! $success) {
|
|
$this->setError();
|
|
} else {
|
|
unset($this->last_sql);
|
|
unset($this->last_result);
|
|
unset($this->mysql_link);
|
|
}
|
|
}
|
|
|
|
return $success;
|
|
}
|
|
|
|
/**
|
|
* Deletes rows in a table based on a WHERE filter
|
|
* (can be just one or many rows based on the filter)
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @param array $whereArray (Optional) An associative array containing the
|
|
* column names as keys and values as data. The
|
|
* values must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect). If not specified
|
|
* then all values in the table are deleted.
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function deleteRows($tableName, $whereArray = null)
|
|
{
|
|
$this->resetError();
|
|
if (! $this->isConnected()) {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
} else {
|
|
$sql = self::buildSQLDelete($tableName, $whereArray);
|
|
// Execute the UPDATE
|
|
if (! $this->query($sql)) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the internal pointer is at the end of the records
|
|
*
|
|
* @return boolean TRUE if at the last row or false if not
|
|
*/
|
|
public function endOfSeek()
|
|
{
|
|
$this->resetError();
|
|
if ($this->isConnected()) {
|
|
if ($this->active_row >= ($this->RowCount())) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the last MySQL error as text
|
|
*
|
|
* @return string Error text from last known error
|
|
*/
|
|
public function error()
|
|
{
|
|
$error = $this->error_desc;
|
|
if (empty($error)) {
|
|
if ($this->error_number != 0) {
|
|
$error = "Unknown Error (#" . $this->error_number . ")";
|
|
} else {
|
|
$error = false;
|
|
}
|
|
} else {
|
|
if ($this->error_number > 0) {
|
|
$error .= " (#" . $this->error_number . ")";
|
|
}
|
|
}
|
|
|
|
return $error;
|
|
}
|
|
|
|
/**
|
|
* Returns the last MySQL error as a number
|
|
*
|
|
* @return integer Error number from last known error
|
|
*/
|
|
public function errorNumber()
|
|
{
|
|
if (strlen($this->error_desc) > 0) {
|
|
if ($this->error_number != 0) {
|
|
return $this->error_number;
|
|
} else {
|
|
return -1;
|
|
}
|
|
} else {
|
|
return $this->error_number;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* [STATIC] Converts any value of any datatype into boolean (true or false)
|
|
*
|
|
* @param mixed $value Value to analyze for TRUE or false
|
|
* @return boolean Returns TRUE or false
|
|
*/
|
|
public static function getBooleanValue($value)
|
|
{
|
|
if (gettype($value) == "boolean") {
|
|
if ($value == true) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} elseif (is_numeric($value)) {
|
|
if ($value > 0) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
$cleaned = strtoupper(trim($value));
|
|
|
|
if ($cleaned == "ON") {
|
|
return true;
|
|
} elseif ($cleaned == "SELECTED" || $cleaned == "CHECKED") {
|
|
return true;
|
|
} elseif ($cleaned == "YES" || $cleaned == "Y") {
|
|
return true;
|
|
} elseif ($cleaned == "TRUE" || $cleaned == "T") {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the comments for fields in a table into an
|
|
* array or NULL if the table has not got any fields
|
|
*
|
|
* @param string $table Table name
|
|
* @return array An array that contains the column comments
|
|
*/
|
|
public function getColumnComments($table)
|
|
{
|
|
$this->resetError();
|
|
$records = mysqli_query($this->mysql_link, "SHOW FULL COLUMNS FROM " . $table);
|
|
if (! $records) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
// Get the column names
|
|
$columnNames = $this->getColumnNames($table);
|
|
if ($this->error()) {
|
|
return false;
|
|
} else {
|
|
$index = 0;
|
|
// Fetchs the array to be returned (column 8 is field comment):
|
|
while ($array_data = mysqli_fetch_array($records)) {
|
|
$columns[$index] = $array_data[8];
|
|
$columns[$columnNames[$index++]] = $array_data[8];
|
|
}
|
|
|
|
return $columns;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function returns the number of columns or returns false on error
|
|
*
|
|
* @param string $table (Optional) If a table name is not specified, the
|
|
* column count is returned from the last query
|
|
* @return integer The total count of columns
|
|
*/
|
|
public function getColumnCount($table = "")
|
|
{
|
|
$this->resetError();
|
|
if (empty($table)) {
|
|
$result = mysqli_field_count($this->mysql_link);
|
|
if (! $result) {
|
|
$this->setError();
|
|
}
|
|
} else {
|
|
$records = mysqli_query($this->mysql_link, "SELECT * FROM " . $table . " LIMIT 1");
|
|
if (! $records) {
|
|
$this->setError();
|
|
$result = false;
|
|
} else {
|
|
$result = mysqli_field_count($this->mysql_link);
|
|
$success = @mysqli_free_result($records);
|
|
if (! $success) {
|
|
$this->setError();
|
|
$result = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* This function returns the data type for a specified column. If
|
|
* the column does not exists or no records exist, it returns false
|
|
*
|
|
* @param string $column Column name or number (first column is 0)
|
|
* @param string $table (Optional) If a table name is not specified, the
|
|
* last returned records are used
|
|
* @return string MySQL data (field) type
|
|
*/
|
|
public function getColumnDataType($column, $table = "")
|
|
{
|
|
$this->resetError();
|
|
if (empty($table)) {
|
|
if ($this->RowCount() > 0) {
|
|
if (is_numeric($column)) {
|
|
$field = mysqli_fetch_field_direct($this->last_result, $column);
|
|
|
|
return $field->type;
|
|
} else {
|
|
$field = mysqli_fetch_field_direct($this->last_result, $this->getColumnID($column));
|
|
|
|
return $field->type;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (is_numeric($column)) {
|
|
$column = $this->getColumnName($column, $table);
|
|
}
|
|
$result = mysqli_query($this->mysql_link, "SELECT " . $column . " FROM " . $table . " LIMIT 1");
|
|
if (mysqli_field_count($this->mysql_link) > 0) {
|
|
$field = mysqli_fetch_field_direct($result, 0);
|
|
|
|
return $field->type;
|
|
} else {
|
|
$this->setError("The specified column or table does not exist, or no data was returned", -1);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function returns the position of a column
|
|
*
|
|
* @param string $column Column name
|
|
* @param string $table (Optional) If a table name is not specified, the
|
|
* last returned records are used.
|
|
* @return integer Column ID
|
|
*/
|
|
public function getColumnID($column, $table = "")
|
|
{
|
|
$this->resetError();
|
|
$columnNames = $this->getColumnNames($table);
|
|
if (! $columnNames) {
|
|
return false;
|
|
} else {
|
|
$index = 0;
|
|
$found = false;
|
|
foreach ($columnNames as $columnName) {
|
|
if ($columnName == $column) {
|
|
$found = true;
|
|
break;
|
|
}
|
|
$index++;
|
|
}
|
|
if ($found) {
|
|
return $index;
|
|
} else {
|
|
$this->setError("Column name not found", -1);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function returns the field length or returns false on error
|
|
*
|
|
* @param string $column Column name
|
|
* @param string $table (Optional) If a table name is not specified, the
|
|
* last returned records are used.
|
|
* @return integer Field length
|
|
*/
|
|
public function getColumnLength($column, $table = "")
|
|
{
|
|
$this->resetError();
|
|
if (empty($table)) {
|
|
if (is_numeric($column)) {
|
|
$columnID = $column;
|
|
} else {
|
|
$columnID = $this->getColumnID($column);
|
|
}
|
|
if (! $columnID) {
|
|
return false;
|
|
} else {
|
|
$field = mysqli_fetch_field_direct($this->last_result, $columnID);
|
|
if (! $field) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
return $field->length;
|
|
}
|
|
}
|
|
} else {
|
|
$records = mysqli_query($this->mysql_link, "SELECT " . $column . " FROM " . $table . " LIMIT 1");
|
|
if (! $records) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
}
|
|
$field = mysqli_fetch_field_direct($records, 0);
|
|
if (! $field) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
return $field->length;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function returns the name for a specified column number. If
|
|
* the index does not exists or no records exist, it returns false
|
|
*
|
|
* @param string $columnID Column position (0 is the first column)
|
|
* @param string $table (Optional) If a table name is not specified, the
|
|
* last returned records are used.
|
|
* @return integer Field Length
|
|
*/
|
|
public function getColumnName($columnID, $table = "")
|
|
{
|
|
$this->resetError();
|
|
$result = false;
|
|
if (empty($table)) {
|
|
if ($this->RowCount() > 0) {
|
|
$field = mysqli_fetch_field_direct($this->last_result, $columnID);
|
|
if (! $field) {
|
|
$result = false;
|
|
$this->setError();
|
|
} else {
|
|
$result = $field->name;
|
|
}
|
|
} else {
|
|
$result = false;
|
|
}
|
|
} else {
|
|
$records = mysqli_query($this->mysql_link, "SELECT * FROM " . $table . " LIMIT 1");
|
|
if (! $records) {
|
|
$this->setError();
|
|
$result = false;
|
|
} else {
|
|
if (mysqli_field_count($this->mysql_link) > 0) {
|
|
$field = mysqli_fetch_field_direct($records, $columnID);
|
|
if (! $field) {
|
|
$result = false;
|
|
$this->setError();
|
|
} else {
|
|
$result = $field->name;
|
|
}
|
|
} else {
|
|
$result = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Returns the field names in a table or query in an array
|
|
*
|
|
* @param string $table (Optional) If a table name is not specified, the
|
|
* last returned records are used
|
|
* @return array An array that contains the column names
|
|
*/
|
|
public function getColumnNames($table = "")
|
|
{
|
|
$this->resetError();
|
|
if (empty($table)) {
|
|
$columnCount = mysqli_field_count($this->mysql_link);
|
|
if (! $columnCount) {
|
|
$this->setError();
|
|
$columns = false;
|
|
} else {
|
|
for ($column = 0; $column < $columnCount; $column++) {
|
|
$field = mysqli_fetch_field_direct($this->last_result, $column);
|
|
$columns[] = $field->name;
|
|
}
|
|
}
|
|
} else {
|
|
$result = mysqli_query($this->mysql_link, "SHOW COLUMNS FROM " . $table);
|
|
if (! $result) {
|
|
$this->setError();
|
|
$columns = false;
|
|
} else {
|
|
while ($array_data = mysqli_fetch_array($result)) {
|
|
$columns[] = $array_data[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Returns the array
|
|
return $columns;
|
|
}
|
|
|
|
/**
|
|
* This function returns the last query as an HTML table
|
|
*
|
|
* @param boolean $showCount (Optional) TRUE if you want to show the row count,
|
|
* false if you do not want to show the count
|
|
* @param string $styleTable (Optional) Style information for the table
|
|
* @param string $styleHeader (Optional) Style information for the header row
|
|
* @param string $styleData (Optional) Style information for the cells
|
|
* @return string HTML containing a table with all records listed
|
|
*/
|
|
public function getHTML($showCount = true, $styleTable = null, $styleHeader = null, $styleData = null)
|
|
{
|
|
if ($styleTable === null) {
|
|
$tb = "border-collapse:collapse;empty-cells:show";
|
|
} else {
|
|
$tb = $styleTable;
|
|
}
|
|
if ($styleHeader === null) {
|
|
$th = "border-width:1px;border-style:solid;background-color:navy;color:white";
|
|
} else {
|
|
$th = $styleHeader;
|
|
}
|
|
if ($styleData === null) {
|
|
$td = "border-width:1px;border-style:solid";
|
|
} else {
|
|
$td = $styleData;
|
|
}
|
|
|
|
if ($this->last_result) {
|
|
if ($this->RowCount() > 0) {
|
|
$html = "";
|
|
if ($showCount) {
|
|
$html = "Record Count: " . $this->RowCount() . "<br />\n";
|
|
}
|
|
$html .= "<table style=\"$tb\" cellpadding=\"2\" cellspacing=\"2\">\n";
|
|
$this->moveFirst();
|
|
$header = false;
|
|
while ($member = mysqli_fetch_object($this->last_result)) {
|
|
if (!$header) {
|
|
$html .= "\t<tr>\n";
|
|
foreach ($member as $key => $value) {
|
|
$html .= "\t\t<td style=\"$th\"><strong>" . htmlspecialchars($key) . "</strong></td>\n";
|
|
}
|
|
$html .= "\t</tr>\n";
|
|
$header = true;
|
|
}
|
|
$html .= "\t<tr>\n";
|
|
foreach ($member as $key => $value) {
|
|
$html .= "\t\t<td style=\"$td\">" . htmlspecialchars($value) . "</td>\n";
|
|
}
|
|
$html .= "\t</tr>\n";
|
|
}
|
|
$this->moveFirst();
|
|
$html .= "</table>";
|
|
} else {
|
|
$html = "No records were returned.";
|
|
}
|
|
} else {
|
|
$this->active_row = -1;
|
|
$html = false;
|
|
}
|
|
|
|
return $html;
|
|
}
|
|
|
|
/**
|
|
* Returns the last query as a JSON document
|
|
*
|
|
* @return string JSON containing all records listed
|
|
*/
|
|
public function getJSON()
|
|
{
|
|
if ($this->last_result) {
|
|
if ($this->RowCount() > 0) {
|
|
for ($i = 0, $il = mysqli_field_count($this->mysql_link); $i < $il; $i++) {
|
|
$field = mysqli_fetch_field_direct($this->last_result, $i);
|
|
$types[$i] = $field->type;
|
|
}
|
|
$json = '[';
|
|
$this->moveFirst();
|
|
while ($member = mysqli_fetch_object($this->last_result)) {
|
|
$json .= json_encode($member) . ",";
|
|
}
|
|
$json .= ']';
|
|
$json = str_replace("},]", "}]", $json);
|
|
} else {
|
|
$json = 'null';
|
|
}
|
|
} else {
|
|
$this->active_row = -1;
|
|
$json = 'null';
|
|
}
|
|
|
|
return $json;
|
|
}
|
|
|
|
/**
|
|
* Returns the last autonumber ID field from a previous INSERT query
|
|
*
|
|
* @return integer ID number from previous INSERT query
|
|
*/
|
|
public function getLastInsertID()
|
|
{
|
|
return $this->last_insert_id;
|
|
}
|
|
|
|
/**
|
|
* Returns the last SQL statement executed
|
|
*
|
|
* @return string Current SQL query string
|
|
*/
|
|
public function getLastSQL()
|
|
{
|
|
return $this->last_sql;
|
|
}
|
|
|
|
/**
|
|
* This function returns table names from the database
|
|
* into an array. If the database does not contains
|
|
* any tables, the returned value is false
|
|
*
|
|
* @return array An array that contains the table names
|
|
*/
|
|
public function getTables()
|
|
{
|
|
$this->resetError();
|
|
// Query to get the tables in the current database:
|
|
$records = mysqli_query($this->mysql_link, "SHOW TABLES");
|
|
if (! $records) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
while ($array_data = mysqli_fetch_array($records)) {
|
|
$tables[] = $array_data[0];
|
|
}
|
|
|
|
// Returns the array or NULL
|
|
if (count($tables) > 0) {
|
|
return $tables;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the last query as an XML Document
|
|
*
|
|
* @return string XML containing all records listed
|
|
*/
|
|
public function getXML()
|
|
{
|
|
// Create a new XML document
|
|
$doc = new DomDocument('1.0'); // ,'UTF-8');
|
|
|
|
// Create the root node
|
|
$root = $doc->createElement('root');
|
|
$root = $doc->appendChild($root);
|
|
|
|
// If there was a result set
|
|
if (is_resource($this->last_result)) {
|
|
|
|
// Show the row count and query
|
|
$root->setAttribute('rows', ($this->RowCount() ? $this->RowCount() : 0));
|
|
$root->setAttribute('query', $this->last_sql);
|
|
$root->setAttribute('error', "");
|
|
|
|
// process one row at a time
|
|
$rowCount = 0;
|
|
while ($row = mysqli_fetch_assoc($this->last_result)) {
|
|
|
|
// Keep the row count
|
|
$rowCount = $rowCount + 1;
|
|
|
|
// Add node for each row
|
|
$element = $doc->createElement('row');
|
|
$element = $root->appendChild($element);
|
|
$element->setAttribute('index', $rowCount);
|
|
|
|
// Add a child node for each field
|
|
foreach ($row as $fieldname => $fieldvalue) {
|
|
$child = $doc->createElement($fieldname);
|
|
$child = $element->appendChild($child);
|
|
|
|
// $fieldvalue = iconv("ISO-8859-1", "UTF-8", $fieldvalue);
|
|
$fieldvalue = htmlspecialchars($fieldvalue);
|
|
$value = $doc->createTextNode($fieldvalue);
|
|
$value = $child->appendChild($value);
|
|
} // foreach
|
|
} // while
|
|
} else {
|
|
// Process any errors
|
|
$root->setAttribute('rows', 0);
|
|
$root->setAttribute('query', $this->last_sql);
|
|
if ($this->error()) {
|
|
$root->setAttribute('error', $this->error());
|
|
} else {
|
|
$root->setAttribute('error', "No query has been executed.");
|
|
}
|
|
}
|
|
|
|
// Show the XML document
|
|
return $doc->saveXML();
|
|
}
|
|
|
|
/**
|
|
* Determines if a query contains any rows
|
|
*
|
|
* @param string $sql [Optional] If specified, the query is first executed
|
|
* Otherwise, the last query is used for comparison
|
|
* @return boolean TRUE if records exist, false if not or query error
|
|
*/
|
|
public function hasRecords($sql = "")
|
|
{
|
|
if (strlen($sql) > 0) {
|
|
$this->query($sql);
|
|
if ($this->error()) {
|
|
return false;
|
|
}
|
|
}
|
|
if ($this->RowCount() > 0) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Inserts a row into a table in the connected database
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @param array $valuesArray An associative array containing the column
|
|
* names as keys and values as data. The values
|
|
* must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect)
|
|
* @return integer Returns last insert ID on success or false on failure
|
|
*/
|
|
public function insertRow($tableName, $valuesArray)
|
|
{
|
|
$this->resetError();
|
|
if (! $this->isConnected()) {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
} else {
|
|
// Execute the query
|
|
$sql = self::buildSQLInsert($tableName, $valuesArray);
|
|
if (! $this->query($sql)) {
|
|
return false;
|
|
} else {
|
|
return $this->getLastInsertID();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines if a valid connection to the database exists
|
|
*
|
|
* @return boolean TRUE idf connectect or false if not connected
|
|
*/
|
|
public function isConnected()
|
|
{
|
|
if (is_object($this->mysql_link)) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* [STATIC] Determines if a value of any data type is a date PHP can convert
|
|
*
|
|
* @param date/string $value
|
|
* @return boolean Returns TRUE if value is date or false if not date
|
|
*/
|
|
public static function isDate($value)
|
|
{
|
|
$date = date('Y', strtotime($value));
|
|
if ($date == "1969" || $date == '') {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stop executing (die/exit) and show last MySQL error message
|
|
*
|
|
*/
|
|
public function kill($message = "")
|
|
{
|
|
if (strlen($message) > 0) {
|
|
exit($message);
|
|
} else {
|
|
exit($this->error());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Seeks to the beginning of the records
|
|
*
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function moveFirst()
|
|
{
|
|
$this->resetError();
|
|
if (! $this->seek(0)) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
$this->active_row = 0;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Seeks to the end of the records
|
|
*
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function moveLast()
|
|
{
|
|
$this->resetError();
|
|
$this->active_row = $this->RowCount() - 1;
|
|
if (! $this->error()) {
|
|
if (! $this->seek($this->active_row)) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Connect to specified MySQL server
|
|
*
|
|
* @param string $database (Optional) Database name
|
|
* @param string $server (Optional) Host address
|
|
* @param string $username (Optional) User name
|
|
* @param string $password (Optional) Password
|
|
* @param string $charset (Optional) Character set
|
|
* @param boolean $pcon (Optional) Persistant connection
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function open($database = null, $server = null, $username = null, $password = null, $charset = null, $pcon = false)
|
|
{
|
|
$this->resetError();
|
|
|
|
// Use defaults?
|
|
if ($database !== null) {
|
|
$this->db_dbname = $database;
|
|
}
|
|
if ($server !== null) {
|
|
$this->db_host = $server;
|
|
}
|
|
if ($username !== null) {
|
|
$this->db_user = $username;
|
|
}
|
|
if ($password !== null) {
|
|
$this->db_pass = $password;
|
|
}
|
|
if ($charset !== null) {
|
|
$this->db_charset = $charset;
|
|
}
|
|
if (is_bool($pcon)) {
|
|
$this->db_pcon = $pcon;
|
|
}
|
|
|
|
$this->active_row = -1;
|
|
|
|
// Open persistent or normal connection
|
|
if ($pcon) {
|
|
$this->mysql_link = mysqli_pconnect('p:' . $this->db_host, $this->db_user, $this->db_pass);
|
|
} else {
|
|
$this->mysql_link = mysqli_connect($this->db_host, $this->db_user, $this->db_pass);
|
|
}
|
|
// Connect to mysql server failed?
|
|
if (! $this->isConnected()) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
// Select a database (if specified)
|
|
if (strlen($this->db_dbname) > 0) {
|
|
if (strlen($this->db_charset) == 0) {
|
|
if (! $this->selectDatabase($this->db_dbname)) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
} else {
|
|
if (! $this->selectDatabase($this->db_dbname, $this->db_charset)) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Executes the given SQL query and returns the records
|
|
*
|
|
* @param string $sql The query string should not end with a semicolon
|
|
* @return object PHP 'mysql result' resource object containing the records
|
|
* on SELECT, SHOW, DESCRIBE or EXPLAIN queries and returns;
|
|
* TRUE or false for all others i.e. UPDATE, DELETE, DROP
|
|
* AND false on all errors (setting the local Error message)
|
|
*/
|
|
public function query($sql)
|
|
{
|
|
$this->resetError();
|
|
$this->last_sql = $sql;
|
|
$this->last_result = @mysqli_query($this->mysql_link, $sql);
|
|
if (! $this->last_result) {
|
|
$this->active_row = -1;
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
if (strpos(strtolower($sql), "insert") === 0) {
|
|
$this->last_insert_id = mysqli_insert_id($this->mysql_link);
|
|
if ($this->last_insert_id === false) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
$numrows = 0;
|
|
$this->active_row = -1;
|
|
|
|
return $this->last_result;
|
|
}
|
|
} elseif (strpos(strtolower($sql), "select") === 0) {
|
|
$numrows = mysqli_field_count($this->mysql_link);
|
|
if ($numrows > 0) {
|
|
$this->active_row = 0;
|
|
} else {
|
|
$this->active_row = -1;
|
|
}
|
|
$this->last_insert_id = 0;
|
|
|
|
return $this->last_result;
|
|
} else {
|
|
return $this->last_result;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Executes the given SQL query and returns a multi-dimensional array
|
|
*
|
|
* @param string $sql The query string should not end with a semicolon
|
|
* @param integer $resultType (Optional) The type of array
|
|
* Values can be: MYSQLI_ASSOC, MYSQLI_NUM, MYSQLI_BOTH
|
|
* @return array A multi-dimensional array containing all the data
|
|
* returned from the query or false on all errors
|
|
*/
|
|
public function queryArray($sql, $resultType = MYSQLI_BOTH)
|
|
{
|
|
$this->query($sql);
|
|
if (! $this->error()) {
|
|
return $this->recordsArray($resultType);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Executes the given SQL query and returns only one (the first) row
|
|
*
|
|
* @param string $sql The query string should not end with a semicolon
|
|
* @return object PHP resource object containing the first row or
|
|
* false if no row is returned from the query
|
|
*/
|
|
public function querySingleRow($sql)
|
|
{
|
|
$this->query($sql);
|
|
if ($this->RowCount() > 0) {
|
|
return $this->row();
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Executes the given SQL query and returns the first row as an array
|
|
*
|
|
* @param string $sql The query string should not end with a semicolon
|
|
* @param integer $resultType (Optional) The type of array
|
|
* Values can be: MYSQLI_ASSOC, MYSQLI_NUM, MYSQLI_BOTH
|
|
* @return array An array containing the first row or false if no row
|
|
* is returned from the query
|
|
*/
|
|
public function querySingleRowArray($sql, $resultType = MYSQLI_BOTH)
|
|
{
|
|
$this->query($sql);
|
|
if ($this->RowCount() > 0) {
|
|
return $this->RowArray(null, $resultType);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Executes a query and returns a single value. If more than one row
|
|
* is returned, only the first value in the first column is returned.
|
|
*
|
|
* @param string $sql The query string should not end with a semicolon
|
|
* @return mixed The value returned or false if no value
|
|
*/
|
|
public function querySingleValue($sql)
|
|
{
|
|
$this->query($sql);
|
|
if ($this->RowCount() > 0 && $this->getColumnCount() > 0) {
|
|
$row = $this->RowArray(null, MYSQLI_NUM);
|
|
|
|
return $row[0];
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Executes the given SQL query, measures it, and saves the total duration
|
|
* in microseconds
|
|
*
|
|
* @param string $sql The query string should not end with a semicolon
|
|
* @return object PHP 'mysql result' resource object containing the records
|
|
* on SELECT, SHOW, DESCRIBE or EXPLAIN queries and returns
|
|
* TRUE or false for all others i.e. UPDATE, DELETE, DROP
|
|
*/
|
|
public function queryTimed($sql)
|
|
{
|
|
$this->timerStart();
|
|
$result = $this->query($sql);
|
|
$this->timerStop();
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Returns the records from the last query
|
|
*
|
|
* @return object PHP 'mysql result' resource object containing the records
|
|
* for the last query executed
|
|
*/
|
|
public function records()
|
|
{
|
|
return $this->last_result;
|
|
}
|
|
|
|
/**
|
|
* Returns all records from last query and returns contents as array
|
|
* or false on error
|
|
*
|
|
* @param integer $resultType (Optional) The type of array
|
|
* Values can be: MYSQLI_ASSOC, MYSQLI_NUM, MYSQLI_BOTH
|
|
* @return Records in array form
|
|
*/
|
|
public function recordsArray($resultType = MYSQLI_BOTH)
|
|
{
|
|
$this->resetError();
|
|
if ($this->last_result) {
|
|
if (! mysqli_data_seek($this->last_result, 0)) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
//while ($member = mysqli_fetch_object($this->last_result)) {
|
|
while ($member = mysqli_fetch_array($this->last_result, $resultType)) {
|
|
$members[] = $member;
|
|
}
|
|
mysqli_data_seek($this->last_result, 0);
|
|
$this->active_row = 0;
|
|
|
|
return $members;
|
|
}
|
|
} else {
|
|
$this->active_row = -1;
|
|
$this->setError("No query results exist", -1);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Frees memory used by the query results and returns the function result
|
|
*
|
|
* @return boolean Returns TRUE on success or false on failure
|
|
*/
|
|
public function release()
|
|
{
|
|
$this->resetError();
|
|
if (! $this->last_result) {
|
|
$success = true;
|
|
} else {
|
|
$success = @mysqli_free_result($this->last_result);
|
|
if (! $success) {
|
|
$this->setError();
|
|
}
|
|
}
|
|
|
|
return $success;
|
|
}
|
|
|
|
/**
|
|
* Clears the internal variables from any error information
|
|
*
|
|
*/
|
|
private function resetError()
|
|
{
|
|
$this->error_desc = '';
|
|
$this->error_number = 0;
|
|
}
|
|
|
|
/**
|
|
* Reads the current row and returns contents as a
|
|
* PHP object or returns false on error
|
|
*
|
|
* @param integer $optional_row_number (Optional) Use to specify a row
|
|
* @return object PHP object or false on error
|
|
*/
|
|
public function row($optional_row_number = null)
|
|
{
|
|
$this->resetError();
|
|
if (! $this->last_result) {
|
|
$this->setError("No query results exist", -1);
|
|
|
|
return false;
|
|
} elseif ($optional_row_number === null) {
|
|
if (($this->active_row) > $this->RowCount()) {
|
|
$this->setError("Cannot read past the end of the records", -1);
|
|
|
|
return false;
|
|
} else {
|
|
$this->active_row++;
|
|
}
|
|
} else {
|
|
if ($optional_row_number >= $this->RowCount()) {
|
|
$this->setError("Row number is greater than the total number of rows", -1);
|
|
|
|
return false;
|
|
} else {
|
|
$this->active_row = $optional_row_number;
|
|
$this->seek($optional_row_number);
|
|
}
|
|
}
|
|
$row = mysqli_fetch_object($this->last_result);
|
|
if (! $row) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
return $row;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reads the current row and returns contents as an
|
|
* array or returns false on error
|
|
*
|
|
* @param integer $optional_row_number (Optional) Use to specify a row
|
|
* @param integer $resultType (Optional) The type of array
|
|
* Values can be: MYSQLI_ASSOC, MYSQLI_NUM, MYSQLI_BOTH
|
|
* @return array Array that corresponds to fetched row or false if no rows
|
|
*/
|
|
public function rowArray($optional_row_number = null, $resultType = MYSQLI_BOTH)
|
|
{
|
|
$this->resetError();
|
|
if (! $this->last_result) {
|
|
$this->setError("No query results exist", -1);
|
|
|
|
return false;
|
|
} elseif ($optional_row_number === null) {
|
|
if (($this->active_row) > $this->RowCount()) {
|
|
$this->setError("Cannot read past the end of the records", -1);
|
|
|
|
return false;
|
|
} else {
|
|
$this->active_row++;
|
|
}
|
|
} else {
|
|
if ($optional_row_number >= $this->RowCount()) {
|
|
$this->setError("Row number is greater than the total number of rows", -1);
|
|
|
|
return false;
|
|
} else {
|
|
$this->active_row = $optional_row_number;
|
|
$this->seek($optional_row_number);
|
|
}
|
|
}
|
|
$row = mysqli_fetch_array($this->last_result, $resultType);
|
|
if (! $row) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
return $row;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the last query row count
|
|
*
|
|
* @return integer Row count or false on error
|
|
*/
|
|
public function rowCount()
|
|
{
|
|
$this->resetError();
|
|
if (! $this->isConnected()) {
|
|
$this->setError("No connection", -1);
|
|
|
|
return false;
|
|
} elseif (! $this->last_result) {
|
|
$this->setError("No query results exist", -1);
|
|
|
|
return false;
|
|
} else {
|
|
$result = @mysqli_affected_rows($this->mysql_link);
|
|
if (! $result) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
return $result;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the internal database pointer to the
|
|
* specified row number and returns the result
|
|
*
|
|
* @param integer $row_number Row number
|
|
* @return object Fetched row as PHP object
|
|
*/
|
|
public function seek($row_number)
|
|
{
|
|
$this->resetError();
|
|
$row_count = $this->RowCount();
|
|
if (! $row_count) {
|
|
return false;
|
|
} elseif ($row_number >= $row_count) {
|
|
$this->setError("Seek parameter is greater than the total number of rows", -1);
|
|
|
|
return false;
|
|
} else {
|
|
$this->active_row = $row_number;
|
|
$result = mysqli_data_seek($this->last_result, $row_number);
|
|
if (! $result) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
$record = mysqli_fetch_row($this->last_result);
|
|
if (! $record) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
// Go back to the record after grabbing it
|
|
mysqli_data_seek($this->last_result, $row_number);
|
|
|
|
return $record;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the current cursor row location
|
|
*
|
|
* @return integer Current row number
|
|
*/
|
|
public function seekPosition()
|
|
{
|
|
return $this->active_row;
|
|
}
|
|
|
|
/**
|
|
* Selects a different database and character set
|
|
*
|
|
* @param string $database Database name
|
|
* @param string $charset (Optional) Character set (i.e. utf8)
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function selectDatabase($database, $charset = "")
|
|
{
|
|
$return_value = true;
|
|
if (! $charset) {
|
|
$charset = $this->db_charset;
|
|
}
|
|
$this->resetError();
|
|
if (! (mysqli_select_db($this->mysql_link, $database))) {
|
|
$this->setError();
|
|
$return_value = false;
|
|
} else {
|
|
if ((strlen($charset) > 0)) {
|
|
if (! (mysqli_query($this->mysql_link, "SET CHARACTER SET '{$charset}'"))) {
|
|
$this->setError();
|
|
$return_value = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $return_value;
|
|
}
|
|
|
|
/**
|
|
* Gets rows in a table based on a WHERE filter
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @param array $whereArray (Optional) An associative array containing the
|
|
* column names as keys and values as data. The
|
|
* values must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect)
|
|
* @param array/string $columns (Optional) The column or list of columns to select
|
|
* @param array/string $sortColumns (Optional) Column or list of columns to sort by
|
|
* @param boolean $sortAscending (Optional) TRUE for ascending; false for descending
|
|
* This only works if $sortColumns are specified
|
|
* @param integer/string $limit (Optional) The limit of rows to return
|
|
* @return boolean Returns records on success or false on error
|
|
*/
|
|
public function selectRows($tableName, $whereArray = null, $columns = null, $sortColumns = null, $sortAscending = true, $limit = null)
|
|
{
|
|
$this->resetError();
|
|
if (! $this->isConnected()) {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
} else {
|
|
$sql = self::buildSQLSelect($tableName, $whereArray, $columns, $sortColumns, $sortAscending, $limit);
|
|
// Execute the UPDATE
|
|
if (! $this->query($sql)) {
|
|
return $this->last_result;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieves all rows in a specified table
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @return boolean Returns records on success or false on error
|
|
*/
|
|
public function selectTable($tableName)
|
|
{
|
|
return $this->selectRows($tableName);
|
|
}
|
|
|
|
/**
|
|
* Sets the local variables with the last error information
|
|
*
|
|
* @param string $errorMessage The error description
|
|
* @param integer $errorNumber The error number
|
|
*/
|
|
private function setError($errorMessage = "", $errorNumber = 0)
|
|
{
|
|
try {
|
|
if (strlen($errorMessage) > 0) {
|
|
$this->error_desc = $errorMessage;
|
|
} else {
|
|
if ($this->isConnected()) {
|
|
$this->error_desc = mysqli_error($this->mysql_link);
|
|
} else {
|
|
$this->error_desc = mysqli_connect_error();
|
|
}
|
|
}
|
|
if ($errorNumber != 0) {
|
|
$this->error_number = $errorNumber;
|
|
} else {
|
|
if ($this->isConnected()) {
|
|
$this->error_number = @mysqli_errno($this->mysql_link);
|
|
} else {
|
|
$this->error_number = @mysqli_connect_errno();
|
|
}
|
|
}
|
|
} catch (\Exception $e) {
|
|
$this->error_desc = $e->getMessage();
|
|
$this->error_number = -999;
|
|
}
|
|
if ($this->throw_exceptions) {
|
|
if (isset($this->error_desc) && $this->error_desc != null) {
|
|
throw new \Exception($this->error_desc . ' (' . __LINE__ . ')');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* [STATIC] Converts a boolean into a formatted TRUE or false value of choice
|
|
*
|
|
* @param mixed $value value to analyze for TRUE or false
|
|
* @param mixed $trueValue value to use if TRUE
|
|
* @param mixed $falseValue value to use if false
|
|
* @param string $datatype Use SQLVALUE constants or the strings:
|
|
* string, text, varchar, char, boolean, bool,
|
|
* Y-N, T-F, bit, date, datetime, time, integer,
|
|
* int, number, double, float
|
|
* @return string SQL formatted value of the specified data type
|
|
*/
|
|
public static function sqlBooleanValue($value, $trueValue, $falseValue, $datatype = self::SQLVALUE_TEXT)
|
|
{
|
|
if (self::getBooleanValue($value)) {
|
|
$return_value = self::sqlValue($trueValue, $datatype);
|
|
} else {
|
|
$return_value = self::sqlValue($falseValue, $datatype);
|
|
}
|
|
|
|
return $return_value;
|
|
}
|
|
|
|
/**
|
|
* Returns string suitable for SQL
|
|
* NOTE: This is no longer a static call because of a conflict with mysqli_real_escape_string.
|
|
* Also, please note that the SQLUnfix function was removed for compatibility.
|
|
*
|
|
* @param string $value
|
|
* @return string SQL formatted value
|
|
*/
|
|
public function sqlFix($value)
|
|
{
|
|
return @mysqli_real_escape_string($this->mysql_link, $value);
|
|
}
|
|
|
|
/**
|
|
* [STATIC] Formats any value into a string suitable for SQL statements
|
|
* (NOTE: Also supports data types returned from the gettype function)
|
|
*
|
|
* @param mixed $value Any value of any type to be formatted to SQL
|
|
* @param string $datatype Use SQLVALUE constants or the strings:
|
|
* string, text, varchar, char, boolean, bool,
|
|
* Y-N, T-F, bit, date, datetime, time, integer,
|
|
* int, number, double, float
|
|
* @return string
|
|
*/
|
|
public static function sqlValue($value, $datatype = self::SQLVALUE_TEXT)
|
|
{
|
|
$return_value = "";
|
|
|
|
switch (strtolower(trim($datatype))) {
|
|
case "text":
|
|
case "string":
|
|
case "varchar":
|
|
case "char":
|
|
if (strlen($value) == 0) {
|
|
$return_value = "NULL";
|
|
} else {
|
|
if (get_magic_quotes_gpc()) {
|
|
$value = stripslashes($value);
|
|
}
|
|
$return_value = "'" . str_replace("'", "''", $value) . "'";
|
|
}
|
|
break;
|
|
case "number":
|
|
case "integer":
|
|
case "int":
|
|
case "double":
|
|
case "float":
|
|
if (is_numeric($value)) {
|
|
$return_value = $value;
|
|
} else {
|
|
$return_value = "NULL";
|
|
}
|
|
break;
|
|
case "boolean": //boolean to use this with a bit field
|
|
case "bool":
|
|
case "bit":
|
|
if (self::getBooleanValue($value)) {
|
|
$return_value = "1";
|
|
} else {
|
|
$return_value = "0";
|
|
}
|
|
break;
|
|
case "y-n": //boolean to use this with a char(1) field
|
|
if (self::getBooleanValue($value)) {
|
|
$return_value = "'Y'";
|
|
} else {
|
|
$return_value = "'N'";
|
|
}
|
|
break;
|
|
case "t-f": //boolean to use this with a char(1) field
|
|
if (self::getBooleanValue($value)) {
|
|
$return_value = "'T'";
|
|
} else {
|
|
$return_value = "'F'";
|
|
}
|
|
break;
|
|
case "date":
|
|
if (empty($value)) {
|
|
$return_value = "NULL";
|
|
} elseif (self::isDate($value)) {
|
|
$return_value = "'" . date('Y-m-d', strtotime($value)) . "'";
|
|
} else {
|
|
$return_value = "NULL";
|
|
}
|
|
break;
|
|
case "datetime":
|
|
if (empty($value)) {
|
|
$return_value = "NULL";
|
|
} elseif (self::isDate($value)) {
|
|
$return_value = "'" . date('Y-m-d H:i:s', strtotime($value)) . "'";
|
|
} else {
|
|
$return_value = "NULL";
|
|
}
|
|
break;
|
|
case "time":
|
|
if (empty($value)) {
|
|
$return_value = "NULL";
|
|
} elseif (self::isDate($value)) {
|
|
$return_value = "'" . date('H:i:s', strtotime($value)) . "'";
|
|
} else {
|
|
$return_value = "NULL";
|
|
}
|
|
break;
|
|
default:
|
|
exit("ERROR: Invalid data type specified in sqlValue method");
|
|
}
|
|
|
|
return $return_value;
|
|
}
|
|
|
|
/**
|
|
* Returns last measured duration (time between TimerStart and TimerStop)
|
|
*
|
|
* @param integer $decimals (Optional) The number of decimal places to show
|
|
* @return Float Microseconds elapsed
|
|
*/
|
|
public function timerDuration($decimals = 4)
|
|
{
|
|
return number_format($this->time_diff, $decimals);
|
|
}
|
|
|
|
/**
|
|
* Starts time measurement (in microseconds)
|
|
*
|
|
*/
|
|
public function timerStart()
|
|
{
|
|
$parts = explode(" ", microtime());
|
|
$this->time_diff = 0;
|
|
$this->time_start = $parts[1].substr($parts[0], 1);
|
|
}
|
|
|
|
/**
|
|
* Stops time measurement (in microseconds)
|
|
*
|
|
*/
|
|
public function timerStop()
|
|
{
|
|
$parts = explode(" ", microtime());
|
|
$time_stop = $parts[1].substr($parts[0], 1);
|
|
$this->time_diff = ($time_stop - $this->time_start);
|
|
$this->time_start = 0;
|
|
}
|
|
|
|
/**
|
|
* Starts a transaction
|
|
*
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function transactionBegin()
|
|
{
|
|
$this->resetError();
|
|
if (! $this->isConnected()) {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
} else {
|
|
if (! $this->in_transaction) {
|
|
if (! mysqli_query($this->mysql_link, "START TRANSACTION")) {
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
$this->in_transaction = true;
|
|
|
|
return true;
|
|
}
|
|
} else {
|
|
$this->setError("Already in transaction", -1);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ends a transaction and commits the queries
|
|
*
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function transactionEnd()
|
|
{
|
|
$this->resetError();
|
|
if (! $this->isConnected()) {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
} else {
|
|
if ($this->in_transaction) {
|
|
if (! mysqli_query($this->mysql_link, "COMMIT")) {
|
|
// $this->transactionRollback();
|
|
$this->setError();
|
|
|
|
return false;
|
|
} else {
|
|
$this->in_transaction = false;
|
|
|
|
return true;
|
|
}
|
|
} else {
|
|
$this->setError("Not in a transaction", -1);
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rolls the transaction back
|
|
*
|
|
* @return boolean Returns TRUE on success or false on failure
|
|
*/
|
|
public function transactionRollback()
|
|
{
|
|
$this->resetError();
|
|
if (! $this->isConnected()) {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
} else {
|
|
if (! mysqli_query($this->mysql_link, "ROLLBACK")) {
|
|
$this->setError("Could not rollback transaction");
|
|
|
|
return false;
|
|
} else {
|
|
$this->in_transaction = false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Truncates a table removing all data
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function truncateTable($tableName)
|
|
{
|
|
$this->resetError();
|
|
if (! $this->isConnected()) {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
} else {
|
|
$sql = "TRUNCATE TABLE `" . $tableName . "`";
|
|
if (! $this->query($sql)) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates rows in a table based on a WHERE filter
|
|
* (can be just one or many rows based on the filter)
|
|
*
|
|
* @param string $tableName The name of the table
|
|
* @param array $valuesArray An associative array containing the column
|
|
* names as keys and values as data. The values
|
|
* must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect)
|
|
* @param array $whereArray (Optional) An associative array containing the
|
|
* column names as keys and values as data. The
|
|
* values must be SQL ready (i.e. quotes around
|
|
* strings, formatted dates, ect). If not specified
|
|
* then all values in the table are updated.
|
|
* @return boolean Returns TRUE on success or false on error
|
|
*/
|
|
public function updateRows($tableName, $valuesArray, $whereArray = null)
|
|
{
|
|
$this->resetError();
|
|
if (! $this->isConnected()) {
|
|
$this->setError("No connection");
|
|
|
|
return false;
|
|
} else {
|
|
$sql = self::buildSQLUpdate($tableName, $valuesArray, $whereArray);
|
|
// Execute the UPDATE
|
|
if (! $this->query($sql)) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|