PageRenderTime 27ms CodeModel.GetById 1ms RepoModel.GetById 1ms app.codeStats 0ms

/surosql/wordpress_plugin/surosql/src/SurosqlWpdb.class.php

https://bitbucket.org/SuRaMoN/surosql
PHP | 295 lines | 248 code | 46 blank | 1 comment | 36 complexity | ae29e26034830d0eb0e4c63f48080637 MD5 | raw file
Possible License(s): LGPL-3.0, AGPL-1.0, GPL-2.0, LGPL-2.1
  1. <?php
  2. // version 1.1
  3. class SurosqlWpdb {
  4. static $osql;
  5. static function register($args = array()) {
  6. $defaults = array(
  7. 'osql' => new Surosql(),
  8. 'wpdb' => $GLOBALS['wpdb'],
  9. 'options' => array(),
  10. 'init_osql_func' => true);
  11. if(is_string($args)) {
  12. parse_str($args, $args);
  13. }
  14. extract(array_merge($defaults, $args));
  15. $osql->wpdb = $wpdb;
  16. if($init_osql_func && !function_exists('osql')) {
  17. self::$osql = $osql;
  18. self::init_osql_func($osql);
  19. SurosqlWpdbOOManager::register($osql);
  20. }
  21. foreach(get_class_methods('SurosqlWpdb') as $funcname) {
  22. if(substr($funcname, -6) == '_query') {
  23. $osql->imported_query_functions[substr($funcname, 0, -6)] = array('SurosqlWpdb', $funcname);
  24. } else if(substr($funcname, -5) == '_osql') {
  25. $osql->imported_osql_functions[substr($funcname, 0, -5)] = array('SurosqlWpdb', $funcname);
  26. }
  27. }
  28. $bin_string_operators = array('eq' => '=', 'neq' => '!=', 'lt' => '<', 'gt' => '>', 'lte' => '<=', 'gte' => '>=', 'like' => 'LIKE', 'is' => '');
  29. foreach($bin_string_operators as $opname => $op) {
  30. $osql->imported_osql_functions[$opname] = create_function('$osql, $key, $val = null', "return SurosqlWpdb::operator(\$osql, '$op', \$key, \$val);");
  31. $osql->imported_query_functions["if{$opname}"] = create_function('$query, $key, $val = null', "return \$query->andwhere(SurosqlWpdb::operator(\$query->osql, '$op', \$key, \$val));");
  32. }
  33. $bin_array_operators = array('in' => 'IN', 'nin' => 'NOT IN');
  34. foreach($bin_array_operators as $opname => $op) {
  35. $osql->imported_osql_functions[$opname] = create_function('$osql, $key, $val = null', "return SurosqlWpdb::operator_with_list_param(\$osql, '$op', \$key, \$val);");
  36. $osql->imported_query_functions["if{$opname}"] = create_function('$query, $key, $val = null', "return \$query->andwhere(SurosqlWpdb::operator_with_list_param(\$query->osql, '$op', \$key, \$val));");
  37. }
  38. return $osql;
  39. }
  40. static private function init_osql_func($osql) {
  41. function osql() {
  42. return SurosqlWpdb::$osql;
  43. }
  44. }
  45. static function quote_rec_osql($osql, $var, $maxdepth = PHP_INT_MAX, $depth = 0) {
  46. if(is_array($var) && $maxdepth > $depth) {
  47. foreach($var as $key => &$val) {
  48. $val = self::quote_rec_osql($osql, $val, $maxdepth, $depth + 1);
  49. }
  50. return $var;
  51. } else if(is_object($var) && $maxdepth > $depth) {
  52. $obj = clone $var;
  53. foreach(get_object_vars() as $field => $val) {
  54. $obj->$field = self::quote_rec_osql($osql, $val, $maxdepth, $depth + 1);
  55. }
  56. return $obj;
  57. } else {
  58. return '"' . $osql->wpdb->escape((string)$var) . '"';
  59. }
  60. }
  61. static function quote_osql($osql, $str) {
  62. return '"' . $osql->wpdb->escape((string)$str) . '"';
  63. }
  64. static function quote_lst($osql, $lst) {
  65. $lst = is_array($lst) ? Surosql::array_flatten($lst) : explode(',', (string)$lst);
  66. return implode(',', self::quote_rec_osql($osql, $lst, 1));
  67. }
  68. static function operator($osql, $operator, $key, $val = null, $quote_vals = true) {
  69. $where = array();
  70. if(is_null($val)) {
  71. foreach($key as $col => $colval) {
  72. $prepped_val = ($quote_vals ? self::quote_osql($osql, $val) : $colval);
  73. $where[] = "$col $operator $prepped_val";
  74. }
  75. } else {
  76. $keys = is_array($key) ? $key : array($key);
  77. $prepped_val = $quote_vals ? self::quote_osql($osql, $val) : $val;
  78. foreach($keys as $col) {
  79. $where[] = "$col $operator $prepped_val";
  80. }
  81. }
  82. return is_array($key) ? $where : $where[0];
  83. }
  84. static function operator_with_list_param($osql, $operator, $key, $val = null) {
  85. if(is_null($val)) {
  86. foreach($key as $col => &$colval) {
  87. $colval = '(' . self::quote_lst($osql, $colval) . ')';
  88. }
  89. } else {
  90. $val = '(' . self::quote_lst($osql, $val) . ')';
  91. }
  92. return self::operator($osql, $operator, $key, $val, false);
  93. }
  94. static private function wpdb_method($method, $query) {
  95. $wpdb = $query->osql->wpdb;
  96. $func_args = func_get_args();
  97. if(!isset($query->bound_args) || count($query->bound_args) == 0) {
  98. $arg = $query->sql();
  99. } else {
  100. $arg = call_user_func_array(array($wpdb, 'prepare'), array_merge(array($query->sql()), $query->bound_args));
  101. }
  102. return call_user_func_array(array($wpdb, $method), array_merge(array($arg), array_slice($func_args, 2)));
  103. }
  104. static function insert_osql($osql, $table, $values_escaped = array(), $values_unescaped = array()) {
  105. $table = $osql->glalias2table($table);
  106. $names = array_merge(array_keys($values_escaped), array_keys($values_unescaped));
  107. $sqlvalues = array_merge(array_fill(0, count($values_escaped), '%s'), array_values($values_unescaped));
  108. return $osql->exec("INSERT INTO `$table` (`" . implode('`, `', $names) . '`) VALUES (' . implode(', ', $sqlvalues) . ')', array_values($values_escaped));
  109. }
  110. static function escape_osql($osql, $var) {
  111. return $osql->wpdb->escape($var);
  112. }
  113. static function insert_id_osql($osql) {
  114. return $osql->wpdb->insert_id;
  115. }
  116. static function lastInsertId_osql($osql) {
  117. return $osql->wpdb->insert_id;
  118. }
  119. static function query_osql() {
  120. $args = func_get_args();
  121. return call_user_func_array(array('SurosqlWpdb', 'exec_osql'), $args);
  122. }
  123. static function exec_osql($osql, $query) {
  124. $func_args = func_get_args();
  125. if(func_num_args() == 2) {
  126. return $osql->wpdb->query($query);
  127. } else {
  128. return $osql->wpdb->query(call_user_func_array(array($osql->wpdb, 'prepare'), array_values(surosql::array_flatten(array_slice($func_args, 1)))));
  129. }
  130. }
  131. static function exec_query($query) {
  132. return self::wpdb_method('query', $query);
  133. }
  134. static function bind_query($query) {
  135. $sql = $query->sql();
  136. $func_args = func_get_args();
  137. $query->bound_args = array_values(surosql::array_flatten(array_slice($func_args, 1)));
  138. return $query;
  139. }
  140. static function get_results_query($query) {
  141. return self::wpdb_method('get_results', $query);
  142. }
  143. static function get_col_query($query) {
  144. return self::wpdb_method('get_col', $query);
  145. }
  146. static function get_var_query($query) {
  147. return self::wpdb_method('get_var', $query);
  148. }
  149. static function first_query($query, $default = null) {
  150. $r = self::wpdb_method('get_row', $query, ARRAY_A);
  151. if(!is_null($r)) {
  152. $r = $query->array_to_oo(array($r));
  153. return $r[0];
  154. } else if(func_num_args() == 1) {
  155. throw new Exception('Trying to fetch from empty resultset.');
  156. }
  157. return $default;
  158. }
  159. static function all_query($query) {
  160. return $query->array_to_oo(self::wpdb_method('get_results', $query, ARRAY_A));
  161. }
  162. static function col_query($query, $col_num = 0) {
  163. return self::wpdb_method('get_col', $query, $col_num);
  164. }
  165. static function var_query($query) {
  166. return self::wpdb_method('get_var', $query);
  167. }
  168. static function getIteratorImpl_query($query) {
  169. return new ArrayIterator(self::all_query($query));
  170. }
  171. }
  172. class SurosqlWpdbOOManager {
  173. static function register($osql) {
  174. $funcs = array(
  175. 'insertobj' => array('SurosqlWpdbOOManager', 'insertobj'),
  176. 'updateobj' => array('SurosqlWpdbOOManager', 'updateobj'),
  177. 'deleteobj' => array('SurosqlWpdbOOManager', 'deleteobj'),
  178. );
  179. $osql->imported_osql_functions = array_merge($osql->imported_osql_functions, $funcs);
  180. }
  181. static function update($obj, $fields = null, $values_unescaped = array()) {
  182. return self::updateobj(SurosqlWpdb::$osql, $obj, $fields, $values_unescaped);
  183. }
  184. static function insert($obj, $fields = null, $values_unescaped = array()) {
  185. return self::insertobj(SurosqlWpdb::$osql, $obj, $fields, $values_unescaped);
  186. }
  187. static function delete($obj) {
  188. return self::deleteobj(SurosqlWpdb::$osql, $obj);
  189. }
  190. static function updateobj($osql, $obj, $fields = null, $values_unescaped = array()) {
  191. $oo = $osql->get_obj_info($obj);
  192. $fields = is_null($fields) ? array_diff($oo['columns'], array($oo['primary'])) : $fields;
  193. $bind_vars = array();
  194. foreach($fields as $field) {
  195. $bind_vars[$field] = isset($obj->$field) ? $obj->$field : null;
  196. $set[] = "`$field` = %s";
  197. }
  198. foreach($values_unescaped as $field => $value) {
  199. $set[] = "`$field` = $value";
  200. }
  201. $bind_vars = array_merge(array_values($osql->field_serialization($bind_vars, $oo)), array($obj->{$oo['primary']}));
  202. return $osql->update($oo['table'])->set(implode(', ', $set))->where("{$oo['primary']}=%d")->bind($bind_vars)->exec();
  203. }
  204. static function insertobj($osql, $obj, $fields = null, $values_unescaped = array()) {
  205. $oo = $osql->get_obj_info($obj);
  206. foreach($oo['columns'] as $field) {
  207. if(isset($obj->$field)) {
  208. $values_escaped[$field] = $obj->$field;
  209. }
  210. }
  211. if(isset($oo['primary']) && isset($values_escaped[$oo['primary']]) && is_null($values_escaped[$oo['primary']])) {
  212. unset($values_escaped[$oo['primary']]);
  213. }
  214. $osql->insert($oo['table'], $osql->field_serialization($values_escaped, $oo), $values_unescaped);
  215. return isset($oo['primary']) ? ($obj->{$oo['primary']} = $osql->lastInsertId()) : null;
  216. }
  217. static function deleteobj($osql, $obj) {
  218. $oo = $osql->get_obj_info($obj);
  219. return $osql->exec("DELETE FROM `{$oo['table']}` WHERE `{$oo['primary']}` = %d", $obj->{$oo['primary']});
  220. }
  221. }
  222. class SurosqlWpdbOO {
  223. const ONLY_COLUMN_FIELDS = 0;
  224. const ALSO_NON_COLUMN_FIELDS = 1;
  225. function __construct($field_array = null) {
  226. if(is_array($field_array)) {
  227. $this->set_fields_from_array($field_array);
  228. }
  229. }
  230. function set_fields_from_array($field_array, $which_fields = self::ONLY_COLUMN_FIELDS) {
  231. if($only_column_fields == self::ONLY_COLUMN_FIELDS) {
  232. $oo = SurosqlWpdb::$osql->get_obj_info($this);
  233. $field_array = array_intersect_key($field_array, array_flip($oo['columns']));
  234. }
  235. foreach($field_array as $name => $value) {
  236. $this->$name = $value;
  237. }
  238. }
  239. function update($fields = null, $values_unescaped = array()) {
  240. return SurosqlWpdbOOManager::update($this, $fields, $values_unescaped);
  241. }
  242. function insert($fields = null, $values_unescaped = array()) {
  243. return SurosqlWpdbOOManager::insert($this, $fields, $values_unescaped);
  244. }
  245. function delete() {
  246. return SurosqlWpdbOOManager::delete($this);
  247. }
  248. }
  249. ?>