--- /dev/null
+<?php
+ /***************************************
+ * SQLite-MySQL wrapper for Nucleus *
+ * ver 0.8.5.2*
+ * Written by Katsumi *
+ ***************************************/
+//
+// The licence of this script is GPL
+//
+// ACKOWLEDGMENT
+//
+// I thank all the people of Nucleus JP forum
+// who discussed this project. Especially, I
+// thank kosugiatkips, mekyo, and nakahara21
+// for ideas of some part of code.
+// I also thank Jon Jensen for his generous
+// acceptance for using his PHP code in this
+// script.
+//
+// The features that are supported by this script but not
+// generally by SQLite are as follows:
+//
+// CREATE TABLE IF NOT EXISTS, auto_increment,
+// DROP TABLE IF EXISTS, ALTER TABLE,
+// INSERT INTO ... SET xx=xx, xx=xx,
+// REPLACE INTO ... SET xx=xx, xx=xx,
+// SHOW KEYS FROM, SHOW INDEX FROM,
+// SHOW FIELDS FROM, SHOW COLUMNS FROM,
+// CREATE TABLE ... KEYS xxx (xxx,xxx)
+// SHOW TABLES LIKE, TRUNCATE TABLE
+// SHOW TABLES
+//
+// Release note:
+// Version 0.8.0
+// -This is the first established version and
+// exactly the same as ver 0.7.8b.
+//
+// Version 0.8.1
+// -Execute "PRAGMA short_column_names=1" first.
+// -Avoid executing outside php file in some very specfic environment.
+// -Avoid executing multiple queries using ";" as delimer.
+// -Add check routine for the installed SQLite
+//
+// Version 0.8.5
+// -Use SQLite_Functions class
+// -'PRAGMA synchronous = off;' when installing
+
+// Check SQLite installed
+
+if (!function_exists('sqlite_open')) exit('Sorry, SQLite is not installed in the server.');
+
+// Initializiation stuff
+require_once dirname(__FILE__) . '/sqliteconfig.php';
+$SQLITE_DBHANDLE=sqlite_open($SQLITECONF['DBFILENAME']);
+require_once dirname(__FILE__) . '/sqlitequeryfunctions.php';
+$SQLITECONF['VERSION']='0.8.5';
+
+//Following thing may work if MySQL is NOT installed in server.
+if (!function_exists('mysql_query')) {
+ define ("MYSQL_ASSOC", SQLITE_ASSOC);
+ define ("MYSQL_BOTH", SQLITE_BOTH);
+ define ("MYSQL_NUM", SQLITE_NUM);
+ function mysql_connect(){
+ global $SQLITECONF;
+ $SQLITECONF['OVERRIDEMODE']=true;
+ $args=func_get_args();
+ return call_user_func_array('nucleus_mysql_connect',$args);
+ }
+ foreach (array('mysql_affected_rows','mysql_change_user','mysql_client_encoding','mysql_close',
+ 'mysql_create_db','mysql_data_seek','mysql_db_name','mysql_db_query','mysql_drop_db','mysql_errno',
+ 'mysql_error','mysql_escape_string','mysql_fetch_array','mysql_fetch_assoc','mysql_fetch_field','mysql_fetch_lengths',
+ 'mysql_fetch_object','mysql_fetch_row','mysql_field_flags','mysql_field_len','mysql_field_name','mysql_field_seek',
+ 'mysql_field_table','mysql_field_type','mysql_free_result','mysql_get_client_info','mysql_get_host_info',
+ 'mysql_get_proto_info','mysql_get_server_info','mysql_info','mysql_insert_id','mysql_list_dbs',
+ 'mysql_list_fields','mysql_list_processes','mysql_list_tables','mysql_num_fields','mysql_num_rows','mysql_numrows',
+ 'mysql_pconnect','mysql_ping','mysql_query','mysql_real_escape_string','mysql_result','mysql_select_db',
+ 'mysql_stat','mysql_tablename','mysql_thread_id','mysql_unbuffered_query')
+ as $value) eval(
+ "function $value(){\n".
+ " \$args=func_get_args();\n".
+ " return call_user_func_array('nucleus_$value',\$args);\n".
+ "}\n");
+}
+
+// Empty object for mysql_fetch_object().
+class SQLITE_OBJECT {}
+
+function sqlite_ReturnWithError($text='Not supported',$more=''){
+ // Show warning when error_reporting() is set.
+ if (!(error_reporting() & E_WARNING)) return false;
+
+ // Seek the file and line that originally called sql function.
+ $a=debug_backtrace();
+ foreach($a as $key=>$btrace) {
+ if (!($templine=$btrace['line'])) continue;
+ if (!($tempfile=$btrace['file'])) continue;
+ $file=str_replace("\\",'/',$file);
+ if (!$line && !$file && strpos($tempfile,'/sqlite.php')===false && strpos($tempfile,'/sqlitequeryfunctions.php')===false) {
+ $line=$templine;
+ $file=$tempfile;
+ }
+ echo "\n<!--$tempfile line:$templine-->\n";
+ }
+ echo "Warning from SQLite-MySQL wrapper: $text<br />\n";
+ if ($line && $file) echo "in <b>$file</b> on line <b>$line</b><br />\n";
+ echo $more;
+ return false;
+}
+function sqlite_DebugMessage($text=''){
+ global $SQLITECONF;
+ if (!$SQLITECONF['DEBUGREPORT']) return;
+ if ($text) $SQLITECONF['DEBUGMESSAGE'].="\n".$text."\n";
+ if (headers_sent()) {
+ echo '<!--sqlite_DebugMessage'.$SQLITECONF['DEBUGMESSAGE'].'sqlite_DebugMessage-->';
+ unset($SQLITECONF['DEBUGMESSAGE']);
+ }
+}
+
+// nucleus_mysql_XXXX() functions follow.
+
+function nucleus_mysql_connect($p1=null,$p2=null,$p3=null,$p4=null,$p5=null){
+ // All prameters are ignored.
+ global $SQLITE_DBHANDLE,$SQLITECONF;
+ if (!$SQLITE_DBHANDLE) $SQLITE_DBHANDLE=sqlite_open($SQLITECONF['DBFILENAME']);
+ // Initialization queries.
+ foreach($SQLITECONF['INITIALIZE'] as $value) nucleus_mysql_query($value);
+ return $SQLITE_DBHANDLE;
+}
+
+function nucleus_mysql_close($p1=null){
+ global $SQLITE_DBHANDLE;
+ if (!($dbhandle=$p1)) $dbhandle=$SQLITE_DBHANDLE;
+ $SQLITE_DBHANDLE='';
+ return sqlite_close ($dbhandle);
+}
+
+function nucleus_mysql_select_db($p1,$p2=null){
+ // SQLite does not support multiple databases in a file.
+ // So this function do nothing and always returns true.
+ // Note: mysql_select_db() function returns true/false,
+ // not link-ID.
+ return true;
+}
+
+function nucleus_mysql_query($p1,$p2=null,$unbuffered=false){//echo htmlspecialchars($p1)."<br />\n";
+ global $SQLITE_DBHANDLE,$SQLITECONF;
+ if (!($dbhandle=$p2)) $dbhandle=$SQLITE_DBHANDLE;
+ $query=trim($p1);
+ if (strpos($query,"\xEF\xBB\xBF")===0) $query=substr($query,3);// UTF-8 stuff
+ if (substr($query,-1)==';') $query=substr($query,0,strlen($query)-1);
+
+ // Escape style is changed from MySQL type to SQLite type here.
+ // This is important to avoid possible SQL-injection.
+ $strpositions=array();// contains the data show where the strings are (startposition => endposition)
+ if (strpos($query,'`')!==false || strpos($query,'"')!==false || strpos($query,"'")!==false)
+ $strpositions=sqlite_changeQuote($query);
+ //echo "<br />".htmlspecialchars($p1)."<br /><br />\n".htmlspecialchars($query)."<hr />\n";
+
+ // Debug mode
+ if ($SQLITECONF['DEBUGMODE']) $query=sqlite_mysql_query_debug($query);
+
+ // Anyway try it.
+ if ($unbuffered) {
+ if ($ret=@sqlite_unbuffered_query($dbhandle,$query)) return $ret;
+ } else {
+ if ($ret=@sqlite_query($dbhandle,$query)) return $ret;
+ }
+
+ // Error occured. Query must be translated.
+ return sqlite_mysql_query_sub($dbhandle,$query,$strpositions,$p1,$unbuffered);
+}
+function sqlite_mysql_query_sub($dbhandle,$query,$strpositions=array(),$p1=null,$unbuffered=false){//echo htmlspecialchars($p1)."<br />\n";
+ // Query translation is needed, especially when changing the data in database.
+ // So far, this routine is written for 'CREATE TABLE','DROP TABLE', 'INSERT INTO',
+ // 'SHOW TABLES LIKE', 'SHOW KEYS FROM', 'SHOW INDEX FROM'
+ // and several functions used in query.
+ // How about 'UPDATE' ???
+ global $SQLITE_DBHANDLE,$SQLITECONF;
+ $beforetrans=time()+microtime();
+ if (!$p1) $p1=$query;
+ $morequeries=array();
+ $uquery=strtoupper($query);
+ if (strpos($uquery,'CREATE TABLE')===0 || ($temptable=(strpos($uquery,'CREATE TEMPORARY TABLE')===0))) {
+ if (!($i=strpos($query,'('))) return sqlite_ReturnWithError('nucleus_mysql_query: '.$p1);
+ //check if the command is 'CREATE TABLE IF NOT EXISTS'
+ if (strpos(strtoupper($uquery),'CREATE TABLE IF NOT EXISTS')===0) {
+ $tablename=trim(substr($query,26,$i-26));
+ if (substr($tablename,0,1)!="'") $tablename="'$tablename'";
+ $res=sqlite_query($dbhandle,"SELECT tbl_name FROM sqlite_master WHERE tbl_name=$tablename LIMIT 1");
+ if (nucleus_mysql_num_rows($res)) return true;
+ } else {
+ $tablename=trim(substr($query,12,$i-12));
+ if (substr($tablename,0,1)!="'") $tablename="'$tablename'";
+ }
+
+ $query=trim(substr($query,$i+1));
+ for ($i=strlen($query);0<$i;$i--) if ($query[$i]==')') break;
+ $query=substr($query,0,$i);
+ $auto_increment=false;
+ $commands=sqlite_splitByComma($query);
+ $query=' (';
+ $first=true;
+ foreach($commands as $key => $value) {
+ if (strpos(strtolower($value),'auto_increment')==strlen($value)-14) $auto_increment=true;
+ $isint=preg_match('/int\(([0-9]*?)\)/i',$value);
+ $isint=$isint | preg_match('/tinyint\(([0-9]*?)\)/i',$value);
+ $value=preg_replace('/int\(([0-9]*?)\)[\s]+unsigned/i','int($1)',$value);
+ $value=preg_replace('/int\([0-9]*?\)[\s]+NOT NULL[\s]+auto_increment$/i',' INTEGER NOT NULL PRIMARY KEY',$value);
+ $value=preg_replace('/int\([0-9]*?\)[\s]+auto_increment$/i',' INTEGER PRIMARY KEY',$value);
+ if ($auto_increment) $value=preg_replace('/^PRIMARY KEY(.*?)$/i','',$value);
+ while (preg_match('/PRIMARY KEY[\s]*\((.*)\([0-9]+\)(.*)\)/i',$value)) // Remove '(100)' from 'PRIMARY KEY (`xxx` (100))'
+ $value=preg_replace('/PRIMARY KEY[\s]*\((.*)\([0-9]+\)(.*)\)/i','PRIMARY KEY ($1 $2)',$value);
+
+ // CREATE KEY queries for SQLite (corresponds to KEY 'xxxx'('xxxx', ...) of MySQL
+ if (preg_match('/^FULLTEXT KEY(.*?)$/i',$value,$matches)) {
+ array_push($morequeries,'CREATE INDEX '.str_replace('('," ON $tablename (",$matches[1]));
+ $value='';
+ } else if (preg_match('/^UNIQUE KEY(.*?)$/i',$value,$matches)) {
+ array_push($morequeries,'CREATE UNIQUE INDEX '.str_replace('('," ON $tablename (",$matches[1]));
+ $value='';
+ } else if (preg_match('/^KEY(.*?)$/i',$value,$matches)) {
+ array_push($morequeries,'CREATE INDEX '.str_replace('('," ON $tablename (",$matches[1]));
+ $value='';
+ }
+
+ // Check if 'DEFAULT' is set when 'NOT NULL'
+ $uvalue=strtoupper($value);
+ if (strpos($uvalue,'NOT NULL')!==false &&
+ strpos($uvalue,'DEFAULT')===false &&
+ strpos($uvalue,'INTEGER NOT NULL PRIMARY KEY')===false) {
+ if ($isint) $value.=" DEFAULT 0";
+ else $value.=" DEFAULT ''";
+ }
+
+ if ($value) {
+ if ($first) $first=false;
+ else $query.=',';
+ $query.=' '.$value;
+ }
+ }
+ $query.=' )';
+ if ($temptable) $query='CREATE TEMPORARY TABLE '.$tablename.$query;
+ else $query='CREATE TABLE '.$tablename.$query;
+ //echo "<br />".htmlspecialchars($p1)."<br /><br />\n".htmlspecialchars($query)."<hr />\n";
+ } else if (strpos($uquery,'DROP TABLE IF EXISTS')===0) {
+ if (!($i=strpos($query,';'))) $i=strlen($query);
+ $tablename=trim(substr($query,20,$i-20));
+ if (substr($tablename,0,1)!="'") $tablename="'$tablename'";
+ $res=sqlite_query($dbhandle,"SELECT tbl_name FROM sqlite_master WHERE tbl_name=$tablename LIMIT 1");
+ if (!nucleus_mysql_num_rows($res)) return true;
+ $query='DROP TABLE '.$tablename;
+ } else if (strpos($uquery,'ALTER TABLE ')===0) {
+ $query=trim(substr($query,11));
+ if ($i=strpos($query,' ')) {
+ $tablename=trim(substr($query,0,$i));
+ $query=trim(substr($query,$i));
+ $ret =sqlite_altertable($tablename,$query,$dbhandle);
+ if (!$ret) sqlite_ReturnWithError('SQL error',"<br /><i>".nucleus_mysql_error()."</i><br />".htmlspecialchars($p1)."<br /><br />\n".htmlspecialchars("ALTER TABLE $tablename $query")."<hr />\n");
+ return $ret;
+ }
+ // Syntax error
+ $query=='DROP TABLE '.$query;
+ } else if (strpos($uquery,'INSERT INTO ')===0 || strpos($uquery,'REPLACE INTO ')===0 ||
+ strpos($uquery,'INSERT IGNORE INTO ')===0 || strpos($uquery,'REPLACE IGNORE INTO ')===0) {
+ $buff=str_replace(' IGNORE ',' OR IGNORE ',substr($uquery,0,($i=strpos($uquery,' INTO ')+6)));
+ $query=trim(substr($query,$i));
+ if ($i=strpos($query,' ')) {
+ $buff.=trim(substr($query,0,$i+1));
+ $query=trim(substr($query,$i));
+ }
+ if ($i=strpos($query,' ')) {
+ if (strpos(strtoupper($query),'SET')===0) {
+ $query=trim(substr($query,3));
+ $commands=sqlite_splitByComma($query);
+ $query=' VALUES(';
+ $buff.=' (';
+ foreach($commands as $key=>$value){
+ //echo "[".htmlspecialchars($value)."]";
+ if (0<$key) {
+ $buff.=', ';
+ $query.=', ';
+ }
+ if ($i=strpos($value,'=')) {
+ $buff.=trim(substr($value,0,$i));
+ $query.=substr($value,$i+1);
+ }
+ }
+ $buff.=')';
+ $query.=')';
+ } else {
+ $beforevalues='';
+ $commands=sqlite_splitByComma($query);
+ $query='';
+ foreach($commands as $key=>$value){
+ if ($beforevalues=='' && preg_match('/^(.*)\)\s+VALUES\s+\(/i',$value,$matches)) {
+ $beforevalues=$buff.' '.$query.$matches[1].')';
+ }
+ if (0<$key) $query.=$beforevalues.' VALUES ';// supports multiple insertion
+ $query.=$value.';';
+ }
+ }
+ }
+ $query=$buff.' '.$query;
+ } else if (strpos($uquery,'SHOW TABLES LIKE ')===0) {
+ $query='SELECT name FROM sqlite_master WHERE type=\'table\' AND name LIKE '.substr($query,17);
+ } else if (strpos($uquery,'SHOW TABLES')===0) {
+ $query='SELECT name FROM sqlite_master WHERE type=\'table\'';
+ } else if (strpos($uquery,'SHOW KEYS FROM ')===0) {
+ $query=sqlite_showKeysFrom(trim(substr($query,15)),$dbhandle);
+ } else if (strpos($uquery,'SHOW INDEX FROM ')===0) {
+ $query=sqlite_showKeysFrom(trim(substr($query,16)),$dbhandle);
+ } else if (strpos($uquery,'SHOW FIELDS FROM ')===0) {
+ $query=sqlite_showFieldsFrom(trim(substr($query,17)),$dbhandle);
+ } else if (strpos($uquery,'SHOW COLUMNS FROM ')===0) {
+ $query=sqlite_showFieldsFrom(trim(substr($query,18)),$dbhandle);
+ } else if (strpos($uquery,'TRUNCATE TABLE ')===0) {
+ $query='DELETE FROM '.substr($query,15);
+ } else SQLite_Functions::sqlite_modifyQueryForUserFunc($query,$strpositions);
+
+ //Throw query again.
+ $aftertrans=time()+microtime();
+ if ($unbuffered) {
+ $ret=sqlite_unbuffered_query($dbhandle,$query);
+ } else {
+ $ret=sqlite_query($dbhandle,$query);
+ }
+
+ $afterquery=time()+microtime();
+ if ($SQLITECONF['MEASURESPEED']) sqlite_DebugMessage("translated query:$query\n".
+ 'translation: '.($aftertrans-$beforetrans).'sec, query: '.($afterquery-$aftertrans).'sec');
+ if (!$ret) sqlite_ReturnWithError('SQL error',"<br /><i>".nucleus_mysql_error()."</i><br />".htmlspecialchars($p1)."<br /><br />\n".htmlspecialchars($query)."<hr />\n");
+ foreach ($morequeries as $value) if ($value) @sqlite_query($dbhandle,$value);
+ return $ret;
+}
+function sqlite_changeQuote(&$query){
+ // This function is most important.
+ // When you modify this function, do it very carefully.
+ // Otherwise, you may allow crackers to do SQL-injection.
+ // This function returns array that shows where the strings are.
+ $sarray=array();
+ $ret='';
+ $qlen=strlen($query);
+ for ($i=0;$i<$qlen;$i++) {
+ // Go to next quote
+ if (($i1=strpos($query,'"',$i))===false) $i1=$qlen;
+ if (($i2=strpos($query,"'",$i))===false) $i2=$qlen;
+ if (($i3=strpos($query,'`',$i))===false) $i3=$qlen;
+ if ($i1==$qlen && $i2==$qlen && $i3==$qlen) {
+ $ret.=($temp=substr($query,$i));
+ if (strstr($temp,';')) exit('Warning: try to use more than two queries?');
+ break;
+ }
+ if ($i2<($j=$i1)) $j=$i2;
+ if ($i3<$j) $j=$i3;
+ $ret.=($temp=substr($query,$i,$j-$i));
+ $c=$query[($i=$j)]; // $c keeps the type of quote.
+ if (strstr($temp,';')) exit('Warning: try to use more than two queries?');
+
+ // Check between quotes.
+ // $j shows the begging positioin.
+ // $i will show the ending position.
+ $j=(++$i);
+ while ($i<$qlen) {
+ if (($i1=strpos($query,$c,$i))===false) $i1=$qlen;
+ if (($i2=strpos($query,"\\",$i))===false) $i2=$qlen;
+ if ($i2<$i1) {
+ // \something. Skip two characters.
+ $i=$i2+2;
+ continue;
+ } if ($i1<($qlen-1) && $query[$i1+1]==$c) {
+ // "", '' or ``. Skip two characters.
+ $i=$i1+2;
+ continue;
+ } else {// OK. Reached the end position
+ $i=$i1;
+ break;
+ }
+ }
+ $i1=strlen($ret);
+ $ret.="'".sqlite_changeslashes(substr($query,$j,$i-$j));
+ if ($i<$qlen) $ret.="'"; //else Syntax error in query.
+ $i2=strlen($ret);
+ $sarray[$i1]=$i2;
+ }//echo htmlspecialchars($query).'<br />'.htmlspecialchars($ret).'<br />';
+ $query=$ret;
+ return $sarray;
+}
+function sqlite_splitByComma($query) {
+ // The query is splitted by comma and the data will be put into an array.
+ // The commas in quoted strings are ignored.
+ $commands=array();
+ $i=0;
+ $in=false;
+ while ($query) {
+ if ($query[$i]=="'") {
+ $i++;
+ while ($i<strlen($query)) {
+ if ($query[$i++]!="'") continue;
+ if ($query[$i]!="'") break;
+ $i++;
+ }
+ continue;
+ } else if ($query[$i]=='(') $in=true;
+ else if ($query[$i]==')') $in=false;
+ else if ($query[$i]==',' && (!$in)) {
+ $commands[]=trim(substr($query,0,$i));
+ $query=trim(substr($query,$i+1));
+ $i=0;
+ continue;
+ } // Do NOT add 'else' statement here! '$i++' is important in the following line.
+ if (strlen($query)<=($i++)) break;
+ }
+ if ($query) $commands[]=$query;
+ return $commands;
+}
+function sqlite_changeslashes(&$text){
+ // By SQLite, "''" is used in the quoted string instead of "\'".
+ // In addition, only "'" seems to be allowed for perfect quotation of string.
+ // This routine is used for the conversion from MySQL type to SQL type.
+ // Do NOT use stripslashes() but use stripcslashes(). Otherwise, "\r\n" is not converted.
+ if ($text==='') return '';
+ return (sqlite_escape_string (stripcslashes((string)$text)));
+}
+function sqlite_altertable($table,$alterdefs,$dbhandle){
+ // This function originaly came from Jon Jensen's PHP class, SQLiteDB.
+ // There are some modifications by Katsumi.
+ $table=str_replace("'",'',$table);
+ if (!$alterdefs) return false;
+ $result = sqlite_query($dbhandle,"SELECT sql,name,type FROM sqlite_master WHERE tbl_name = '".$table."' ORDER BY type DESC");
+ if(!sqlite_num_rows($result)) return sqlite_ReturnWithError('no such table: '.$table);
+ $row = sqlite_fetch_array($result); //table sql
+ if (function_exists('microtime')) $tmpname='t'.str_replace('.','',str_replace(' ','',microtime()));
+ else $tmpname = 't'.rand(0,999999).time();
+ $origsql = trim(preg_replace("/[\s]+/"," ",str_replace(",",", ",preg_replace("/[\(]/","( ",$row['sql'],1))));
+ $createtemptableSQL = 'CREATE TEMPORARY '.substr(trim(preg_replace("'".$table."'",$tmpname,$origsql,1)),6);
+ $createindexsql = array();
+ while ($row = sqlite_fetch_array($result)) {//index sql
+ $createindexsql[]=$row['sql'];
+ }
+ $i = 0;
+ $defs = preg_split("/[,]+/",$alterdefs,-1,PREG_SPLIT_NO_EMPTY);
+ $prevword = $table;
+ $oldcols = preg_split("/[,]+/",substr(trim($createtemptableSQL),strpos(trim($createtemptableSQL),'(')+1),-1,PREG_SPLIT_NO_EMPTY);
+ $newcols = array();
+ for($i=0;$i<sizeof($oldcols);$i++){
+ $colparts = preg_split("/[\s]+/",$oldcols[$i],-1,PREG_SPLIT_NO_EMPTY);
+ $oldcols[$i] = $colparts[0];
+ $newcols[$colparts[0]] = $colparts[0];
+ }
+ $newcolumns = '';
+ $oldcolumns = '';
+ reset($newcols);
+ while(list($key,$val) = each($newcols)){
+ if (strtoupper($val)!='PRIMARY' && strtoupper($key)!='PRIMARY' &&
+ strtoupper($val)!='UNIQUE' && strtoupper($key)!='UNIQUE'){
+ $newcolumns .= ($newcolumns?', ':'').$val;
+ $oldcolumns .= ($oldcolumns?', ':'').$key;
+ }
+ }
+ $copytotempsql = 'INSERT INTO '.$tmpname.'('.$newcolumns.') SELECT '.$oldcolumns.' FROM '.$table;
+ $dropoldsql = 'DROP TABLE '.$table;
+ $createtesttableSQL = $createtemptableSQL;
+ foreach($defs as $def){
+ $defparts = preg_split("/[\s]+/",$def,-1,PREG_SPLIT_NO_EMPTY);
+ $action = strtolower($defparts[0]);
+ switch($action){
+ case 'modify':
+ // Modification does not mean anything for SQLite, so just return true.
+ // But this command will be supported in future???
+ break;
+ case 'add':
+ if(($i=sizeof($defparts)) <= 2) return sqlite_ReturnWithError('near "'.$defparts[0].($defparts[1]?' '.$defparts[1]:'').'": syntax error');
+
+ // ignore if there is already such table
+ $exists=false;
+ foreach($oldcols as $value) if (str_replace("'",'',$defparts[1])==str_replace("'",'',$value)) $exists=true;
+ if ($exists) break;
+
+ // Ignore 'AFTER xxxx' statement.
+ // Ignore 'FIRST' statement.
+ // Maybe this feature will be supprted later.
+ if (4<=$i && strtoupper($defparts[$i-2])=='AFTER') unset($defparts[$i-1],$defparts[$i-2]);
+ else if (3<=$i && strtoupper($defparts[$i-1])=='FIRST') unset($defparts[$i-1]);
+
+ $createtesttableSQL = substr($createtesttableSQL,0,strlen($createtesttableSQL)-1).',';
+ for($i=1;$i<sizeof($defparts);$i++) $createtesttableSQL.=' '.$defparts[$i];
+ $createtesttableSQL.=')';
+ break;
+ case 'change':
+ if(sizeof($defparts) <= 3) return sqlite_ReturnWithError('near "'.$defparts[0].($defparts[1]?' '.$defparts[1]:'').($defparts[2]?' '.$defparts[2]:'').'": syntax error');
+ if($severpos = strpos($createtesttableSQL,' '.$defparts[1].' ')){
+ if($newcols[$defparts[1]] != $defparts[1]){
+ sqlite_ReturnWithError('unknown column "'.$defparts[1].'" in "'.$table.'"');
+ return false;
+ }
+ $newcols[$defparts[1]] = $defparts[2];
+ $nextcommapos = strpos($createtesttableSQL,',',$severpos);
+ $insertval = '';
+ for($i=2;$i<sizeof($defparts);$i++) $insertval.=' '.$defparts[$i];
+ if($nextcommapos) $createtesttableSQL = substr($createtesttableSQL,0,$severpos).$insertval.substr($createtesttableSQL,$nextcommapos);
+ else $createtesttableSQL = substr($createtesttableSQL,0,$severpos-(strpos($createtesttableSQL,',')?0:1)).$insertval.')';
+ } else return sqlite_ReturnWithError('unknown column "'.$defparts[1].'" in "'.$table.'"');
+ break;
+ case 'drop':
+ if(sizeof($defparts) < 2) return sqlite_ReturnWithError('near "'.$defparts[0].($defparts[1]?' '.$defparts[1]:'').'": syntax error');
+ if($severpos = strpos($createtesttableSQL,' '.$defparts[1].' ')){
+ $nextcommapos = strpos($createtesttableSQL,',',$severpos);
+ if($nextcommapos) $createtesttableSQL = substr($createtesttableSQL,0,$severpos).substr($createtesttableSQL,$nextcommapos + 1);
+ else $createtesttableSQL = substr($createtesttableSQL,0,$severpos-(strpos($createtesttableSQL,',')?0:1) - 1).')';
+ unset($newcols[$defparts[1]]);
+ } else return sqlite_ReturnWithError('unknown column "'.$defparts[1].'" in "'.$table.'"');
+ break;
+ default:
+ return sqlite_ReturnWithError('near "'.$prevword.'": syntax error');
+ break;
+ }
+ $prevword = $defparts[sizeof($defparts)-1];
+ }
+
+ //this block of code generates a test table simply to verify that the columns specifed are valid in an sql statement
+ //this ensures that no reserved words are used as columns, for example
+ if (!sqlite_query($dbhandle,$createtesttableSQL)) return false;
+ $droptempsql = 'DROP TABLE '.$tmpname;
+ sqlite_query($dbhandle,$droptempsql);
+ //end block
+
+ $createnewtableSQL = 'CREATE '.substr(trim(preg_replace("'".$tmpname."'",$table,$createtesttableSQL,1)),17);
+ $newcolumns = '';
+ $oldcolumns = '';
+ reset($newcols);
+ while(list($key,$val) = each($newcols)) {
+ if (strtoupper($val)!='PRIMARY' && strtoupper($key)!='PRIMARY' &&
+ strtoupper($val)!='UNIQUE' && strtoupper($key)!='UNIQUE'){
+ $newcolumns .= ($newcolumns?', ':'').$val;
+ $oldcolumns .= ($oldcolumns?', ':'').$key;
+ }
+ }
+ $copytonewsql = 'INSERT INTO '.$table.'('.$newcolumns.') SELECT '.$oldcolumns.' FROM '.$tmpname;
+
+ sqlite_query($dbhandle,$createtemptableSQL); //create temp table
+ sqlite_query($dbhandle,$copytotempsql); //copy to table
+ sqlite_query($dbhandle,$dropoldsql); //drop old table
+
+ sqlite_query($dbhandle,$createnewtableSQL); //recreate original table
+ foreach($createindexsql as $sql) sqlite_query($dbhandle,$sql); //recreate index
+ sqlite_query($dbhandle,$copytonewsql); //copy back to original table
+ sqlite_query($dbhandle,$droptempsql); //drop temp table
+ return true;
+}
+function sqlite_showKeysFrom($tname,$dbhandle) {
+ // This function is for supporing 'SHOW KEYS FROM' and 'SHOW INDEX FROM'.
+ // For making the same result as obtained by MySQL, temporary table is made.
+ $tname=str_replace("'",'',$tname);
+
+ // Create a temporary table for making result
+ if (function_exists('microtime')) $tmpname='t'.str_replace('.','',str_replace(' ','',microtime()));
+ else $tmpname = 't'.rand(0,999999).time();
+ sqlite_query($dbhandle,"CREATE TEMPORARY TABLE $tmpname ('Table', 'Non_unique', 'Key_name', 'Seq_in_index',".
+ " 'Column_name', 'Collation', 'Cardinality', 'Sub_part', 'Packed', 'Null', 'Index_type', 'Comment')");
+
+ // First, get the sql query when the table created
+ $res=sqlite_query($dbhandle,"SELECT sql FROM sqlite_master WHERE tbl_name = '$tname' ORDER BY type DESC");
+ $a=nucleus_mysql_fetch_assoc($res);
+ $tablesql=$a['sql'];
+
+ // Check if each columns are unique
+ $notnull=array();
+ foreach(sqlite_splitByComma(substr($tablesql,strpos($tablesql,'(')+1)) as $value) {
+ $name=str_replace("'",'',substr($value,0,strpos($value,' ')));
+ if (strpos(strtoupper($value),'NOT NULL')!==false) $notnull[$name]='';
+ else $notnull[$name]='YES';
+ }
+
+ // Get the primary key (and check if it is unique???).
+ if (preg_match('/[^a-zA-Z_\']([\S]+)[^a-zA-Z_\']+INTEGER NOT NULL PRIMARY KEY/i',$tablesql,$matches)) {
+ $pkey=str_replace("'",'',$matches[1]);
+ $pkeynull='';
+ } else if (preg_match('/[^a-zA-Z_\']([\S]+)[^a-zA-Z_\']+INTEGER PRIMARY KEY/i',$tablesql,$matches)) {
+ $pkey=str_replace("'",'',$matches[1]);
+ $pkeynull='YES';
+ } else if (preg_match('/PRIMARY KEY[\s]*?\(([^\)]+)\)/i',$tablesql,$matches)) {
+ $pkey=null;// PRIMARY KEY ('xxx'[,'xxx'])
+ foreach(explode(',',$matches[1]) as $key=>$value) {
+ $value=str_replace("'",'',trim($value));
+ $key++;
+ $cardinality=nucleus_mysql_num_rows(sqlite_query($dbhandle,"SELECT '$value' FROM '$tname'"));
+ sqlite_query($dbhandle,"INSERT INTO $tmpname ('Table', 'Non_unique', 'Key_name', 'Seq_in_index',".
+ " 'Column_name', 'Collation', 'Cardinality', 'Sub_part', 'Packed', 'Null', 'Index_type', 'Comment')".
+ " VALUES ('$tname', '0', 'PRIMARY', '$key',".
+ " '$value', 'A', '$cardinality', null, null, '', 'BTREE', '')");
+ }
+ } else $pkey=null;
+
+ // Check the index.
+ $res=sqlite_query($dbhandle,"SELECT sql,name FROM sqlite_master WHERE type = 'index' and tbl_name = '$tname' ORDER BY type DESC");
+ while ($a=nucleus_mysql_fetch_assoc($res)) {
+ if (!($sql=$a['sql'])) {// Primary key
+ if ($pkey && strpos(strtolower($a['name']),'autoindex')) {
+ $cardinality=nucleus_mysql_num_rows(sqlite_query($dbhandle,"SELECT $pkey FROM '$tname'"));
+ sqlite_query($dbhandle,"INSERT INTO $tmpname ('Table', 'Non_unique', 'Key_name', 'Seq_in_index',".
+ " 'Column_name', 'Collation', 'Cardinality', 'Sub_part', 'Packed', 'Null', 'Index_type', 'Comment')".
+ " VALUES ('$tname', '0', 'PRIMARY', '1',".
+ " '$pkey', 'A', '$cardinality', null, null, '$pkeynull', 'BTREE', '')");
+ $pkey=null;
+ }
+ } else {// Non-primary key
+ if (($name=str_replace("'",'',$a['name'])) && preg_match('/\(([\s\S]+)\)/',$sql,$matches)) {
+ foreach(explode(',',$matches[1]) as $key=>$value) {
+ $columnname=str_replace("'",'',$value);
+ if (strpos(strtoupper($sql),'CREATE UNIQUE ')===0) $nonunique='0';
+ else $nonunique='1';
+ $cardinality=nucleus_mysql_num_rows(sqlite_query($dbhandle,"SELECT $columnname FROM '$tname'"));
+ sqlite_query($dbhandle,"INSERT INTO $tmpname ('Table', 'Non_unique', 'Key_name', 'Seq_in_index',".
+ " 'Column_name', 'Collation', 'Cardinality', 'Sub_part', 'Packed', 'Null', 'Index_type', 'Comment')".
+ " VALUES ('$tname', '$nonunique', '$name', '".(string)($key+1)."',".
+ " '$columnname', 'A', '$cardinality', null, null, '$notnull[$columnname]', 'BTREE', '')");
+ }
+ }
+ }
+ }
+ if ($pkey) { // The case that the key (index) is not defined.
+ $cardinality=nucleus_mysql_num_rows(sqlite_query($dbhandle,"SELECT $pkey FROM '$tname'"));
+ sqlite_query($dbhandle,"INSERT INTO $tmpname ('Table', 'Non_unique', 'Key_name', 'Seq_in_index',".
+ " 'Column_name', 'Collation', 'Cardinality', 'Sub_part', 'Packed', 'Null', 'Index_type', 'Comment')".
+ " VALUES ('$tname', '0', 'PRIMARY', '1',".
+ " '$pkey', 'A', '$cardinality', null, null, '$pkeynull', 'BTREE', '')");
+ $pkey=null;
+ }
+
+ // return the final query to show the keys in MySQL style (using temporary table).
+ return "SELECT * FROM $tmpname";
+}
+function sqlite_showFieldsFrom($tname,$dbhandle){
+ // This function is for supporing 'SHOW FIELDS FROM' and 'SHOW COLUMNS FROM'.
+ // For making the same result as obtained by MySQL, temporary table is made.
+ $tname=str_replace("'",'',$tname);
+
+ // First, get the sql query when the table created
+ $res=sqlite_query($dbhandle,"SELECT sql FROM sqlite_master WHERE tbl_name = '$tname' ORDER BY type DESC");
+ $a=nucleus_mysql_fetch_assoc($res);
+ $tablesql=trim($a['sql']);
+ if (preg_match('/^[^\(]+\(([\s\S]*?)\)$/',$tablesql,$matches)) $tablesql=$matches[1];
+ $tablearray=array();
+ foreach(sqlite_splitByComma($tablesql) as $value) {
+ $value=trim($value);
+ if ($i=strpos($value,' ')) {
+ $name=str_replace("'",'',substr($value,0,$i));
+ $value=trim(substr($value,$i));
+ if (substr($value,-1)==',') $value=substr($value,strlen($value)-1);
+ $tablearray[$name]=$value;
+ }
+ }
+
+ // Check if INDEX has been made for the parameter 'MUL' in 'KEY' column
+ $multi=array();
+ $res=sqlite_query($dbhandle,"SELECT name FROM sqlite_master WHERE type = 'index' and tbl_name = '$tname' ORDER BY type DESC");
+ while ($a=nucleus_mysql_fetch_assoc($res)) $multi[str_replace("'",'',$a['name'])]='MUL';
+
+ // Create a temporary table for making result
+ if (function_exists('microtime')) $tmpname='t'.str_replace('.','',str_replace(' ','',microtime()));
+ else $tmpname = 't'.rand(0,999999).time();
+ sqlite_query($dbhandle,"CREATE TEMPORARY TABLE $tmpname ('Field', 'Type', 'Null', 'Key', 'Default', 'Extra')");
+
+ // Check the table
+ foreach($tablearray as $field=>$value) {
+ if (strtoupper($field)=='PRIMARY') continue;//PRIMARY KEY('xx'[,'xx'])
+ $uvalue=strtoupper($value.' ');
+ $key=(string)$multi[$field];
+ if ($uvalue=='INTEGER NOT NULL PRIMARY KEY ' || $uvalue=='INTEGER PRIMARY KEY ') {
+ $key='PRI';
+ $extra='auto_increment';
+ } else $extra='';
+ if ($i=strpos($uvalue,' ')) {
+ $type=substr($value,0,$i);
+ if (strpos($type,'(') && ($i=strpos($value,')')))
+ $type=substr($value,0,$i+1);
+ } else $type='';
+ if (strtoupper($type)=='INTEGER') $type='int(11)';
+ if (strpos($uvalue,'NOT NULL')===false) $null='YES';
+ else {
+ $null='';
+ $value=preg_replace('/NOT NULL/i','',$value);
+ $uvalue=strtoupper($value);
+ }
+ if ($i=strpos($uvalue,'DEFAULT')) {
+ $default=trim(substr($value,$i+7));
+ if (strtoupper($default)=='NULL') {
+ $default="";
+ $setdefault="";
+ } else {
+ if (substr($default,0,1)=="'") $default=substr($default,1,strlen($default)-2);
+ $default="'".$default."',";
+ $setdefault="'Default',";
+ }
+ } else if ($null!='YES' && $extra!='auto_increment') {
+ if (strpos(strtolower($type),'int')===false) $default="'',";
+ else $default="'0',";
+ $setdefault="'Default',";
+ } else {
+ $default="";
+ $setdefault="";
+ }
+ sqlite_query($dbhandle,"INSERT INTO '$tmpname' ('Field', 'Type', 'Null', 'Key', $setdefault 'Extra')".
+ " VALUES ('$field', '$type', '$null', '$key', $default '$extra')");
+ }
+
+ // return the final query to show the keys in MySQL style (using temporary table).
+ return "SELECT * FROM $tmpname";
+}
+function sqlite_mysql_query_debug(&$query){
+ // The debug mode is so far used for checking query difference like "SELECT i.itime, ....".
+ // This must be chaged to "SELECT i.itime as itime,..." for SQLite.
+ // (This feature is not needed any more after the version 0.8.1 (see intialization query))
+ $uquery=strtoupper($query);
+ if (strpos($uquery,"SELECT ")!==0) return $query;
+ if (($i=strpos($uquery," FROM "))===false) return $query;
+ $select=sqlite_splitByComma(substr($query,7,$i-7));
+ $query=substr($query,$i);
+ $ret='';
+ foreach($select as $value){
+ if (preg_match('/^([a-z_]+)\.([a-z_]+)$/i',$value,$matches)) {
+ $value=$value." as ".$matches[2];
+ $t=$matches[0]."=>$value\n";
+ $a=debug_backtrace();
+ foreach($a as $key=>$btrace) {
+ if (!($templine=$btrace['line'])) continue;
+ if (!($tempfile=$btrace['file'])) continue;
+ $tempfile=preg_replace('/[\s\S]*?[\/\\\\]([^\/\\\\]+)$/','$1',$tempfile);
+ $t.="$tempfile line:$templine\n";
+ }
+ sqlite_DebugMessage($t);
+ }
+ if ($ret) $ret.=', ';
+ $ret.=$value;
+ }
+ return "SELECT $ret $query";
+}
+
+function nucleus_mysql_list_tables($p1=null,$p2=null) {
+ global $SQLITE_DBHANDLE,$MYSQL_DATABASE;
+ return sqlite_query($SQLITE_DBHANDLE,"SELECT name as Tables_in_$MYSQL_DATABASE FROM sqlite_master WHERE type='table'");
+}
+function nucleus_mysql_listtables($p1=null,$p2=null) { return nucleus_mysql_list_tables($p1,$p2);}
+
+function nucleus_mysql_affected_rows($p1=null){
+ global $SQLITE_DBHANDLE;
+ if (!($dbhandle=$p1)) $dbhandle=$SQLITE_DBHANDLE;
+ return sqlite_changes($dbhandle);
+}
+
+function nucleus_mysql_error($p1=null){
+ global $SQLITE_DBHANDLE;
+ if (!($dbhandle=$p1)) $dbhandle=$SQLITE_DBHANDLE;
+ return sqlite_error_string ( sqlite_last_error ($dbhandle) );
+}
+
+function nucleus_mysql_fetch_array($p1,$p2=SQLITE_BOTH){
+ return sqlite_fetch_array ($p1,$p2);
+}
+
+function nucleus_mysql_fetch_assoc($p1){
+ return sqlite_fetch_array($p1,SQLITE_ASSOC);
+}
+
+function nucleus_mysql_fetch_object($p1,$p2=SQLITE_BOTH){
+ if (is_array($ret=sqlite_fetch_array ($p1,$p2))) {
+ $o=new SQLITE_OBJECT;
+ foreach ($ret as $key=>$value) {
+ if (strstr($key,'.')) {// Remove table name.
+ $key=preg_replace('/^(.+)\."(.+)"$/','"$2"',$key);
+ $key=preg_replace('/^(.+)\.([^.^"]+)$/','$2',$key);
+ }
+ $o->$key=$value;
+ }
+ return $o;
+ } else return false;
+}
+
+function nucleus_mysql_fetch_row($p1){
+ return sqlite_fetch_array($p1,SQLITE_NUM);
+}
+
+function nucleus_mysql_field_name($p1,$p2){
+ return sqlite_field_name ($p1,$p2);
+}
+
+function nucleus_mysql_free_result($p1){
+ // ???? Cannot find corresponding function of SQLite.
+ // Maybe SQLite is NOT used for the high spec server
+ // that need mysql_free_result() function because of
+ // many SQL-queries in a script.
+ return true;
+}
+
+function nucleus_mysql_insert_id($p1=null){
+ global $SQLITE_DBHANDLE;
+ if (!($dbhandle=$p1)) $dbhandle=$SQLITE_DBHANDLE;
+ return sqlite_last_insert_rowid ($dbhandle);
+}
+
+function nucleus_mysql_num_fields($p1){
+ return sqlite_num_fields ($p1);
+}
+
+function nucleus_mysql_num_rows($p1){
+ return sqlite_num_rows ($p1);
+}
+function nucleus_mysql_numrows($p1){
+ return sqlite_num_rows ($p1);
+}
+
+function nucleus_mysql_result($p1,$p2,$p3=null){
+ if ($p3) return sqlite_ReturnWithError('nucleus_mysql_result');
+ if (!$p2) return sqlite_fetch_single ($p1);
+ $a=sqlite_fetch_array ($p1);
+ return $a[$p2];
+}
+
+function nucleus_mysql_unbuffered_query($p1,$p2=null){
+ return nucleus_mysql_query($p1,$p2,true);
+}
+
+function nucleus_mysql_client_encoding($p1=null){
+ return sqlite_libencoding();
+}
+
+function nucleus_mysql_data_seek($p1,$p2) {
+ return sqlite_seek($p1,$p2);
+}
+
+function nucleus_mysql_errno ($p1=null){
+ global $SQLITE_DBHANDLE;
+ if (!($dbhandle=$p1)) $dbhandle=$SQLITE_DBHANDLE;
+ return sqlite_last_error($dbhandle);
+}
+
+function nucleus_mysql_escape_string ($p1){
+ // The "'" will be changed to "''".
+ // This way works for both MySQL and SQLite when single quotes are used for string.
+ // Note that single quote is always used in this wrapper.
+ // If a plugin is made on SQLite-Nucleus and such plugin will be used for MySQL-Nucleus,
+ // nucleus_mysql_escape_string() will be changed to mysql_escape_string() and
+ // this routine won't be used, so this way won't be problem.
+ return sqlite_escape_string($p1);
+}
+
+function nucleus_mysql_real_escape_string ($p1,$p2=null){
+ //addslashes used here.
+ return addslashes($p1);
+}
+
+function nucleus_mysql_create_db ($p1,$p2=null){
+ // All prameters are ignored.
+ // Returns always true;
+ return true;
+}
+
+function nucleus_mysql_pconnect($p1=null,$p2=null,$p3=null,$p4=null,$p5=null){
+ global $SQLITE_DBHANDLE,$SQLITECONF;
+ sqlite_close ($SQLITE_DBHANDLE);
+ $SQLITE_DBHANDLE=sqlite_popen($SQLITECONF['DBFILENAME']);
+ return ($SQLITE['DBHANDLE']=$SQLITE_DBHANDLE);
+}
+
+function nucleus_mysql_fetch_field($p1,$p2=null){
+ if ($p2) return sqlite_ReturnWithError('nucleus_mysql_fetch_field');
+ // Only 'name' is supported.
+ $o=new SQLITE_OBJECT;
+ $o->name=array();
+ if(is_array($ret=sqlite_fetch_array ($p1,SQLITE_ASSOC )))
+ foreach ($ret as $key=>$value) {
+ if (is_string($key)) array_push($o->name,$key);
+ }
+ return $o;
+
+}
+
+// This function is called instead of _execute_queries() in backp.php
+function sqlite_restore_execute_queries(&$query){
+ global $DIR_NUCLEUS,$DIR_LIBS,$DIR_PLUGINS,$CONF;
+
+ // Skip until the first "#" or "--"
+ if (($i=strpos($query,"\n#"))===false) $i=strlen($query);
+ if (($j=strpos($query,"\n--"))===false) $j=strlen($query);
+ if ($i<$j) $query=substr($query,$i+1);
+ else $query=substr($query,$j+1);
+
+ // Save the query to temporary file in sqlite directory.
+ if (function_exists('microtime')) {
+ $prefix=preg_replace('/[^0-9]/','',microtime());
+ } else {
+ srand(time());
+ $prefix=(string)rand(0,999999);
+ }
+ $tmpname=tempnam($DIR_NUCLEUS.'sqlite/',"tmp$prefix");
+ if (!($handle=@fopen($tmpname,'w'))) return 'Cannot save temporary DB file.';
+ fwrite($handle,$query);
+ fclose($handle);
+ $tmpname=preg_replace('/[\s\S]*?[\/\\\\]([^\/\\\\]+)$/','$1',$tmpname);
+
+ // Read the option from NP_SQLite
+ if (!class_exists('NucleusPlugin')) { include($DIR_LIBS.'PLUGIN.php');}
+ if (!class_exists('NP_SQLite')) { include($DIR_PLUGINS.'NP_SQLite.php'); }
+ $p=new NP_SQLite();
+ if (!($numatonce=@$p->getOption('numatonce'))) $numatonce=20;
+ if (!($refreshwait=@$p->getOption('refreshwait'))) $refreshwait=1;
+
+ // Start process.
+ $url="plugins/sqlite/restore.php?dbfile=$tmpname&numatonce=$numatonce&refreshwait=$refreshwait";
+ header('HTTP/1.0 301 Moved Permanently');
+ header('Location: '.$url);
+ exit('<html><body>Moved Permanently</body></html>');
+}
+
+?>
\ No newline at end of file
--- /dev/null
+<?php
+ /***************************************
+ * SQLite-MySQL wrapper for Nucleus *
+ * ver 0.8.5 *
+ * Written by Katsumi *
+ ***************************************/
+//
+// The licence of this script is GPL
+//
+// The features that are supported by this script but not
+// generally by SQLite are as follows:
+//
+// CONCAT, IF, IFNULL, NULLIF, SUBSTRING,
+// match() against(),
+// replace, UNIX_TIMESTAMP, REGEXP, DAYOFMONTH, MONTH, YEAR,
+// ADDDATE, DATE_ADD, SUBDATE, DATE_SUB, FIND_IN_SET,
+// CURDATE, CURRENT_DATE, CURTIME, CURRENT_TIME, CURRENT_TIMESTAMP,
+// LOCALTIME, LOCALTIMESTAMP, SYSDATE, DATE_FORMAT, TIME_FORMAT,
+// DAYNAME, DAYOFWEEK, DAYOFYEAR, EXTRACT, FROM_DAYS, FROM_UNIXTIME,
+// HOUR, MINUTE, MONTH, MONTHNAME, PERIOD_ADD, PERIOD_DIFF, QUARTER,
+// SECOND, SEC_TO_TIME, SECOND, WEEK, WEEKDAY, YEAR, YEARWEEK,
+// FORMAT, INET_ATON, INET_NTOA, MD5,
+// ACOS, ASIN, ATAN, CEIL, CEILING, COS, COT, CRC32, DEGREES,
+// EXP, FLOOR, GREATEST, MAX, LEAST, MIN, ln, log, log2, log10,
+// MOD, PI, POW, POWER, RADIANS, RAND, SIGN, SIN, SQRT, TAN,
+// ASCII, BIN, BIT_LENGTH, CHAR, CHAR_LENGTH, CONCAT_WS,
+// CONV, ELT, EXPORT_SET, FIELD, HEX, INSERT, LOCATE,
+// INSTR, LCASE, LOWER, LEFT, LENGTH, OCTET_LENGTH,
+// LOAD_FILE, LPAD, LTRIM, MAKE_SET, MID, SUBSTRING,
+// OCT, ORD, QUOTE, REPEAT, REVERSE, RIGHT, RPAD,
+// RTRIM, SOUNDEX, SPACE, SUBSTRING_INDEX, TRIM,
+// UCASE, UPPER,
+
+
+// Register user-defined functions used in SQL query.
+// The SQLite_QueryFunctions object is created to register SQLite queries.
+$SQLITECONF['object']=new SQLite_Functions;
+// After the registration, the object is not required any more.
+unset($SQLITECONF['object']);
+
+
+// The class for SQLite user functions
+class SQLite_Functions {
+
+// Constructor is used for the registration of user-defined functions of SQLite
+function SQLite_Functions(){
+ global $SQLITE_DBHANDLE;
+ foreach($this as $key=>$value){
+ $key=strtoupper($key);
+ if (substr($key,0,7)!='DEFINE_') continue;
+ $key=substr($key,7);
+ if (substr($value,0,7)=='sqlite_') $value=array('SQLite_Functions',$value);
+ @sqlite_create_function($SQLITE_DBHANDLE,$key,$value);
+ }
+}
+
+var $define_ASCII='ord';
+
+var $define_BIN='decbin';
+
+var $define_BIT_LENGTH='sqlite_userfunc_BIT_LENGTH';
+function sqlite_userfunc_BIT_LENGTH($p1){
+ return strlen($p1)*8;
+}
+
+var $define_CHAR='sqlite_userfunc_CHAR';
+function sqlite_userfunc_CHAR(){
+ if (!($lastnum=func_num_args())) return null;
+ $args=&func_get_args();
+ $ret='';
+ for ($i=0;$i<$lastnum;$i++) {
+ if ($args[$i]!==null) $ret.=chr($args[$i]);
+ }
+ return $ret;
+}
+
+var $define_CHAR_LENGTH='mb_strlen';
+
+var $define_CONCAT_WS='sqlite_userfunc_CONCAT_WS';
+function sqlite_userfunc_CONCAT_WS(){
+ if (($lastnum=func_num_args())<2) return null;
+ $args=&func_get_args();
+ if ($args[0]===null) return null;
+ $ret='';
+ for ($i=1;$i<$lastnum;$i++) {
+ if ($args[$i]===null) continue;
+ if ($ret) $ret.=$args[0];
+ $ret.=(string)($args[$i]);
+ }
+ return $ret;
+}
+
+var $define_CONV='sqlite_userfunc_CONV';
+function sqlite_userfunc_CONV($p1,$p2,$p3){
+ $t36='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+ $p1=strtoupper(trim((string)$p1));
+ if ($p3<0 && substr($p1,0,1)=='-') {
+ $sign='-';
+ $p1=substr($p1,1);
+ } else $sign='';
+ $p3=abs($p3);
+ $v=0;
+ for ($i=0;$i<strlen($p1);$i++) $v=$v*$p2+strpos($t36,$p1[$i]);
+ if (!$v) return '0';
+ $ret='';
+ while ($v) {
+ $i=$v % $p3;
+ $ret=$t36[$i].$ret;
+ $v=($v-$i)/$p3;
+ }
+ return $sign.$ret;
+}
+
+var $define_ELT='sqlite_userfunc_ELT';
+function sqlite_userfunc_ELT(){
+ if (($lastnum=func_num_args())<2) return null;
+ $args=&func_get_args();
+ if ($args[0]<1 || $lastnum<$args[0]) return null;
+ return $args[$args[0]];
+}
+
+var $define_EXPORT_SET='sqlite_userfunc_EXPORT_SET';
+function sqlite_userfunc_EXPORT_SET($p1,$p2,$p3,$p4=',',$p5=64){
+ if ($p1<2147483648) $p1=decbin($p1);
+ else $p1=decbin($p1/2147483648).decbin($p1 % 2147483648);
+ $p1=substr(decbin($p1).str_repeat('0',$p5),0,$p5);
+ $p1=str_replace(array('1','0'),array($p2.$p4,$p3.$p4),$p1);
+ return substr($p1,0,strlen($p1)-strlen($p4));
+}
+
+var $define_FIELD='sqlite_userfunc_FIELD';
+function sqlite_userfunc_FIELD(){
+ if (($lastnum=func_num_args())<2) return null;
+ $args=&func_get_args();
+ for ($i=1;$i<$lastnum;$i++) if ($args[0]==$args[$i]) return $i;
+ return 0;
+}
+
+var $define_HEX='sqlite_userfunc_HEX';
+function sqlite_userfunc_HEX($p1){
+ if (is_numeric($p1)) return dechex ($p1);
+ $p1=(string)$p1;
+ $ret='';
+ for($i=0;$i<strlen($p1);$i++) $ret.=substr('0'.dechex($p1[$i]),-2);
+ return $ret;
+}
+
+var $define_INSERT='sqlite_userfunc_INSERT';
+function sqlite_userfunc_INSERT($p1,$p2,$p3,$p4){
+ if (function_exists('mb_substr')) return mb_substr($p1,0,$p2-1).$p4.mb_substr($p1,$p2+$p3-1);
+ return substr($p1,0,$p2-1).$p4.substr($p1,$p2+$p3-1);
+}
+
+var $define_LOCATE='sqlite_userfunc_LOCATE';
+function sqlite_userfunc_LOCATE($p1,$p2,$p3=1){
+ if (substr($p1,1)=='_') $p2='-'.$p2;
+ else $p2='_'.$p2;
+ if (function_exists('mb_strpos')) return (int)mb_strpos($p2,$p1,$p3);
+ if (($p=strpos(substr($p2,$p3),$p1))===false) return 0;
+ return $p+$p3;
+}
+
+var $define_INSTR='sqlite_userfunc_INSTR';
+function sqlite_userfunc_INSTR($p1,$p2){
+ return SQLite_Functions::sqlite_userfunc_LOCATE($p2,$p1);
+}
+
+var $define_LCASE='sqlite_userfunc_LOWER';
+var $define_LOWER='sqlite_userfunc_LOWER';
+function sqlite_userfunc_LOWER($p1){
+ if (function_exists('mb_strtolower')) return mb_strtolower($p1);
+ return strtolower($p1);
+}
+
+var $define_LEFT='sqlite_userfunc_LEFT';
+function sqlite_userfunc_LEFT($p1,$p2){
+ if (function_exists('mb_substr')) return mb_substr($p1,0,$p2);
+ return substr($p1,0,$p2);
+}
+
+var $define_LENGTH='strlen';
+var $define_OCTET_LENGTH='strlen';
+
+var $define_LOAD_FILE='sqlite_userfunc_LOAD_FILE';
+function sqlite_userfunc_LOAD_FILE($p1){
+ if (!file_exists($p1)) return null;
+ if (!is_array($a=@file($p1))) return null;
+ $ret='';
+ foreach($a as $value) $ret.=$value;
+ return $ret;
+}
+
+var $define_LPAD='sqlite_userfunc_LPAD';
+function sqlite_userfunc_LPAD($p1,$p2,$p3){
+ return substr(str_repeat($p3,$p2/strlen($p3)).$p1,0-$p2);
+}
+
+var $define_LTRIM='ltrim';
+
+var $define_MAKE_SET='sqlite_userfunc_MAKE_SET';
+function sqlite_userfunc_MAKE_SET($p1,$p2,$p3){
+ if (($lastnum=func_num_args())<2) return null;
+ $args=&func_get_args();
+ $ret='';
+ if ($args[0]<2147483648) $bits=decbin($args[0]);
+ else $bits=decbin($args[0]/2147483648).decbin($args[0] % 2147483648);
+ for ($i=1;$i<$lastnum;$i++) {
+ if ($bits[strlen($bits)-$i]=='1' && $args[$i]) {
+ if ($ret) $ret.=',';
+ $ret.=$args[$i];
+ }
+ }
+ return 0;
+}
+
+var $define_MID='sqlite_userfunc_SUBSTRING';
+var $define_SUBSTRING='sqlite_userfunc_SUBSTRING';
+function sqlite_userfunc_SUBSTRING($p1,$p2,$p3=null){
+ $p2--;
+ if (function_exists('mb_substr')) {
+ if ($p3) return mb_substr($p1,$p2,$p3);
+ return mb_substr($p1,$p2);
+ }
+ if ($p3) return substr($p1,$p2,$p3);
+ return substr($p1,$p2);
+}
+
+var $define_OCT='sqlite_userfunc_OCT';
+function sqlite_userfunc_OCT($p1){
+ if ($p1===null) return null;
+ return SQLite_Functions::sqlite_userfunc_CONV($p1,10,8);
+}
+
+var $define_ORD='sqlite_userfunc_ORD';
+function sqlite_userfunc_ORD($p1){
+ if (function_exists('mb_substr')) $p1=mb_substr($p1,0,1);
+ else $p1=substr($p1,0,1);
+ $ret=0;
+ for ($i=0;$i<strlen($p1);$i++) $ret=$ret*256+ord($p1[$i]);
+ return $ret;
+}
+
+var $define_QUOTE='sqlite_userfunc_QUOTE';
+function sqlite_userfunc_QUOTE($p1){
+ if ($p1===null) return 'NULL';
+ return str_replace(array("'","\\","\x1A"),array("\\'","\\\\","\\z"),$p1);
+}
+
+var $define_REPEAT='str_repeat';
+
+var $define_REVERSE='sqlite_userfunc_REVERSE';
+function sqlite_userfunc_REVERSE($p1){
+ if (function_exists('mb_strlen')) {
+ $ret='';
+ for ($i=mb_strlen($p1)-1;0<=$i;$i++) $ret.=mb_substr($p1,$i,1);
+ return $ret;
+ }
+ return strrev($p1);
+}
+
+var $define_RIGHT='sqlite_userfunc_RIGHT';
+function sqlite_userfunc_RIGHT($p1){
+ if (function_exists('mb_substr')) return mb_substr($p1,0-$p2);
+ return substr($p1,0-$p2);
+}
+
+var $define_RPAD='sqlite_userfunc_RPAD';
+function sqlite_userfunc_RPAD($p1,$p2,$p3){
+ return substr($p1.str_repeat($p3,$p2/strlen($p3)),0,$p2);
+}
+
+var $define_RTRIM='rtrim';
+var $define_SOUNDEX='soundex';
+
+var $define_SPACE='sqlite_userfunc_SPACE';
+function sqlite_userfunc_SPACE($p1){
+ return str_repeat(' ',$p1);
+}
+
+var $define_SUBSTRING_INDEX='sqlite_userfunc_SUBSTRING_INDEX';
+function sqlite_userfunc_SUBSTRING_INDEX($p1,$p2,$p3){
+ if (!is_array($a=explode($p2,$p1))) return null;
+ $ret='';
+ if (0<$p3) {
+ for ($i=0;$i<$p3;$i++) {
+ if ($ret) $ret.=$p2;
+ $ret.=$a[$i];
+ }
+ } else {
+ for ($i=0;$i<0-$p3;$i++) {
+ if ($ret) $ret.=$p2;
+ $ret.=$a[count($a)-1-$i];
+ }
+ }
+ return $ret;
+}
+
+var $define_TRIM='sqlite_userfunc_TRIM';
+function sqlite_userfunc_TRIM($p1,$p2=null,$p3=null){
+ if (!$p2 && !$p3) return trim($p1);
+ if (!$p2) $p2=' ';
+ switch(strtoupper($p1)){
+ case 'BOTH':
+ while (strpos($p3,$p2)===0) $p3=substr($p3,strlen($p2));
+ case 'TRAILING':
+ while (strrpos($p3,$p2)===strlen($p3)-strlen($p2)-1) $p3=substr($p3,0,strlen($p3)-strlen($p2));
+ break;
+ case 'LEADING':
+ while (strpos($p3,$p2)===0) $p3=substr($p3,strlen($p2));
+ break;
+ }
+ return $p2;
+}
+
+var $define_UCASE='sqlite_userfunc_UPPER';
+var $define_UPPER='sqlite_userfunc_UPPER';
+function sqlite_userfunc_UPPER($p1){
+ if (function_exists('mb_strtoupper')) return mb_strtoupper($p1);
+ return strtoupper($p1);
+}
+
+var $define_ACOS='acos';
+var $define_ASIN='asin';
+
+var $define_ATAN='sqlite_userfunc_ATAN';
+function sqlite_userfunc_ATAN($p1,$p2=null){
+ if (!$p2) return atan($p1);
+ if ($p1>0 && $p2>0) return atan($p1/$p2);
+ else if ($p1>0 && $p2<0) return pi-atan(-$p1/$p2);
+ else if ($p1<0 && $p2<0) return pi+atan($p1/$p2);
+ else if ($p1<0 && $p2>0) return 2*pi-atan(-$p1/$p2);
+ else return 0;
+}
+
+var $define_CEIL='ceil';
+var $define_CEILING='ceil';
+var $define_COS='cos';
+
+var $define_COT='sqlite_userfunc_COT';
+function sqlite_userfunc_COT($p1){
+ return 1/tan($p1);
+}
+
+var $define_CRC32='crc32';
+
+var $define_DEGREES='sqlite_userfunc_DEGREES';
+function sqlite_userfunc_DEGREES($p1){
+ return ($p1/pi)*180;
+}
+
+var $define_EXP='exp';
+var $define_FLOOR='floor';
+var $define_GREATEST='max';
+var $define_MAX='max';
+var $define_LEAST='min';
+var $define_MIN='min';
+var $define_ln='log';
+
+var $define_log='sqlite_userfunc_LOG';
+function sqlite_userfunc_LOG($p1,$p2=null){
+ if ($p2) return log($p1)/log($p2);
+ return log($p1);
+}
+
+var $define_log2='sqlite_userfunc_LOG2';
+function sqlite_userfunc_LOG2($p1){
+ return log($p1)/log(2);
+}
+
+var $define_log10='log10';
+
+var $define_MOD='sqlite_userfunc_MOD';
+function sqlite_userfunc_MOD($p1,$p2){
+ return $p1 % $p2;
+}
+
+var $define_PI='sqlite_userfunc_PI';
+function sqlite_userfunc_PI(){
+ return pi;
+}
+
+var $define_POW='sqlite_userfunc_POW';
+var $define_POWER='sqlite_userfunc_POW';
+function sqlite_userfunc_POW($p1,$p2){
+ return pow($p1,$p2);
+}
+
+var $define_RADIANS='sqlite_userfunc_RADIANS';
+function sqlite_userfunc_RADIANS($p1){
+ return ($p1/180)*pi;
+}
+
+var $define_RAND='sqlite_userfunc_RAND';
+function sqlite_userfunc_RAND($p1=null){
+ if ($p1) srand($p1);
+ return rand(0,1073741823)/1073741824;
+}
+
+var $define_SIGN='sqlite_userfunc_SIGN';
+function sqlite_userfunc_SIGN($p1){
+ if ($p1>0) return 1;
+ else if ($p1<0) return -1;
+ return 0;
+}
+
+var $define_SIN='sin';
+var $define_SQRT='sqrt';
+var $define_TAN='tan';
+
+var $define_TRUNCATE='sqlite_userfunc_TRUNCATE';
+function sqlite_userfunc_TRUNCATE($p1,$p2){
+ $p2=pow(10,$p2);
+ return ((int)($p1*$p2))/$p2;
+}
+
+var $define_FORMAT='sqlite_userfunc_FORMAT';
+function sqlite_userfunc_FORMAT($p1,$p2){
+ return number_format($p1, $p2, '.', ',');
+}
+
+var $define_INET_ATON='sqlite_userfunc_INET_ATON';
+function sqlite_userfunc_INET_ATON($p1){
+ $a=explode('.',$p1);
+ return (($a[0]*256+$a[1])*256+$a[2])*256+$a[3];
+}
+
+var $define_INET_NTOA='sqlite_userfunc_INET_NTOA';
+function sqlite_userfunc_INET_NTOA($p1){
+ $a=array();
+ for ($i=0;$i<4;$i++){
+ $a[$i]=(string)($p1 % 256);
+ $p1=(int)($p1/256);
+ }
+ return $a[3].'.'.$a[2].'.'.$a[1].'.'.$a[0];
+}
+
+var $define_MD5='md5';
+
+
+var $define_CURDATE='sqlite_userfunc_CURDATE';
+var $define_CURRENT_DATE='sqlite_userfunc_CURDATE';
+function sqlite_userfunc_CURDATE(){
+ return date('Y-m-d');
+}
+
+var $define_CURTIME='sqlite_userfunc_CURTIME';
+var $define_CURRENT_TIME='sqlite_userfunc_CURTIME';
+function sqlite_userfunc_CURTIME(){
+ return date('H:i:s');
+}
+
+var $define_CURRENT_TIMESTAMP='sqlite_userfunc_NOW';
+var $define_LOCALTIME='sqlite_userfunc_NOW';
+var $define_LOCALTIMESTAMP='sqlite_userfunc_NOW';
+var $define_SYSDATE='sqlite_userfunc_NOW';
+function sqlite_userfunc_NOW(){
+ return date('Y-m-d H:i:s');
+}
+
+var $define_DATE_FORMAT='sqlite_userfunc_DATE_FORMAT';
+var $define_TIME_FORMAT='sqlite_userfunc_DATE_FORMAT';
+function sqlite_userfunc_DATE_FORMAT($p1,$p2){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ $func='if ($matches=="%") return "%";';
+ $func='return date($matches,'.$t.');';
+ return preg_replace_callback ('/%([%a-zA-Z])/',create_function('$matches',$func), $p2);
+}
+
+var $define_DAYNAME='sqlite_userfunc_DAYNAME';
+function sqlite_userfunc_DAYNAME($p1){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return date('l',$t);
+}
+
+var $define_DAYOFWEEK='sqlite_userfunc_DAYOFWEEK';
+function sqlite_userfunc_DAYOFWEEK($p1){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return date('w',$t)+1;
+}
+
+var $define_DAYOFYEAR='sqlite_userfunc_DAYOFYEAR';
+function sqlite_userfunc_DAYOFYEAR($p1){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return date('z',$t);
+}
+
+var $define_EXTRACT='sqlite_userfunc_EXTRACT';
+function sqlite_userfunc_EXTRACT($p1,$p2){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p2,$yr,$mt,$dy,$hr,$mn,$sc);
+ switch(strtoupper($p1)) {
+ case'SECOND': // SECONDS
+ return $sc;
+ case'MINUTE': // MINUTES
+ return $m;
+ case'HOUR': // HOURS
+ return $hr;
+ case'MONTH': // MONTHS
+ return $mt;
+ case'YEAR': // YEARS
+ return $y;
+ case'MINUTE_SECOND': // 'MINUTES:SECONDS'
+ return date('is',$t);
+ case'HOUR_MINUTE': // 'HOURS:MINUTES'
+ return date('Hi',$t);
+ case'DAY_HOUR': // 'DAYS HOURS'
+ return date('dH',$t);
+ case'YEAR_MONTH': // 'YEARS-MONTHS'
+ return date('Ym',$t);
+ case'HOUR_SECOND': // 'HOURS:MINUTES:SECONDS'
+ return date('Hs',$t);
+ case'DAY_MINUTE': // 'DAYS HOURS:MINUTES'
+ return date('di',$t);
+ case'DAY_SECOND': // 'DAYS HOURS:MINUTES:SECONDS'
+ return date('ds',$t);
+ case'DAY': // DAYS
+ default:
+ return $dy;
+ }
+}
+
+var $define_FROM_DAYS='sqlite_userfunc_FROM_DAYS';
+function sqlite_userfunc_FROM_DAYS($p1){
+ return date('Y-m-d',($p1-719528)*86400);
+}
+
+var $define_FROM_UNIXTIME='sqlite_userfunc_FROM_UNIXTIME';
+function sqlite_userfunc_FROM_UNIXTIME($p1,$p2=null){
+ if ($p2) return sqlite_userfunc_DATE_FORMAT($p1,$p2);
+ return date('Y-m-d H:i:s',$p1);
+}
+
+var $define_HOUR='sqlite_userfunc_HOUR';
+function sqlite_userfunc_HOUR($p1){
+ SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return $hr;
+}
+
+var $define_MINUTE='sqlite_userfunc_MINUTE';
+function sqlite_userfunc_MINUTE($p1){
+ SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return $mn;
+}
+
+var $define_MONTHNAME='sqlite_userfunc_MONTHNAME';
+function sqlite_userfunc_MONTHNAME($p1){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return date('F',$t);
+}
+
+
+var $define_PERIOD_ADD='sqlite_userfunc_PERIOD_ADD';
+function sqlite_userfunc_PERIOD_ADD($p1,$p2){
+ $y=(int)($p1/100);
+ $m=$p1-$y*100;
+ $t=mktime(0,0,0,$m+$p2,1,$y, -1);
+ return date('Ym',$t);
+}
+
+var $define_PERIOD_DIFF='sqlite_userfunc_PERIOD_DIFF';
+function sqlite_userfunc_PERIOD_DIFF($p1,$p2){
+ $y1=(int)($p1/100);
+ $m1=$p1-$y1*100;
+ $y2=(int)($p2/100);
+ $m2=$p1-$y2*100;
+ $t1=mktime(0,0,0,$m1,1,$y1, -1);
+ $t2=mktime(0,0,0,$m2,1,$y2, -1);
+ $y1=date('Y',$t1);
+ $y2=date('Y',$t2);
+ return (int)(mktime(0,0,0,$m1-$m2,1,1970+$y1-$y2, -1)/60/60/24/28);
+}
+
+var $define_QUARTER='sqlite_userfunc_QUARTER';
+function sqlite_userfunc_QUARTER($p1){
+ SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ switch($mt){
+ case 1: case 2: case 3: return 1;
+ case 4: case 5: case 6: return 2;
+ case 7: case 8: case 9: return 3;
+ default: return 4;
+ }
+}
+
+var $define_SECOND='sqlite_userfunc_SECOND';
+function sqlite_userfunc_SECOND($p1){
+ SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return $sc;
+}
+
+var $define_SEC_TO_TIME='sqlite_userfunc_SEC_TO_TIME';
+function sqlite_userfunc_SEC_TO_TIME($p1){
+ return date('H:i:s',$p1);
+}
+
+var $define_WEEK='sqlite_userfunc_WEEK';
+function sqlite_userfunc_WEEK($p1){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return date('W',$t);
+}
+
+var $define_WEEKDAY='sqlite_userfunc_WEEKDAY';
+function sqlite_userfunc_WEEKDAY($p1){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ if (0<($w=date('w',$t))) return $w-1;
+ return 6;
+}
+
+var $define_YEAR='sqlite_userfunc_YEAR';
+function sqlite_userfunc_YEAR($p1){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return date('Y',$t);
+}
+
+var $define_YEARWEEK='sqlite_userfunc_YEARWEEK';
+function sqlite_userfunc_YEARWEEK($p1){
+ $t=SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return date('YW',$t);
+}
+
+
+var $define_FIND_IN_SET='sqlite_userfunc_FIND_IN_SET';
+function sqlite_userfunc_FIND_IN_SET($p1,$p2){
+ if ($p1==null && $p2==null) return null;
+ if (!$p2) return 0;
+ foreach (explode(',',$p2) as $key=>$value) if ($value==$p1) return ($key+1);
+ return 0;
+}
+
+
+var $define_ADDDATE='sqlite_userfunc_ADDDATE';
+function sqlite_userfunc_ADDDATE($p1,$p2,$p3='DAY'){
+ return date("Y-m-d",sqlite_ADDDATE($p1,$p2,$p3));
+}
+
+var $define_SUBDATE='sqlite_userfunc_SUBDATE';
+function sqlite_userfunc_SUBDATE($p1,$p2,$p3='DAY'){
+ return date("Y-m-d",sqlite_ADDDATE($p1,0-$p2,$p3));
+}
+
+var $define_CONCAT='sqlite_userfunc_CONCAT';
+function sqlite_userfunc_CONCAT(){
+ if (!($lastnum=func_num_args())) return null;
+ $args=&func_get_args();
+ $ret='';
+ for ($i=0;$i<$lastnum;$i++) {
+ if ($args[$i]===null) return null;
+ $ret.=(string)($args[$i]);
+ }
+ return $ret;
+}
+
+var $define_IF='sqlite_userfunc_IF';
+function sqlite_userfunc_IF($p1,$p2,$p3){
+ if ((int)$p1) return $p2;
+ return $p3;
+}
+
+var $define_IFNULL='sqlite_userfunc_IFNULL';
+function sqlite_userfunc_IFNULL($p1,$p2){
+ if ($p1!=null) return $p1;
+ return $p2;
+}
+
+var $define_NULLIF='sqlite_userfunc_NULLIF';
+function sqlite_userfunc_NULLIF($p1,$p2){
+ if ($p1==$p2) return null;
+ return $p1;
+}
+
+
+var $define_match_against='sqlite_userfunc_match_against';
+function sqlite_userfunc_match_against(){
+ if (!($lastnum=func_num_args())) return 0;
+ if (!(--$lastnum)) return 0;
+ $args=&func_get_args();
+ if (!$args[$lastnum]) return 0;
+ $pattern='/'.quotemeta($args[$lastnum]).'/i';
+ $ret=0;
+ for($i=0;$i<$lastnum;$i++) $ret=$ret+preg_match_all ($pattern,$args[$i],$matches);
+ return $ret;
+}
+
+var $define_replace='sqlite_userfunc_replace';
+function sqlite_userfunc_replace($p1,$p2,$p3){
+ return str_replace($p3,$p1,$p2);
+}
+
+var $define_UNIX_TIMESTAMP='sqlite_userfunc_UNIX_TIMESTAMP';
+function sqlite_userfunc_UNIX_TIMESTAMP($p1=null){
+ if (!$p1) return time();
+ SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ if ($yr) return mktime($hr,$mn,$sc,$mt,$dy,$yr, -1);
+ return $p1;//TIMESTAMP
+}
+
+var $define_REGEXP='sqlite_userfunc_REGEXP';
+function sqlite_userfunc_REGEXP($p1,$p2){
+ return preg_match ("/$p2/",$p1);
+}
+
+var $define_DAYOFMONTH='sqlite_userfunc_DAYOFMONTH';
+function sqlite_userfunc_DAYOFMONTH($p1){
+ SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return $dy;
+}
+
+var $define_MONTH='sqlite_userfunc_MONTH';
+function sqlite_userfunc_MONTH($p1){
+ SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ return $mt;
+}
+
+
+function sqlite_resolvedatetime($p1,&$yr,&$mt,&$dy,&$hr,&$mn,&$sc){
+ $t=trim($p1);
+ if (preg_match('/^([0-9]{4})-([0-9]{2})-([0-9]{2}) ([0-9]{2}):([0-9]{2}):([0-9]{2})$/', $t,$matches)) {
+ //DATETIME
+ $yr=(int)$matches[1];
+ $mt=(int)$matches[2];
+ $dy=(int)$matches[3];
+ $hr=(int)$matches[4];
+ $mn=(int)$matches[5];
+ $sc=(int)$matches[6];
+ } else if (preg_match('/^([0-9]{4})-([0-9]{2})-([0-9]{2})$/', $t,$matches)) {
+ //DATE
+ $yr=(int)$matches[1];
+ $mt=(int)$matches[2];
+ $dy=(int)$matches[3];
+ $hr=$mn=$sc=0;
+ } else if (preg_match('/^([0-9]{4})([0-9]{2})([0-9]{2})$/', $t,$matches)) {
+ //YYYYMMDD
+ $yr=(int)$matches[1];
+ $mt=(int)$matches[2];
+ $dy=(int)$matches[3];
+ $hr=$mn=$sc=0;
+ } else if (preg_match('/^([0-9]{2})([0-9]{2})([0-9]{2})$/', $t,$matches)) {
+ //YYMMDD
+ $yr=(int)$matches[1];
+ $mt=(int)$matches[2];
+ $dy=(int)$matches[3];
+ $hr=$mn=$sc=0;
+ if ($yr<70) $yr=$yr+2000;
+ else $yr=$yr+1900;
+ }
+ return mktime($hr,$mn,$sc,$mt,$dy,$yr, -1);
+}
+
+function sqlite_ADDDATE($p1,$p2,$p3){
+ SQLite_Functions::sqlite_resolvedatetime($p1,$yr,$mt,$dy,$hr,$mn,$sc);
+ $a=explode(' ',preg_replace('/[^0-9]/',' ',trim((string)$p2)));
+ switch(strtoupper($p3)) {
+ case'SECOND': // SECONDS
+ $sc += (int)$p2;
+ break;
+ case'MINUTE': // MINUTES
+ $mn += (int)$p2;
+ break;
+ case'HOUR': // HOURS
+ $hr += (int)$p2;
+ break;
+ case'MONTH': // MONTHS
+ $mt += (int)$p2;
+ break;
+ case'YEAR': // YEARS
+ $yr += (int)$p2;
+ break;
+ case'MINUTE_SECOND': // 'MINUTES:SECONDS'
+ $mn += (int)$a[0];
+ $sc += (int)$a[1];
+ break;
+ case'HOUR_MINUTE': // 'HOURS:MINUTES'
+ $hr += (int)$a[0];
+ $mn += (int)$a[1];
+ break;
+ case'DAY_HOUR': // 'DAYS HOURS'
+ $dy += (int)$a[0];
+ $hr += (int)$a[1];
+ break;
+ case'YEAR_MONTH': // 'YEARS-MONTHS'
+ $yr += (int)$a[0];
+ $mt += (int)$a[1];
+ break;
+ case'HOUR_SECOND': // 'HOURS:MINUTES:SECONDS'
+ $hr += (int)$a[0];
+ $mn += (int)$a[1];
+ $sc += (int)$a[2];
+ break;
+ case'DAY_MINUTE': // 'DAYS HOURS:MINUTES'
+ $dy += (int)$a[0];
+ $hr += (int)$a[1];
+ $mn += (int)$a[2];
+ break;
+ case'DAY_SECOND': // 'DAYS HOURS:MINUTES:SECONDS'
+ $dy += (int)$a[0];
+ $hr += (int)$a[1];
+ $mn += (int)$a[2];
+ $sc += (int)$a[3];
+ break;
+ case'DAY': // DAYS
+ default:
+ $dy += (int)$p2;
+ break;
+ }
+ return mktime($hr,$mn,$sc,$mt,$dy,$yr, -1);
+}
+
+// For creating table structure (table and index/indeces)
+var $define_sqlite_table_structure='sqlite_userfunc_sqlite_table_structure';
+function sqlite_userfunc_sqlite_table_structure($p1){
+ global $SQLITE_DBHANDLE;
+ $ret='';
+ if ($res=sqlite_query($SQLITE_DBHANDLE,"SELECT sql FROM sqlite_master WHERE tbl_name='$p1'")) {
+ while ($array=sqlite_fetch_array($res,SQLITE_NUM)) $ret.=$array[0].";\n";
+ }
+ return $ret;
+}
+
+
+// Modification of query for some functions.
+function sqlite_modifyQueryForUserFunc(&$query,$strpositions,$pattern=null,$replacement=null){
+ // Write this part very carefully. Otherwise, you may allow crackers to do SQL-injection.
+ global $SQLITE_MQFUFCB_OK,$SQLITE_MQFUFCB_COUNT,$SQLITE_MQFUFCB_REPLACE;
+
+ // Store the previous string
+ $orgstrings=array();
+ foreach ($strpositions as $start => $end) array_push($orgstrings, trim(substr($query,$start,$end-$start)));
+
+ $lquery=strtolower($query);
+ if (!$pattern) $pattern=array();
+ if (!$replacement) $replacement=array();
+
+ // match() against() support. Following way does NOT accept SQL-injection. Note that the string is always quoted by "'".
+ array_push($pattern,'/match \(([^\']*?)\) against \(/i');
+ array_push($replacement,'match_against ($1,');
+ // REGEXP support
+ if (strpos($lquery,'regexp')!==false) {
+ array_push($pattern,'/([^a-z_\.])([a-z_\.]+)[\s]+REGEXP[\s]+\'([^\']*?)\'([^\']?)/i');
+ array_push($replacement,'$1regexp($2,\'$3\')$4');
+ }
+ // ADDDATE/SUBDATE support (INTERVAL support)
+ array_push($pattern,'/([^a-zA-Z_])ADDDATE[\s]*?\(([^,]+),[\s]*?INTERVAL[\s]+([\S]+)[\s]+([^\)]+)\)/i');
+ array_push($replacement,'$1adddate($2,$3,\'$4\')');
+ array_push($pattern,'/([^a-zA-Z_])DATE_ADD[\s]*?\(([^,]+),[\s]*?INTERVAL[\s]+([\S]+)[\s]+([^\)]+)\)/i');
+ array_push($replacement,'$1adddate($2,$3,\'$4\')');
+ array_push($pattern,'/([^a-zA-Z_])SUBDATE[\s]*?\(([^,]+),[\s]*?INTERVAL[\s]+([\S]+)[\s]+([^\)]+)\)/i');
+ array_push($replacement,'$1subdate($2,$3,\'$4\')');
+ array_push($pattern,'/([^a-zA-Z_])DATE_SUB[\s]*?\(([^,]+),[\s]*?INTERVAL[\s]+([\S]+)[\s]+([^\)]+)\)/i');
+ array_push($replacement,'$1subdate($2,$3,\'$4\')');
+
+ // EXTRACT support
+ array_push($pattern,'/([^a-zA-Z_])EXTRACT[\s]*?\(([a-zA-Z_]+)[\s]+FROM/i');
+ array_push($replacement,'$1extract(\'$2\',');
+
+ // TRIM support:
+ array_push($pattern,'/([^a-zA-Z_])TRIM[\s]*?\((BOTH|LEADING|TRAILING)[\s]+FROM/i');
+ array_push($replacement,'$1extract(\'$2\',\' \',');
+ array_push($pattern,'/([^a-zA-Z_])TRIM[\s]*?\((BOTH|LEADING|TRAILING)[\s]+([\s\S]+)[\s]+FROM/i');
+ array_push($replacement,'$1extract(\'$2\',$3,');
+
+ // Change it.
+ $temp=preg_replace ($pattern,$replacement,$query);
+
+ // Comfirm if strings did not change.
+ $ok=true;
+ foreach ($orgstrings as $key=>$value) if ($value) {
+ if (strpos($temp,$value)!==false) {
+ // This string is OK, therefore will be ignored in the next "step by step" step.
+ $orgstrings[$key]='';
+ continue;
+ }
+ $ok=false;
+ }
+ if ($ok) { // return if everything is OK.
+ $query=$temp;
+ return;
+ }
+
+ // At least one of string changed. Need to do step by step.
+ foreach ($pattern as $key=>$pat) {
+ // Replace is done step by step for each RegExp replace statement.
+ $SQLITE_MQFUFCB_REPLACE=$replace[$key];// Set the grobal var.
+ $num=preg_match_all($pat,$query,$matches);
+ // First, check if OK.
+ $replaceOK=array();
+ for ($i=1;$i<=$num;$i++) {
+ $SQLITE_MQFUFCB_OK=array();
+ $SQLITE_MQFUFCB_OK[$i]=true; // Set the grobal var.
+ $SQLITE_MQFUFCB_COUNT=0; // Set the grobal var.
+ // Only $i-st replacement will be done in the next line.
+ $temp=preg_replace_callback($pat,array('SQLite_Functions','sqlite_modifyQueryForUserFuncCallBack'), $query, $i);
+ $ok=true;
+ foreach ($orgstrings as $value) if ($value) {
+ if (strpos($temp,$value)!==false) continue;
+ $ok=false;
+ break;
+ }
+ if ($ok) $replaceOK[$i]=true;
+ }
+ // Replace
+ $SQLITE_MQFUFCB_OK=$replaceOK;// Copy the OK array
+ $SQLITE_MQFUFCB_COUNT=0;
+ $query=preg_replace_callback($pat,array('SQLite_Functions','sqlite_modifyQueryForUserFuncCallBack'), $query);
+ }
+}
+
+function sqlite_modifyQueryForUserFuncCallBack($mathces){
+ global $SQLITE_MQFUFCB_OK,$SQLITE_MQFUFCB_COUNT,$SQLITE_MQFUFCB_REPLACE;
+ if ($SQLITE_MQFUFCB_OK[++$SQLITE_MQFUFCB_COUNT]) return $SQLITE_MQFUFCB_REPLACE;
+ else return $mathces[0];
+}
+
+}//class SQLite_QueryFunctions
+
+?>
\ No newline at end of file
OSDN Git Service
