Patrick
/
license-vpn
Seguir 1
Destacar 0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
VPN licensing server
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
1 Commit
1 Rama
94KB
Árbol: 7470eddf83
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde '7470eddf83'
${ noResults }
license-vpn/vendor/sergeytsalkov/meekrodb/db.class.php

1010 líneas
38KB
Original Blame Histórico 

  1. <?php

  2. /*

  3.     Copyright (C) 2008 Sergey Tsalkov (stsalkov@gmail.com)

  4. 

  5.     This program is free software: you can redistribute it and/or modify

  6.     it under the terms of the GNU Lesser General Public License as published by

  7.     the Free Software Foundation, either version 3 of the License, or

  8.     (at your option) any later version.

  9. 

  10.     This program is distributed in the hope that it will be useful,

  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.     GNU Lesser General Public License for more details.

  14. 

  15.     You should have received a copy of the GNU Lesser General Public License

  16.     along with this program.  If not, see <http://www.gnu.org/licenses/>.

  17. */

  18. 

  19. 

  20. class DB {

  21.   // initial connection

  22.   public static $dbName = '';

  23.   public static $user = '';

  24.   public static $password = '';

  25.   public static $host = 'localhost';

  26.   public static $port = 3306; //hhvm complains if this is null

  27.   public static $socket = null;

  28.   public static $encoding = 'latin1';

  29.   

  30.   // configure workings

  31.   public static $param_char = '%';

  32.   public static $named_param_seperator = '_';

  33.   public static $success_handler = false;

  34.   public static $error_handler = true;

  35.   public static $throw_exception_on_error = false;

  36.   public static $nonsql_error_handler = null;

  37.   public static $pre_sql_handler = false;

  38.   public static $throw_exception_on_nonsql_error = false;

  39.   public static $nested_transactions = false;

  40.   public static $usenull = true;

  41.   public static $ssl = array('key' => '', 'cert' => '', 'ca_cert' => '', 'ca_path' => '', 'cipher' => '');

  42.   public static $connect_options = array(MYSQLI_OPT_CONNECT_TIMEOUT => 30);

  43.   

  44.   // internal

  45.   protected static $mdb = null;

  46.   public static $variables_to_sync = array('param_char', 'named_param_seperator', 'success_handler', 'error_handler', 'throw_exception_on_error',

  47.     'nonsql_error_handler', 'pre_sql_handler', 'throw_exception_on_nonsql_error', 'nested_transactions', 'usenull', 'ssl', 'connect_options');

  48.   

  49.   public static function getMDB() {

  50.     $mdb = DB::$mdb;

  51.     

  52.     if ($mdb === null) {

  53.       $mdb = DB::$mdb = new MeekroDB();

  54.     }

  55. 

  56.     // Sync everytime because settings might have changed. It's fast.

  57.     $mdb->sync_config(); 

  58.     

  59.     return $mdb;

  60.   }

  61.   

  62.   // yes, this is ugly. __callStatic() only works in 5.3+

  63.   public static function get() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'get'), $args); }

  64.   public static function disconnect() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'disconnect'), $args); }

  65.   public static function query() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'query'), $args); }

  66.   public static function queryFirstRow() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstRow'), $args); }

  67.   public static function queryOneRow() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneRow'), $args); }

  68.   public static function queryAllLists() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryAllLists'), $args); }

  69.   public static function queryFullColumns() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFullColumns'), $args); }

  70.   public static function queryFirstList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstList'), $args); }

  71.   public static function queryOneList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneList'), $args); }

  72.   public static function queryFirstColumn() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstColumn'), $args); }

  73.   public static function queryOneColumn() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneColumn'), $args); }

  74.   public static function queryFirstField() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstField'), $args); }

  75.   public static function queryOneField() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneField'), $args); }

  76.   public static function queryRaw() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryRaw'), $args); }

  77.   public static function queryRawUnbuf() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryRawUnbuf'), $args); }

  78.   

  79.   public static function insert() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insert'), $args); }

  80.   public static function insertIgnore() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertIgnore'), $args); }

  81.   public static function insertUpdate() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertUpdate'), $args); }

  82.   public static function replace() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'replace'), $args); }

  83.   public static function update() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'update'), $args); }

  84.   public static function delete() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'delete'), $args); }

  85.   

  86.   public static function insertId() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertId'), $args); }

  87.   public static function count() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'count'), $args); }

  88.   public static function affectedRows() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'affectedRows'), $args); }

  89.   

  90.   public static function useDB() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'useDB'), $args); }

  91.   public static function startTransaction() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'startTransaction'), $args); }

  92.   public static function commit() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'commit'), $args); }

  93.   public static function rollback() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'rollback'), $args); }

  94.   public static function tableList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'tableList'), $args); }

  95.   public static function columnList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'columnList'), $args); }

  96.   

  97.   public static function sqlEval() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'sqlEval'), $args); }

  98.   public static function nonSQLError() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'nonSQLError'), $args); }

  99.   

  100.   public static function serverVersion() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'serverVersion'), $args); }

  101.   public static function transactionDepth() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'transactionDepth'), $args); }

  102.   

  103.   

  104.   public static function debugMode($handler = true) { 

  105.     DB::$success_handler = $handler;

  106.   }

  107.   

  108. }

  109. 

  110. 

  111. class MeekroDB {

  112.   // initial connection

  113.   public $dbName = '';

  114.   public $user = '';

  115.   public $password = '';

  116.   public $host = 'localhost';

  117.   public $port = 3306;

  118.   public $socket = null;

  119.   public $encoding = 'latin1';

  120.   

  121.   // configure workings

  122.   public $param_char = '%';

  123.   public $named_param_seperator = '_';

  124.   public $success_handler = false;

  125.   public $error_handler = true;

  126.   public $throw_exception_on_error = false;

  127.   public $nonsql_error_handler = null;

  128.   public $pre_sql_handler = false;

  129.   public $throw_exception_on_nonsql_error = false;

  130.   public $nested_transactions = false;

  131.   public $usenull = true;

  132.   public $ssl = array('key' => '', 'cert' => '', 'ca_cert' => '', 'ca_path' => '', 'cipher' => '');

  133.   public $connect_options = array(MYSQLI_OPT_CONNECT_TIMEOUT => 30);

  134.   

  135.   // internal

  136.   public $internal_mysql = null;

  137.   public $server_info = null;

  138.   public $insert_id = 0;

  139.   public $num_rows = 0;

  140.   public $affected_rows = 0;

  141.   public $current_db = null;

  142.   public $nested_transactions_count = 0;

  143.   

  144.   

  145.   public function __construct($host=null, $user=null, $password=null, $dbName=null, $port=null, $encoding=null, $socket=null)  {

  146.     if ($host === null) $host = DB::$host;

  147.     if ($user === null) $user = DB::$user;

  148.     if ($password === null) $password = DB::$password;

  149.     if ($dbName === null) $dbName = DB::$dbName;

  150.     if ($port === null) $port = DB::$port;

  151.     if ($socket === null) $socket = DB::$socket;

  152.     if ($encoding === null) $encoding = DB::$encoding;

  153.     

  154.     $this->host = $host;

  155.     $this->user = $user;

  156.     $this->password = $password;

  157.     $this->dbName = $dbName;

  158.     $this->port = $port;

  159.     $this->socket = $socket;

  160.     $this->encoding = $encoding;

  161. 

  162.     $this->sync_config();

  163.   }

  164. 

  165.   // suck in config settings from static class

  166.   public function sync_config() {

  167.     foreach (DB::$variables_to_sync as $variable) {

  168.       if ($this->$variable !== DB::$$variable) {

  169.         $this->$variable = DB::$$variable;

  170.       }

  171.     }

  172.   }

  173.   

  174.   public function get() {

  175.     $mysql = $this->internal_mysql;

  176.     

  177.     if (!($mysql instanceof MySQLi)) {

  178.       if (! $this->port) $this->port = ini_get('mysqli.default_port');

  179.       $this->current_db = $this->dbName;

  180.       $mysql = new mysqli();

  181. 

  182.       $connect_flags = 0;

  183.       if ($this->ssl['key']) {

  184.         $mysql->ssl_set($this->ssl['key'], $this->ssl['cert'], $this->ssl['ca_cert'], $this->ssl['ca_path'], $this->ssl['cipher']);

  185.         $connect_flags |= MYSQLI_CLIENT_SSL;

  186.       } 

  187.       foreach ($this->connect_options as $key => $value) {

  188.         $mysql->options($key, $value);

  189.       }

  190. 

  191.       // suppress warnings, since we will check connect_error anyway

  192.       @$mysql->real_connect($this->host, $this->user, $this->password, $this->dbName, $this->port, $this->socket, $connect_flags);

  193.       

  194.       if ($mysql->connect_error) {

  195.         return $this->nonSQLError('Unable to connect to MySQL server! Error: ' . $mysql->connect_error);

  196.       }

  197.       

  198.       $mysql->set_charset($this->encoding);

  199.       $this->internal_mysql = $mysql;

  200.       $this->server_info = $mysql->server_info;

  201.     }

  202.     

  203.     return $mysql;

  204.   }

  205.   

  206.   public function disconnect() {

  207.     $mysqli = $this->internal_mysql;

  208.     if ($mysqli instanceof MySQLi) {

  209.       if ($thread_id = $mysqli->thread_id) $mysqli->kill($thread_id); 

  210.       $mysqli->close();

  211.     }

  212.     $this->internal_mysql = null; 

  213.   }

  214.   

  215.   public function nonSQLError($message) {

  216.     if ($this->throw_exception_on_nonsql_error) {

  217.       $e = new MeekroDBException($message);

  218.       throw $e;

  219.     }

  220.     

  221.     $error_handler = is_callable($this->nonsql_error_handler) ? $this->nonsql_error_handler : 'meekrodb_error_handler';

  222.         

  223.     call_user_func($error_handler, array(

  224.       'type' => 'nonsql',

  225.       'error' => $message

  226.     ));

  227.   }

  228.   

  229.   public function debugMode($handler = true) {

  230.     $this->success_handler = $handler;

  231.   }

  232.   

  233.   public function serverVersion() { $this->get(); return $this->server_info; }

  234.   public function transactionDepth() { return $this->nested_transactions_count; }

  235.   public function insertId() { return $this->insert_id; }

  236.   public function affectedRows() { return $this->affected_rows; }

  237.   public function count() { $args = func_get_args(); return call_user_func_array(array($this, 'numRows'), $args); }

  238.   public function numRows() { return $this->num_rows; }

  239.   

  240.   public function useDB() { $args = func_get_args(); return call_user_func_array(array($this, 'setDB'), $args); }

  241.   public function setDB($dbName) {

  242.     $db = $this->get();

  243.     if (! $db->select_db($dbName)) return $this->nonSQLError("Unable to set database to $dbName");

  244.     $this->current_db = $dbName;

  245.   }

  246.   

  247.   

  248.   public function startTransaction() {

  249.     if ($this->nested_transactions && $this->serverVersion() < '5.5') {

  250.       return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion());

  251.     }

  252.     

  253.     if (!$this->nested_transactions || $this->nested_transactions_count == 0) {

  254.       $this->query('START TRANSACTION');

  255.       $this->nested_transactions_count = 1;

  256.     } else {

  257.       $this->query("SAVEPOINT LEVEL{$this->nested_transactions_count}");

  258.       $this->nested_transactions_count++;

  259.     }

  260.     

  261.     return $this->nested_transactions_count;

  262.   }

  263.   

  264.   public function commit($all=false) {

  265.     if ($this->nested_transactions && $this->serverVersion() < '5.5') {

  266.       return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion());

  267.     }

  268.     

  269.     if ($this->nested_transactions && $this->nested_transactions_count > 0)

  270.       $this->nested_transactions_count--;

  271.     

  272.     if (!$this->nested_transactions || $all || $this->nested_transactions_count == 0) {

  273.       $this->nested_transactions_count = 0;

  274.       $this->query('COMMIT');

  275.     } else {

  276.       $this->query("RELEASE SAVEPOINT LEVEL{$this->nested_transactions_count}");

  277.     }

  278.     

  279.     return $this->nested_transactions_count;

  280.   }

  281.   

  282.   public function rollback($all=false) {

  283.     if ($this->nested_transactions && $this->serverVersion() < '5.5') {

  284.       return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion());

  285.     }

  286.     

  287.     if ($this->nested_transactions && $this->nested_transactions_count > 0)

  288.       $this->nested_transactions_count--;

  289.     

  290.     if (!$this->nested_transactions || $all || $this->nested_transactions_count == 0) {

  291.       $this->nested_transactions_count = 0;

  292.       $this->query('ROLLBACK');

  293.     } else {

  294.       $this->query("ROLLBACK TO SAVEPOINT LEVEL{$this->nested_transactions_count}");

  295.     }

  296.     

  297.     return $this->nested_transactions_count;

  298.   }

  299.   

  300.   protected function formatTableName($table) {

  301.     $table = trim($table, '`');

  302.     

  303.     if (strpos($table, '.')) return implode('.', array_map(array($this, 'formatTableName'), explode('.', $table)));

  304.     else return '`' . str_replace('`', '``', $table) . '`'; 

  305.   }

  306.   

  307.   public function update() {

  308.     $args = func_get_args();

  309.     $table = array_shift($args);

  310.     $params = array_shift($args);

  311. 

  312.     $update_part = $this->parseQueryParams(

  313.       str_replace('%', $this->param_char, "UPDATE %b SET %hc"),

  314.       $table, $params

  315.     );

  316. 

  317.     $where_part = call_user_func_array(array($this, 'parseQueryParams'), $args);

  318.     $query = $update_part . ' WHERE ' . $where_part;

  319.     return $this->query($query);

  320.   }

  321.   

  322.   public function insertOrReplace($which, $table, $datas, $options=array()) {

  323.     $datas = unserialize(serialize($datas)); // break references within array

  324.     $keys = $values = array();

  325.     

  326.     if (isset($datas[0]) && is_array($datas[0])) {

  327.       $var = '%ll?';

  328.       foreach ($datas as $datum) {

  329.         ksort($datum);

  330.         if (! $keys) $keys = array_keys($datum);

  331.         $values[] = array_values($datum);  

  332.       }

  333.       

  334.     } else {

  335.       $var = '%l?';

  336.       $keys = array_keys($datas);

  337.       $values = array_values($datas);

  338.     }

  339. 

  340.     if ($which != 'INSERT' && $which != 'INSERT IGNORE' && $which != 'REPLACE') {

  341.       return $this->nonSQLError('insertOrReplace() must be called with one of: INSERT, INSERT IGNORE, REPLACE');

  342.     }

  343.     

  344.     if (isset($options['update']) && is_array($options['update']) && $options['update'] && $which == 'INSERT') {

  345.       if (array_values($options['update']) !== $options['update']) {

  346.         return $this->query(

  347.           str_replace('%', $this->param_char, "INSERT INTO %b %lb VALUES $var ON DUPLICATE KEY UPDATE %hc"), 

  348.           $table, $keys, $values, $options['update']);

  349.       } else {

  350.         $update_str = array_shift($options['update']);

  351.         $query_param = array(

  352.           str_replace('%', $this->param_char, "INSERT INTO %b %lb VALUES $var ON DUPLICATE KEY UPDATE ") . $update_str, 

  353.           $table, $keys, $values);

  354.         $query_param = array_merge($query_param, $options['update']);

  355.         return call_user_func_array(array($this, 'query'), $query_param);

  356.       }

  357.       

  358.     } 

  359.     

  360.     return $this->query(

  361.       str_replace('%', $this->param_char, "%l INTO %b %lb VALUES $var"), 

  362.       $which, $table, $keys, $values);

  363.   }

  364.   

  365.   public function insert($table, $data) { return $this->insertOrReplace('INSERT', $table, $data); }

  366.   public function insertIgnore($table, $data) { return $this->insertOrReplace('INSERT IGNORE', $table, $data); }

  367.   public function replace($table, $data) { return $this->insertOrReplace('REPLACE', $table, $data); }

  368.   

  369.   public function insertUpdate() {

  370.     $args = func_get_args();

  371.     $table = array_shift($args);

  372.     $data = array_shift($args);

  373.     

  374.     if (! isset($args[0])) { // update will have all the data of the insert

  375.       if (isset($data[0]) && is_array($data[0])) { //multiple insert rows specified -- failing!

  376.         return $this->nonSQLError("Badly formatted insertUpdate() query -- you didn't specify the update component!");

  377.       }

  378.       

  379.       $args[0] = $data;

  380.     }

  381.     

  382.     if (is_array($args[0])) $update = $args[0];

  383.     else $update = $args;

  384.     

  385.     return $this->insertOrReplace('INSERT', $table, $data, array('update' => $update)); 

  386.   }

  387.   

  388.   public function delete() {

  389.     $args = func_get_args();

  390.     $table = $this->formatTableName(array_shift($args));

  391. 

  392.     $where = call_user_func_array(array($this, 'parseQueryParams'), $args);

  393.     $query = "DELETE FROM {$table} WHERE {$where}";

  394.     return $this->query($query);

  395.   }

  396.   

  397.   public function sqleval() {

  398.     $args = func_get_args();

  399.     $text = call_user_func_array(array($this, 'parseQueryParams'), $args);

  400.     return new MeekroDBEval($text);

  401.   }

  402.   

  403.   public function columnList($table) {

  404.     return $this->queryOneColumn('Field', "SHOW COLUMNS FROM %b", $table);

  405.   }

  406.   

  407.   public function tableList($db = null) {

  408.     if ($db) {

  409.       $olddb = $this->current_db;

  410.       $this->useDB($db);

  411.     }

  412. 

  413.     $result = $this->queryFirstColumn('SHOW TABLES');

  414.     if (isset($olddb)) $this->useDB($olddb);

  415.     return $result;

  416.   }

  417.   

  418.   protected function preparseQueryParams() {

  419.     $args = func_get_args();

  420.     $sql = trim(strval(array_shift($args)));

  421.     $args_all = $args;

  422.     

  423.     if (count($args_all) == 0) return array($sql);

  424.       

  425.     $param_char_length = strlen($this->param_char);

  426.     $named_seperator_length = strlen($this->named_param_seperator);

  427.     

  428.     $types = array(

  429.       $this->param_char . 'll', // list of literals

  430.       $this->param_char . 'ls', // list of strings

  431.       $this->param_char . 'l',  // literal

  432.       $this->param_char . 'li', // list of integers

  433.       $this->param_char . 'ld', // list of decimals

  434.       $this->param_char . 'lb', // list of backticks

  435.       $this->param_char . 'lt', // list of timestamps

  436.       $this->param_char . 's',  // string

  437.       $this->param_char . 'i',  // integer

  438.       $this->param_char . 'd',  // double / decimal

  439.       $this->param_char . 'b',  // backtick

  440.       $this->param_char . 't',  // timestamp

  441.       $this->param_char . '?',  // infer type

  442.       $this->param_char . 'l?',  // list of inferred types

  443.       $this->param_char . 'll?',  // list of lists of inferred types

  444.       $this->param_char . 'hc',  // hash `key`='value' pairs separated by commas

  445.       $this->param_char . 'ha',  // hash `key`='value' pairs separated by and

  446.       $this->param_char . 'ho',  // hash `key`='value' pairs separated by or

  447.       $this->param_char . 'ss',  // search string (like string, surrounded with %'s)

  448.       $this->param_char . 'ssb', // search string (like, begins with)

  449.       $this->param_char . 'sse', // search string (like, ends with)

  450.     );

  451.     

  452.     // generate list of all MeekroDB variables in our query, and their position

  453.     // in the form "offset => variable", sorted by offsets

  454.     $posList = array();

  455.     foreach ($types as $type) {

  456.       $lastPos = 0;

  457.       while (($pos = strpos($sql, $type, $lastPos)) !== false) {

  458.         $lastPos = $pos + 1;

  459.         if (isset($posList[$pos]) && strlen($posList[$pos]) > strlen($type)) continue;

  460.         $posList[$pos] = $type;

  461.       }

  462.     }

  463.     

  464.     ksort($posList);

  465.     

  466.     // for each MeekroDB variable, substitute it with array(type: i, value: 53) or whatever

  467.     $chunkyQuery = array(); // preparsed query

  468.     $pos_adj = 0; // how much we've added or removed from the original sql string

  469.     foreach ($posList as $pos => $type) {

  470.       $type = substr($type, $param_char_length); // variable, without % in front of it

  471.       $length_type = strlen($type) + $param_char_length; // length of variable w/o %

  472.       

  473.       $new_pos = $pos + $pos_adj; // position of start of variable

  474.       $new_pos_back = $new_pos + $length_type; // position of end of variable

  475.       $arg_number_length = 0; // length of any named or numbered parameter addition

  476.       

  477.       // handle numbered parameters

  478.       if ($arg_number_length = strspn($sql, '0123456789', $new_pos_back)) {

  479.         $arg_number = substr($sql, $new_pos_back, $arg_number_length);

  480.         if (! array_key_exists($arg_number, $args_all)) return $this->nonSQLError("Non existent argument reference (arg $arg_number): $sql");

  481.         

  482.         $arg = $args_all[$arg_number];

  483.         

  484.       // handle named parameters

  485.       } else if (substr($sql, $new_pos_back, $named_seperator_length) == $this->named_param_seperator) {

  486.         $arg_number_length = strspn($sql, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_', 

  487.           $new_pos_back + $named_seperator_length) + $named_seperator_length;

  488.         

  489.         $arg_number = substr($sql, $new_pos_back + $named_seperator_length, $arg_number_length - $named_seperator_length);

  490.         if (count($args_all) != 1 || !is_array($args_all[0])) return $this->nonSQLError("If you use named parameters, the second argument must be an array of parameters");

  491.         if (! array_key_exists($arg_number, $args_all[0])) return $this->nonSQLError("Non existent argument reference (arg $arg_number): $sql");

  492.         

  493.         $arg = $args_all[0][$arg_number];

  494.         

  495.       } else {

  496.         $arg_number = 0;

  497.         $arg = array_shift($args);

  498.       }

  499.       

  500.       if ($new_pos > 0) $chunkyQuery[] = substr($sql, 0, $new_pos);

  501.       

  502.       if (is_object($arg) && ($arg instanceof WhereClause)) {

  503.         list($clause_sql, $clause_args) = $arg->textAndArgs();

  504.         array_unshift($clause_args, $clause_sql); 

  505.         $preparsed_sql = call_user_func_array(array($this, 'preparseQueryParams'), $clause_args);

  506.         $chunkyQuery = array_merge($chunkyQuery, $preparsed_sql);  

  507.       } else {

  508.         $chunkyQuery[] = array('type' => $type, 'value' => $arg);

  509.       }

  510.       

  511.       $sql = substr($sql, $new_pos_back + $arg_number_length);

  512.       $pos_adj -= $new_pos_back + $arg_number_length;

  513.     }

  514.     

  515.     if (strlen($sql) > 0) $chunkyQuery[] = $sql;

  516.     

  517.     return $chunkyQuery;

  518.   }

  519.   

  520.   public function escape($str) { return "'" . $this->get()->real_escape_string(strval($str)) . "'"; }

  521.   

  522.   public function sanitize($value, $type='basic', $hashjoin=', ') {

  523.     if ($type == 'basic') {

  524.       if (is_object($value)) {

  525.         if ($value instanceof MeekroDBEval) return $value->text;

  526.         else if ($value instanceof DateTime) return $this->escape($value->format('Y-m-d H:i:s'));

  527.         else return $this->escape($value); // use __toString() value for objects, when possible

  528.       }

  529.       

  530.       if (is_null($value)) return $this->usenull ? 'NULL' : "''";

  531.       else if (is_bool($value)) return ($value ? 1 : 0);

  532.       else if (is_int($value)) return $value;

  533.       else if (is_float($value)) return $value;

  534.       else if (is_array($value)) return "''";

  535.       else return $this->escape($value);

  536. 

  537.     } else if ($type == 'list') {

  538.       if (is_array($value)) {

  539.         $value = array_values($value);

  540.         return '(' . implode(', ', array_map(array($this, 'sanitize'), $value)) . ')';

  541.       } else {

  542.         return $this->nonSQLError("Expected array parameter, got something different!");

  543.       }

  544.     } else if ($type == 'doublelist') {

  545.       if (is_array($value) && array_values($value) === $value && is_array($value[0])) {

  546.         $cleanvalues = array();

  547.         foreach ($value as $subvalue) {

  548.           $cleanvalues[] = $this->sanitize($subvalue, 'list');

  549.         }

  550.         return implode(', ', $cleanvalues);

  551. 

  552.       } else {

  553.         return $this->nonSQLError("Expected double array parameter, got something different!");

  554.       }

  555.     } else if ($type == 'hash') {

  556.       if (is_array($value)) {

  557.         $pairs = array();

  558.         foreach ($value as $k => $v) {

  559.           $pairs[] = $this->formatTableName($k) . '=' . $this->sanitize($v);

  560.         }

  561.         

  562.         return implode($hashjoin, $pairs);

  563.       } else {

  564.         return $this->nonSQLError("Expected hash (associative array) parameter, got something different!");

  565.       }

  566.     } else {

  567.       return $this->nonSQLError("Invalid type passed to sanitize()!");

  568.     }

  569.     

  570.   }

  571.   

  572.   protected function parseTS($ts) {

  573.     if (is_string($ts)) return date('Y-m-d H:i:s', strtotime($ts));

  574.     else if (is_object($ts) && ($ts instanceof DateTime)) return $ts->format('Y-m-d H:i:s');

  575.   }

  576.   

  577.   protected function intval($var) {

  578.     if (PHP_INT_SIZE == 8) return intval($var);

  579.     return floor(doubleval($var));

  580.   }

  581.   

  582.   public function parseQueryParams() {

  583.     $args = func_get_args();

  584.     $chunkyQuery = call_user_func_array(array($this, 'preparseQueryParams'), $args);

  585.     

  586.     $query = '';

  587.     $array_types = array('ls', 'li', 'ld', 'lb', 'll', 'lt', 'l?', 'll?', 'hc', 'ha', 'ho');

  588.     

  589.     foreach ($chunkyQuery as $chunk) {

  590.       if (is_string($chunk)) {

  591.         $query .= $chunk;

  592.         continue;

  593.       }

  594.       

  595.       $type = $chunk['type'];

  596.       $arg = $chunk['value'];

  597.       $result = '';

  598.       

  599.       $is_array_type = in_array($type, $array_types, true);

  600.       if ($is_array_type && !is_array($arg)) return $this->nonSQLError("Badly formatted SQL query: Expected array, got scalar instead!");

  601.       else if (!$is_array_type && is_array($arg)) $arg = '';

  602.       

  603.       if ($type == 's') $result = $this->escape($arg);

  604.       else if ($type == 'i') $result = $this->intval($arg);

  605.       else if ($type == 'd') $result = doubleval($arg);

  606.       else if ($type == 'b') $result = $this->formatTableName($arg);

  607.       else if ($type == 'l') $result = $arg;

  608.       else if ($type == 'ss') $result = $this->escape("%" . str_replace(array('%', '_'), array('\%', '\_'), $arg) . "%");

  609.       else if ($type == 'ssb') $result = $this->escape(str_replace(array('%', '_'), array('\%', '\_'), $arg) . "%");

  610.       else if ($type == 'sse') $result = $this->escape("%" . str_replace(array('%', '_'), array('\%', '\_'), $arg));

  611.       else if ($type == 't') $result = $this->escape($this->parseTS($arg)); 

  612.       

  613.       else if ($type == 'ls') $result = array_map(array($this, 'escape'), $arg);

  614.       else if ($type == 'li') $result = array_map(array($this, 'intval'), $arg);

  615.       else if ($type == 'ld') $result = array_map('doubleval', $arg);

  616.       else if ($type == 'lb') $result = array_map(array($this, 'formatTableName'), $arg);

  617.       else if ($type == 'll') $result = $arg;

  618.       else if ($type == 'lt') $result = array_map(array($this, 'escape'), array_map(array($this, 'parseTS'), $arg));

  619.       

  620.       else if ($type == '?') $result = $this->sanitize($arg);

  621.       else if ($type == 'l?') $result = $this->sanitize($arg, 'list');

  622.       else if ($type == 'll?') $result = $this->sanitize($arg, 'doublelist');

  623.       else if ($type == 'hc') $result = $this->sanitize($arg, 'hash');

  624.       else if ($type == 'ha') $result = $this->sanitize($arg, 'hash', ' AND ');

  625.       else if ($type == 'ho') $result = $this->sanitize($arg, 'hash', ' OR ');

  626.       

  627.       else return $this->nonSQLError("Badly formatted SQL query: Invalid MeekroDB param $type");

  628.       

  629.       if (is_array($result)) $result = '(' . implode(',', $result) . ')';

  630.       

  631.       $query .= $result;

  632.     }

  633.       

  634.     return $query;

  635.   }

  636.   

  637.   protected function prependCall($function, $args, $prepend) { array_unshift($args, $prepend); return call_user_func_array($function, $args); }

  638.   public function query() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'assoc'); }

  639.   public function queryAllLists() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'list'); }

  640.   public function queryFullColumns() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'full'); }

  641. 

  642.   public function queryRaw() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'raw_buf'); }

  643.   public function queryRawUnbuf() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'raw_unbuf'); }

  644.   

  645.   protected function queryHelper() {

  646.     $args = func_get_args();

  647.     $type = array_shift($args);

  648.     $db = $this->get();

  649. 

  650.     $is_buffered = true;

  651.     $row_type = 'assoc'; // assoc, list, raw

  652.     $full_names = false;

  653. 

  654.     switch ($type) {

  655.       case 'assoc':

  656.         break;

  657.       case 'list':

  658.         $row_type = 'list';

  659.         break;

  660.       case 'full':

  661.         $row_type = 'list';

  662.         $full_names = true;

  663.         break;

  664.       case 'raw_buf':

  665.         $row_type = 'raw';

  666.         break;

  667.       case 'raw_unbuf':

  668.         $is_buffered = false;

  669.         $row_type = 'raw';

  670.         break;

  671.       default:

  672.         return $this->nonSQLError('Error -- invalid argument to queryHelper!');

  673.     }

  674. 

  675.     $sql = call_user_func_array(array($this, 'parseQueryParams'), $args);

  676. 

  677.     if ($this->pre_sql_handler !== false && is_callable($this->pre_sql_handler)) {

  678.       $sql = call_user_func($this->pre_sql_handler, $sql);

  679.     }

  680.     

  681.     if ($this->success_handler) $starttime = microtime(true);

  682.     $result = $db->query($sql, $is_buffered ? MYSQLI_STORE_RESULT : MYSQLI_USE_RESULT);

  683.     if ($this->success_handler) $runtime = microtime(true) - $starttime;

  684.     else $runtime = 0;

  685. 

  686.     // ----- BEGIN ERROR HANDLING

  687.     if (!$sql || $db->error) {

  688.       if ($this->error_handler) {

  689.         $error_handler = is_callable($this->error_handler) ? $this->error_handler : 'meekrodb_error_handler';

  690.         

  691.         call_user_func($error_handler, array(

  692.           'type' => 'sql',

  693.           'query' => $sql,

  694.           'error' => $db->error,

  695.           'code' => $db->errno

  696.         ));

  697.       }

  698.       

  699.       if ($this->throw_exception_on_error) {

  700.         $e = new MeekroDBException($db->error, $sql, $db->errno);

  701.         throw $e;

  702.       }

  703.     } else if ($this->success_handler) {

  704.       $runtime = sprintf('%f', $runtime * 1000);

  705.       $success_handler = is_callable($this->success_handler) ? $this->success_handler : 'meekrodb_debugmode_handler';

  706.       

  707.       call_user_func($success_handler, array(

  708.         'query' => $sql,

  709.         'runtime' => $runtime,

  710.         'affected' => $db->affected_rows

  711.       )); 

  712.     }

  713. 

  714.     // ----- END ERROR HANDLING

  715. 

  716.     $this->insert_id = $db->insert_id;

  717.     $this->affected_rows = $db->affected_rows;

  718. 

  719.     // mysqli_result->num_rows won't initially show correct results for unbuffered data

  720.     if ($is_buffered && ($result instanceof MySQLi_Result)) $this->num_rows = $result->num_rows;

  721.     else $this->num_rows = null;

  722. 

  723.     if ($row_type == 'raw' || !($result instanceof MySQLi_Result)) return $result;

  724. 

  725.     $return = array();

  726. 

  727.     if ($full_names) {

  728.       $infos = array();

  729.       foreach ($result->fetch_fields() as $info) {

  730.         if (strlen($info->table)) $infos[] = $info->table . '.' . $info->name;

  731.         else $infos[] = $info->name;

  732.       }

  733.     }

  734. 

  735.     while ($row = ($row_type == 'assoc' ? $result->fetch_assoc() : $result->fetch_row())) {

  736.       if ($full_names) $row = array_combine($infos, $row);

  737.       $return[] = $row;

  738.     }

  739. 

  740.     // free results

  741.     $result->free();

  742.     while ($db->more_results()) {

  743.       $db->next_result();

  744.       if ($result = $db->use_result()) $result->free();

  745.     }

  746.     

  747.     return $return;

  748.   }

  749. 

  750.   public function queryOneRow() { $args = func_get_args(); return call_user_func_array(array($this, 'queryFirstRow'), $args); }

  751.   public function queryFirstRow() {

  752.     $args = func_get_args();

  753.     $result = call_user_func_array(array($this, 'query'), $args);

  754.     if (!$result || !is_array($result)) return null;

  755.     return reset($result);

  756.   }

  757. 

  758.   public function queryOneList() { $args = func_get_args(); return call_user_func_array(array($this, 'queryFirstList'), $args); }

  759.   public function queryFirstList() {

  760.     $args = func_get_args();

  761.     $result = call_user_func_array(array($this, 'queryAllLists'), $args);

  762.     if (!$result || !is_array($result)) return null;

  763.     return reset($result);

  764.   }

  765.   

  766.   public function queryFirstColumn() { 

  767.     $args = func_get_args();

  768.     $results = call_user_func_array(array($this, 'queryAllLists'), $args);

  769.     $ret = array();

  770.     

  771.     if (!count($results) || !count($results[0])) return $ret;

  772.     

  773.     foreach ($results as $row) {

  774.       $ret[] = $row[0];

  775.     }

  776.     

  777.     return $ret;

  778.   }

  779.   

  780.   public function queryOneColumn() {

  781.     $args = func_get_args();

  782.     $column = array_shift($args);

  783.     $results = call_user_func_array(array($this, 'query'), $args);

  784.     $ret = array();

  785.     

  786.     if (!count($results) || !count($results[0])) return $ret;

  787.     if ($column === null) {

  788.       $keys = array_keys($results[0]);

  789.       $column = $keys[0];

  790.     }

  791.     

  792.     foreach ($results as $row) {

  793.       $ret[] = $row[$column];

  794.     }

  795.     

  796.     return $ret;

  797.   }

  798.   

  799.   public function queryFirstField() { 

  800.     $args = func_get_args();

  801.     $row = call_user_func_array(array($this, 'queryFirstList'), $args);

  802.     if ($row == null) return null;    

  803.     return $row[0];

  804.   }

  805.   

  806.   public function queryOneField() {

  807.     $args = func_get_args();

  808.     $column = array_shift($args);

  809.     

  810.     $row = call_user_func_array(array($this, 'queryOneRow'), $args);

  811.     if ($row == null) { 

  812.       return null;

  813.     } else if ($column === null) {

  814.       $keys = array_keys($row);

  815.       $column = $keys[0];

  816.     }  

  817.     

  818.     return $row[$column];

  819.   }

  820. }

  821. 

  822. class WhereClause {

  823.   public $type = 'and'; //AND or OR

  824.   public $negate = false;

  825.   public $clauses = array();

  826.   

  827.   function __construct($type) {

  828.     $type = strtolower($type);

  829.     if ($type !== 'or' && $type !== 'and') return DB::nonSQLError('you must use either WhereClause(and) or WhereClause(or)');

  830.     $this->type = $type;

  831.   }

  832.   

  833.   function add() {

  834.     $args = func_get_args();

  835.     $sql = array_shift($args);

  836.     

  837.     if ($sql instanceof WhereClause) {

  838.       $this->clauses[] = $sql;

  839.     } else {

  840.       $this->clauses[] = array('sql' => $sql, 'args' => $args);

  841.     }

  842.   }

  843.   

  844.   function negateLast() {

  845.     $i = count($this->clauses) - 1;

  846.     if (!isset($this->clauses[$i])) return;

  847.     

  848.     if ($this->clauses[$i] instanceof WhereClause) {

  849.       $this->clauses[$i]->negate();

  850.     } else {

  851.       $this->clauses[$i]['sql'] = 'NOT (' . $this->clauses[$i]['sql'] . ')';

  852.     }

  853.   }

  854.   

  855.   function negate() {

  856.     $this->negate = ! $this->negate;

  857.   }

  858.   

  859.   function addClause($type) {

  860.     $r = new WhereClause($type);

  861.     $this->add($r);

  862.     return $r;

  863.   }

  864.   

  865.   function count() {

  866.     return count($this->clauses);

  867.   }

  868.   

  869.   function textAndArgs() {

  870.     $sql = array();

  871.     $args = array();

  872.     

  873.     if (count($this->clauses) == 0) return array('(1)', $args);

  874.     

  875.     foreach ($this->clauses as $clause) {

  876.       if ($clause instanceof WhereClause) { 

  877.         list($clause_sql, $clause_args) = $clause->textAndArgs();

  878.       } else {

  879.         $clause_sql = $clause['sql'];

  880.         $clause_args = $clause['args'];

  881.       }

  882.       

  883.       $sql[] = "($clause_sql)";

  884.       $args = array_merge($args, $clause_args);

  885.     }

  886.     

  887.     if ($this->type == 'and') $sql = sprintf('(%s)', implode(' AND ', $sql));

  888.     else $sql = sprintf('(%s)', implode(' OR ', $sql));

  889.     

  890.     if ($this->negate) $sql = '(NOT ' . $sql . ')';

  891.     return array($sql, $args);

  892.   }

  893.   

  894.   // backwards compatability

  895.   // we now return full WhereClause object here and evaluate it in preparseQueryParams

  896.   function text() { return $this; }

  897. }

  898. 

  899. class DBTransaction {

  900.   private $committed = false;

  901.   

  902.   function __construct() { 

  903.     DB::startTransaction(); 

  904.   }

  905.   function __destruct() { 

  906.     if (! $this->committed) DB::rollback(); 

  907.   }

  908.   function commit() {

  909.     DB::commit();

  910.     $this->committed = true;

  911.   }

  912.   

  913.   

  914. }

  915. 

  916. class MeekroDBException extends Exception {

  917.   protected $query = '';

  918.   

  919.   function __construct($message='', $query='', $code = 0) {

  920.     parent::__construct($message);

  921.     $this->query = $query;

  922. 	$this->code = $code;

  923.   }

  924.   

  925.   public function getQuery() { return $this->query; }

  926. }

  927. 

  928. class DBHelper {

  929.   /*

  930.     verticalSlice

  931.     1. For an array of assoc rays, return an array of values for a particular key

  932.     2. if $keyfield is given, same as above but use that hash key as the key in new array

  933.   */

  934.   

  935.   public static function verticalSlice($array, $field, $keyfield = null) {

  936.     $array = (array) $array;

  937.     

  938.     $R = array();

  939.     foreach ($array as $obj) {

  940.       if (! array_key_exists($field, $obj)) die("verticalSlice: array doesn't have requested field\n");

  941.       

  942.       if ($keyfield) {

  943.         if (! array_key_exists($keyfield, $obj)) die("verticalSlice: array doesn't have requested field\n");  

  944.         $R[$obj[$keyfield]] = $obj[$field];

  945.       } else { 

  946.         $R[] = $obj[$field];

  947.       }

  948.     }

  949.     return $R;

  950.   }

  951.   

  952.   /*

  953.     reIndex

  954.     For an array of assoc rays, return a new array of assoc rays using a certain field for keys

  955.   */

  956.   

  957.   public static function reIndex() {

  958.     $fields = func_get_args();

  959.     $array = array_shift($fields);

  960.     $array = (array) $array;

  961.     

  962.     $R = array();

  963.     foreach ($array as $obj) {

  964.       $target =& $R;

  965.       

  966.       foreach ($fields as $field) {

  967.         if (! array_key_exists($field, $obj)) die("reIndex: array doesn't have requested field\n");

  968.         

  969.         $nextkey = $obj[$field];

  970.         $target =& $target[$nextkey];

  971.       }

  972.       $target = $obj;

  973.     }

  974.     return $R;

  975.   }

  976. }

  977. 

  978. function meekrodb_error_handler($params) {

  979.   if (isset($params['query'])) $out[] = "QUERY: " . $params['query'];

  980.   if (isset($params['error'])) $out[] = "ERROR: " . $params['error'];

  981.   $out[] = "";

  982.   

  983.   if (php_sapi_name() == 'cli' && empty($_SERVER['REMOTE_ADDR'])) {

  984.     echo implode("\n", $out);

  985.   } else {

  986.     echo implode("<br>\n", $out);

  987.   }

  988.   

  989.   die;

  990. }

  991. 

  992. function meekrodb_debugmode_handler($params) {

  993.   echo "QUERY: " . $params['query'] . " [" . $params['runtime'] . " ms]";

  994.   if (php_sapi_name() == 'cli' && empty($_SERVER['REMOTE_ADDR'])) {

  995.     echo "\n";

  996.   } else {

  997.     echo "<br>\n";

  998.   }

  999. }

  1000. 

  1001. class MeekroDBEval {

  1002.   public $text = '';

  1003.   

  1004.   function __construct($text) {

  1005.     $this->text = $text;

  1006.   }

  1007. }

  1008. 

  1009. ?>