680 lines
20 KiB
PHP
680 lines
20 KiB
PHP
<?php
|
|
/**
|
|
* This file contains the class that defines user defined functions for PDO library.
|
|
*
|
|
* This file is for PHP 5.3.x or later. For PHP 5.2.x or lesser, functions-5-2.php is
|
|
* loaded. PHP version is checked in the db.php and that will load the apropriate
|
|
* one.
|
|
*
|
|
* @package SQLite Integration
|
|
* @author Kojima Toshiyasu
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* This class defines user defined functions(UDFs) for PDO library.
|
|
*
|
|
* These functions replace those used in the SQL statement with the PHP functions.
|
|
*
|
|
* Usage:
|
|
*
|
|
* <code>
|
|
* new PDOSQLiteUDFS(ref_to_pdo_obj);
|
|
* </code>
|
|
*
|
|
* This automatically enables ref_to_pdo_obj to replace the function in the SQL statement
|
|
* to the ones defined here.
|
|
*/
|
|
class PDOSQLiteUDFS {
|
|
/**
|
|
* The class constructor
|
|
*
|
|
* Initializes the use defined functions to PDO object with PDO::sqliteCreateFunction().
|
|
*
|
|
* @param reference to PDO object $pdo
|
|
*/
|
|
public function __construct(&$pdo){
|
|
foreach ($this->functions as $f=>$t) {
|
|
$pdo->sqliteCreateFunction($f, array($this, $t));
|
|
}
|
|
}
|
|
/**
|
|
* array to define MySQL function => function defined with PHP.
|
|
*
|
|
* Replaced functions must be public.
|
|
*
|
|
* @var associative array
|
|
*/
|
|
private $functions = array(
|
|
'month' => 'month',
|
|
'year' => 'year',
|
|
'day' => 'day',
|
|
'unix_timestamp' => 'unix_timestamp',
|
|
'now' => 'now',
|
|
'char_length' => 'char_length',
|
|
'md5' => 'md5',
|
|
'curdate' => 'curdate',
|
|
'rand' => 'rand',
|
|
'substring' => 'substring',
|
|
'dayofmonth' => 'day',
|
|
'second' => 'second',
|
|
'minute' => 'minute',
|
|
'hour' => 'hour',
|
|
'date_format' => 'dateformat',
|
|
'from_unixtime' => 'from_unixtime',
|
|
'date_add' => 'date_add',
|
|
'date_sub' => 'date_sub',
|
|
'adddate' => 'date_add',
|
|
'subdate' => 'date_sub',
|
|
'localtime' => 'now',
|
|
'localtimestamp' => 'now',
|
|
'isnull' => 'isnull',
|
|
'if' => '_if',
|
|
'regexpp' => 'regexp',
|
|
'concat' => 'concat',
|
|
'field' => 'field',
|
|
'log' => 'log',
|
|
'least' => 'least',
|
|
'greatest' => 'greatest',
|
|
'get_lock' => 'get_lock',
|
|
'release_lock' => 'release_lock',
|
|
'ucase' => 'ucase',
|
|
'lcase' => 'lcase',
|
|
'inet_ntoa' => 'inet_ntoa',
|
|
'inet_aton' => 'inet_aton',
|
|
'datediff' => 'datediff',
|
|
'locate' => 'locate',
|
|
'utc_date' => 'utc_date',
|
|
'utc_time' => 'utc_time',
|
|
'utc_timestamp' => 'utc_timestamp',
|
|
'version' => 'version'
|
|
);
|
|
/**
|
|
* Method to extract the month value from the date.
|
|
*
|
|
* @param string representing the date formated as 0000-00-00.
|
|
* @return string representing the number of the month between 1 and 12.
|
|
*/
|
|
public function month($field){
|
|
$t = strtotime($field);
|
|
return date('n', $t);
|
|
}
|
|
/**
|
|
* Method to extract the year value from the date.
|
|
*
|
|
* @param string representing the date formated as 0000-00-00.
|
|
* @return string representing the number of the year.
|
|
*/
|
|
public function year($field){
|
|
$t = strtotime($field);
|
|
return date('Y', $t);
|
|
}
|
|
/**
|
|
* Method to extract the day value from the date.
|
|
*
|
|
* @param string representing the date formated as 0000-00-00.
|
|
* @return string representing the number of the day of the month from 1 and 31.
|
|
*/
|
|
public function day($field){
|
|
$t = strtotime($field);
|
|
return date('j', $t);
|
|
}
|
|
/**
|
|
* Method to return the unix timestamp.
|
|
*
|
|
* Used without an argument, it returns PHP time() function (total seconds passed
|
|
* from '1970-01-01 00:00:00' GMT). Used with the argument, it changes the value
|
|
* to the timestamp.
|
|
*
|
|
* @param string representing the date formated as '0000-00-00 00:00:00'.
|
|
* @return number of unsigned integer
|
|
*/
|
|
public function unix_timestamp($field = null){
|
|
return is_null($field) ? time() : strtotime($field);
|
|
}
|
|
/**
|
|
* Method to emulate MySQL SECOND() function.
|
|
*
|
|
* @param string representing the time formated as '00:00:00'.
|
|
* @return number of unsigned integer
|
|
*/
|
|
public function second($field){
|
|
$t = strtotime($field);
|
|
return intval( date("s", $t) );
|
|
}
|
|
/**
|
|
* Method to emulate MySQL MINUTE() function.
|
|
*
|
|
* @param string representing the time formated as '00:00:00'.
|
|
* @return number of unsigned integer
|
|
*/
|
|
public function minute($field){
|
|
$t = strtotime($field);
|
|
return intval(date("i", $t));
|
|
}
|
|
/**
|
|
* Method to emulate MySQL HOUR() function.
|
|
*
|
|
* @param string representing the time formated as '00:00:00'.
|
|
* @return number
|
|
*/
|
|
public function hour($time){
|
|
list($hours, $minutes, $seconds) = explode(":", $time);
|
|
return intval($hours);
|
|
}
|
|
/**
|
|
* Method to emulate MySQL FROM_UNIXTIME() function.
|
|
*
|
|
* @param integer of unix timestamp
|
|
* @param string to indicate the way of formatting(optional)
|
|
* @return string formatted as '0000-00-00 00:00:00'.
|
|
*/
|
|
public function from_unixtime($field, $format=null){
|
|
// $field is a timestamp
|
|
//convert to ISO time
|
|
$date = date("Y-m-d H:i:s", $field);
|
|
//now submit to dateformat
|
|
return is_null($format) ? $date : $self->dateformat($date, $format);
|
|
}
|
|
/**
|
|
* Method to emulate MySQL NOW() function.
|
|
*
|
|
* @return string representing current time formatted as '0000-00-00 00:00:00'.
|
|
*/
|
|
public function now(){
|
|
return date("Y-m-d H:i:s");
|
|
}
|
|
/**
|
|
* Method to emulate MySQL CURDATE() function.
|
|
*
|
|
* @return string representing current time formatted as '0000-00-00'.
|
|
*/
|
|
public function curdate() {
|
|
return date("Y-m-d");
|
|
}
|
|
/**
|
|
* Method to emulate MySQL CHAR_LENGTH() function.
|
|
*
|
|
* @param string
|
|
* @return unsigned integer for the length of the argument.
|
|
*/
|
|
public function char_length($field){
|
|
return strlen($field);
|
|
}
|
|
/**
|
|
* Method to emulate MySQL MD5() function.
|
|
*
|
|
* @param string
|
|
* @return string of the md5 hash value of the argument.
|
|
*/
|
|
public function md5($field){
|
|
return md5($field);
|
|
}
|
|
/**
|
|
* Method to emulate MySQL RAND() function.
|
|
*
|
|
* SQLite does have a random generator, but it is called RANDOM() and returns random
|
|
* number between -9223372036854775808 and +9223372036854775807. So we substitute it
|
|
* with PHP random generator.
|
|
*
|
|
* This function uses mt_rand() which is four times faster than rand() and returns
|
|
* the random number between 0 and 1.
|
|
*
|
|
* @return unsigned integer
|
|
*/
|
|
public function rand(){
|
|
return mt_rand(0, 1);
|
|
}
|
|
/**
|
|
* Method to emulate MySQL SUBSTRING() function.
|
|
*
|
|
* This function rewrites the function name to SQLite compatible substr(),
|
|
* which can manipulate UTF-8 characters.
|
|
*
|
|
* @param string $text
|
|
* @param integer $pos representing the start point.
|
|
* @param integer $len representing the length of the substring(optional).
|
|
* @return string
|
|
*/
|
|
public function substring($text, $pos, $len=null){
|
|
return "substr($text, $pos, $len)";
|
|
}
|
|
/**
|
|
* Method to emulate MySQL DATEFORMAT() function.
|
|
*
|
|
* @param string date formatted as '0000-00-00' or datetime as '0000-00-00 00:00:00'.
|
|
* @param string $format
|
|
* @return string formatted according to $format
|
|
*/
|
|
public function dateformat($date, $format){
|
|
$mysql_php_dateformats = array ( '%a' => 'D', '%b' => 'M', '%c' => 'n', '%D' => 'jS', '%d' => 'd', '%e' => 'j', '%H' => 'H', '%h' => 'h', '%I' => 'h', '%i' => 'i', '%j' => 'z', '%k' => 'G', '%l' => 'g', '%M' => 'F', '%m' => 'm', '%p' => 'A', '%r' => 'h:i:s A', '%S' => 's', '%s' => 's', '%T' => 'H:i:s', '%U' => 'W', '%u' => 'W', '%V' => 'W', '%v' => 'W', '%W' => 'l', '%w' => 'w', '%X' => 'Y', '%x' => 'o', '%Y' => 'Y', '%y' => 'y', );
|
|
$t = strtotime($date);
|
|
$format = strtr($format, $mysql_php_dateformats);
|
|
$output = date($format, $t);
|
|
return $output;
|
|
}
|
|
/**
|
|
* Method to emulate MySQL DATE_ADD() function.
|
|
*
|
|
* This function adds the time value of $interval expression to $date.
|
|
* $interval is a single quoted strings rewritten by SQLiteQueryDriver::rewrite_query().
|
|
* It is calculated in the private function deriveInterval().
|
|
*
|
|
* @param string $date representing the start date.
|
|
* @param string $interval representing the expression of the time to add.
|
|
* @return string date formated as '0000-00-00 00:00:00'.
|
|
*/
|
|
public function date_add($date, $interval) {
|
|
$interval = $this->deriveInterval($interval);
|
|
switch (strtolower($date)) {
|
|
case "curdate()":
|
|
$objDate = new Datetime($this->curdate());
|
|
$objDate->add(new DateInterval($interval));
|
|
$returnval = $objDate->format("Y-m-d");
|
|
break;
|
|
case "now()":
|
|
$objDate = new Datetime($this->now());
|
|
$objDate->add(new DateInterval($interval));
|
|
$returnval = $objDate->format("Y-m-d H:i:s");
|
|
break;
|
|
default:
|
|
$objDate = new Datetime($date);
|
|
$objDate->add(new DateInterval($interval));
|
|
$returnval = $objDate->format("Y-m-d H:i:s");
|
|
}
|
|
return $returnval;
|
|
}
|
|
/**
|
|
* Method to emulate MySQL DATE_SUB() function.
|
|
*
|
|
* This function substracts the time value of $interval expression from $date.
|
|
* $interval is a single quoted strings rewritten by SQLiteQueryDriver::rewrite_query().
|
|
* It is calculated in the private function deriveInterval().
|
|
*
|
|
* @param string $date representing the start date.
|
|
* @param string $interval representing the expression of the time to substract.
|
|
* @return string date formated as '0000-00-00 00:00:00'.
|
|
*/
|
|
public function date_sub($date, $interval) {
|
|
$interval = $this->deriveInterval($interval);
|
|
switch (strtolower($date)) {
|
|
case "curdate()":
|
|
$objDate = new Datetime($this->curdate());
|
|
$objDate->sub(new DateInterval($interval));
|
|
$returnval = $objDate->format("Y-m-d");
|
|
break;
|
|
case "now()":
|
|
$objDate = new Datetime($this->now());
|
|
$objDate->sub(new DateInterval($interval));
|
|
$returnval = $objDate->format("Y-m-d H:i:s");
|
|
break;
|
|
default:
|
|
$objDate = new Datetime($date);
|
|
$objDate->sub(new DateInterval($interval));
|
|
$returnval = $objDate->format("Y-m-d H:i:s");
|
|
}
|
|
return $returnval;
|
|
}
|
|
/**
|
|
* Method to calculate the interval time between two dates value.
|
|
*
|
|
* @access private
|
|
* @param string $interval white space separated expression.
|
|
* @return string representing the time to add or substract.
|
|
*/
|
|
private function deriveInterval($interval) {
|
|
$interval = trim(substr(trim($interval), 8));
|
|
$parts = explode(' ', $interval);
|
|
foreach ($parts as $part) {
|
|
if (!empty($part)) {
|
|
$_parts[] = $part;
|
|
}
|
|
}
|
|
$type = strtolower(end($_parts));
|
|
switch ($type) {
|
|
case "second": $unit = 'S'; return 'PT' . $_parts[0] . $unit; break;
|
|
case "minute": $unit = 'M'; return 'PT' . $_parts[0] . $unit; break;
|
|
case "hour": $unit = 'H'; return 'PT' . $_parts[0] . $unit; break;
|
|
case "day": $unit = 'D'; return 'P' . $_parts[0] . $unit; break;
|
|
case "week": $unit = 'W'; return 'P' . $_parts[0] . $unit; break;
|
|
case "month": $unit = 'M'; return 'P' . $_parts[0] . $unit; break;
|
|
case "year": $unit = 'Y'; return 'P' . $_parts[0] . $unit; break;
|
|
case "minute_second":
|
|
list($minutes, $seconds) = explode(':', $_parts[0]);
|
|
return 'PT' . $minutes . 'M' . $seconds . 'S';
|
|
case "hour_second":
|
|
list($hours, $minutes, $seconds) = explode (':', $_parts[0]);
|
|
return 'PT' . $hours . 'H' . $minutes . 'M' . $seconds . 'S';
|
|
case "hour_minute":
|
|
list($hours, $minutes) = explode (':', $_parts[0]);
|
|
return 'PT' . $hours . 'H' . $minutes . 'M';
|
|
case "day_second":
|
|
$days = intval($_parts[0]);
|
|
list($hours, $minutes, $seconds) = explode (':', $_parts[1]);
|
|
return 'P' . $days . 'D' . 'T' . $hours . 'H' . $minutes . 'M' . $seconds . 'S';
|
|
case "day_minute":
|
|
$days = intval($_parts[0]);
|
|
list($hours, $minutes) = explode(':', $parts[1]);
|
|
return 'P' . $days . 'D' . 'T' . $hours . 'H' . $minutes . 'M';
|
|
case "day_hour":
|
|
$days = intval($_parts[0]);
|
|
$hours = intval($_parts[1]);
|
|
return 'P' . $days . 'D' . 'T' . $hours . 'H';
|
|
case "year_month":
|
|
list($years, $months) = explode ('-', $_parts[0]);
|
|
return 'P' . $years . 'Y' . $months . 'M';
|
|
}
|
|
}
|
|
/**
|
|
* Method to emulate MySQL DATE() function.
|
|
*
|
|
* @param string $date formatted as unix time.
|
|
* @return string formatted as '0000-00-00'.
|
|
*/
|
|
public function date($date){
|
|
return date("Y-m-d", strtotime($date));
|
|
}
|
|
/**
|
|
* Method to emulate MySQL ISNULL() function.
|
|
*
|
|
* This function returns true if the argument is null, and true if not.
|
|
*
|
|
* @param various types $field
|
|
* @return boolean
|
|
*/
|
|
public function isnull($field){
|
|
return is_null($field);
|
|
}
|
|
/**
|
|
* Method to emulate MySQL IF() function.
|
|
*
|
|
* As 'IF' is a reserved word for PHP, function name must be changed.
|
|
*
|
|
* @param unknonw $expression the statement to be evaluated as true or false.
|
|
* @param unknown $true statement or value returned if $expression is true.
|
|
* @param unknown $false statement or value returned if $expression is false.
|
|
* @return unknown
|
|
*/
|
|
public function _if($expression, $true, $false){
|
|
return ($expression == true) ? $true : $false;
|
|
}
|
|
/**
|
|
* Method to emulate MySQL REGEXP() function.
|
|
*
|
|
* @param string $field haystack
|
|
* @param string $pattern: regular expression to match.
|
|
* @return integer 1 if matched, 0 if not matched.
|
|
*/
|
|
public function regexp($field, $pattern){
|
|
$pattern = str_replace('/', '\/', $pattern);
|
|
$pattern = "/" . $pattern ."/i";
|
|
return preg_match ($pattern, $field);
|
|
}
|
|
/**
|
|
* Method to emulate MySQL CONCAT() function.
|
|
*
|
|
* SQLite does have CONCAT() function, but it has a different syntax from MySQL.
|
|
* So this function must be manipulated here.
|
|
*
|
|
* @param string
|
|
* @return NULL if the argument is null | string conatenated if the argument is given.
|
|
*/
|
|
public function concat() {
|
|
$returnValue = "";
|
|
$argsNum = func_num_args();
|
|
$argsList = func_get_args();
|
|
for ($i = 0; $i < $argsNum; $i++) {
|
|
if (is_null($argsList[$i])) {
|
|
return null;
|
|
}
|
|
$returnValue .= $argsList[$i];
|
|
}
|
|
return $returnValue;
|
|
}
|
|
/**
|
|
* Method to emulate MySQL FIELD() function.
|
|
*
|
|
* This function gets the list argument and compares the first item to all the others.
|
|
* If the same value is found, it returns the position of that value. If not, it
|
|
* returns 0.
|
|
*
|
|
* @param variable number of string, integer or double
|
|
* @return unsigned integer
|
|
*/
|
|
public function field() {
|
|
$numArgs = func_num_args();
|
|
if ($numArgs < 2 or is_null(func_get_arg(0))) {
|
|
return 0;
|
|
} else {
|
|
$arg_list = func_get_args();
|
|
}
|
|
$searchString = array_shift($arg_list);
|
|
for ($i = 0; $i < $numArgs-1; $i++) {
|
|
if ($searchString === strtolower($arg_list[$i])) {
|
|
return $i + 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
/**
|
|
* Method to emulate MySQL LOG() function.
|
|
*
|
|
* Used with one argument, it returns the natural logarithm of X.
|
|
* <code>
|
|
* LOG(X)
|
|
* </code>
|
|
* Used with two arguments, it returns the natural logarithm of X base B.
|
|
* <code>
|
|
* LOG(B, X)
|
|
* </code>
|
|
* In this case, it returns the value of log(X) / log(B).
|
|
*
|
|
* Used without an argument, it returns false. This returned value will be
|
|
* rewritten to 0, because SQLite doesn't understand true/false value.
|
|
*
|
|
* @param integer representing the base of the logarithm, which is optional.
|
|
* @param double value to turn into logarithm.
|
|
* @return double | NULL
|
|
*/
|
|
public function log() {
|
|
$numArgs = func_num_args();
|
|
if ($numArgs == 1) {
|
|
$arg1 = func_get_arg(0);
|
|
return log($arg1);
|
|
} else if ($numArgs == 2) {
|
|
$arg1 = func_get_arg(0);
|
|
$arg2 = func_get_arg(1);
|
|
return log($arg1)/log($arg2);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
/**
|
|
* Method to emulate MySQL LEAST() function.
|
|
*
|
|
* This function rewrites the function name to SQLite compatible function name.
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function least() {
|
|
$arg_list = func_get_args();
|
|
return "min($arg_list)";
|
|
}
|
|
/**
|
|
* Method to emulate MySQL GREATEST() function.
|
|
*
|
|
* This function rewrites the function name to SQLite compatible function name.
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function greatest() {
|
|
$arg_list = func_get_args();
|
|
return "max($arg_list)";
|
|
}
|
|
/**
|
|
* Method to dummy out MySQL GET_LOCK() function.
|
|
*
|
|
* This function is meaningless in SQLite, so we do nothing.
|
|
*
|
|
* @param string $name
|
|
* @param integer $timeout
|
|
* @return string
|
|
*/
|
|
public function get_lock($name, $timeout) {
|
|
return '1=1';
|
|
}
|
|
/**
|
|
* Method to dummy out MySQL RELEASE_LOCK() function.
|
|
*
|
|
* This function is meaningless in SQLite, so we do nothing.
|
|
*
|
|
* @param string $name
|
|
* @return string
|
|
*/
|
|
public function release_lock($name) {
|
|
return '1=1';
|
|
}
|
|
/**
|
|
* Method to emulate MySQL UCASE() function.
|
|
*
|
|
* This is MySQL alias for upper() function. This function rewrites it
|
|
* to SQLite compatible name upper().
|
|
*
|
|
* @param string
|
|
* @return string SQLite compatible function name.
|
|
*/
|
|
public function ucase($string) {
|
|
return "upper($string)";
|
|
}
|
|
/**
|
|
* Method to emulate MySQL LCASE() function.
|
|
*
|
|
*
|
|
* This is MySQL alias for lower() function. This function rewrites it
|
|
* to SQLite compatible name lower().
|
|
*
|
|
* @param string
|
|
* @return string SQLite compatible function name.
|
|
*/
|
|
public function lcase($string) {
|
|
return "lower($string)";
|
|
}
|
|
/**
|
|
* Method to emulate MySQL INET_NTOA() function.
|
|
*
|
|
* This function gets 4 or 8 bytes integer and turn it into the network address.
|
|
*
|
|
* @param unsigned long integer
|
|
* @return string
|
|
*/
|
|
public function inet_ntoa($num) {
|
|
return long2ip($num);
|
|
}
|
|
/**
|
|
* Method to emulate MySQL INET_ATON() function.
|
|
*
|
|
* This function gets the network address and turns it into integer.
|
|
*
|
|
* @param string
|
|
* @return unsigned long integer
|
|
*/
|
|
public function inet_aton($addr) {
|
|
$int_data = ip2long($addr);
|
|
$unsigned_int_data = sprintf('%u', $address);
|
|
return $unsigned_int_data;
|
|
}
|
|
/**
|
|
* Method to emulate MySQL DATEDIFF() function.
|
|
*
|
|
* This function compares two dates value and returns the difference.
|
|
*
|
|
* PHP 5.3.2 has a serious bug in DateTime::diff(). So if users' PHP is that version,
|
|
* we don't use that function. See https://bugs.php.net/bug.php?id=51184.
|
|
*
|
|
* @param string start
|
|
* @param string end
|
|
* @return string
|
|
*/
|
|
public function datediff($start, $end) {
|
|
if (version_compare(PHP_VERSION, '5.3.2', '==')) {
|
|
$start_date = strtotime($start);
|
|
$end_date = strtotime($end);
|
|
$interval = floor(($start_date - $end_date)/(3600*24));
|
|
return $interval;
|
|
} else {
|
|
$start_date = new DateTime($start);
|
|
$end_date = new DateTime($end);
|
|
$interval = $end_date->diff($start_date, false);
|
|
return $interval->format('%r%a');
|
|
}
|
|
}
|
|
/**
|
|
* Method to emulate MySQL LOCATE() function.
|
|
*
|
|
* This function returns the position if $substr is found in $str. If not,
|
|
* it returns 0. If mbstring extension is loaded, mb_strpos() function is
|
|
* used.
|
|
*
|
|
* @param string needle
|
|
* @param string haystack
|
|
* @param integer position
|
|
* @return integer
|
|
*/
|
|
public function locate($substr, $str, $pos = 0) {
|
|
if (!extension_loaded('mbstring')) {
|
|
if (($val = stros($str, $substr, $pos)) !== false) {
|
|
return $val + 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
if (($val = mb_strpos($str, $substr, $pos)) !== false) {
|
|
return $val + 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Method to return GMT date in the string format.
|
|
*
|
|
* @param none
|
|
* @return string formatted GMT date 'dddd-mm-dd'
|
|
*/
|
|
public function utc_date() {
|
|
return gmdate('Y-m-d', time());
|
|
}
|
|
/**
|
|
* Method to return GMT time in the string format.
|
|
*
|
|
* @param none
|
|
* @return string formatted GMT time '00:00:00'
|
|
*/
|
|
public function utc_time() {
|
|
return gmdate('H:i:s', time());
|
|
}
|
|
/**
|
|
* Method to return GMT time stamp in the string format.
|
|
*
|
|
* @param none
|
|
* @return string formatted GMT timestamp 'yyyy-mm-dd 00:00:00'
|
|
*/
|
|
public function utc_timestamp() {
|
|
return gmdate('Y-m-d H:i:s', time());
|
|
}
|
|
/**
|
|
* Method to return MySQL version.
|
|
*
|
|
* This function only returns the current newest version number of MySQL,
|
|
* because it is meaningless for SQLite database.
|
|
*
|
|
* @param none
|
|
* @return string representing the version number: major_version.minor_version
|
|
*/
|
|
public function version() {
|
|
//global $required_mysql_version;
|
|
//return $required_mysql_version;
|
|
return '5.5';
|
|
}
|
|
}
|
|
?>
|