source/lib/simplicity/data/table/table.php

   1 <?php
   2
   3 class smp_DataTable
   4 {
   5         const NOSET = '*!NOSET!*';
   6
   7         /**
   8          * smp_Db
   9          *
  10          * @var smp_Db
  11          */
  12         static private $_db;
  13
  14         /**
  15          * smp_Cache
  16          *
  17          * @var smp_Cache
  18          */
  19         static private $_cache;
  20
  21         static private $_global_cache_enabled = false;
  22
  23         static public function setDefaultConnection(smp_Db $db)
  24         {
  25                 self::$_db = $db;
  26         }
  27
  28         /**
  29          * smp_Db
  30          *
  31          * @return smp_Db
  32          */
  33         static public function getDefaultConnection()
  34         {
  35                 return self::$_db;
  36         }
  37
  38         /**
  39          * smp_Db
  40          *
  41          * @var smp_Db
  42          */
  43         private $_conn;
  44         private $_table;
  45         private $_primary = 'id';
  46         private $_order;
  47         private $_limit;
  48         private $_data = array();
  49         private $_types = array();
  50
  51         private $_cache_enabled = false;
  52
  53         protected $_id = false;
  54
  55         static private $_ops = array(
  56                 'le' => '<=',
  57                 'lt' => '<',
  58                 'ge' => '>=',
  59                 'gt' => '>',
  60                 'ne' => '<>'
  61         );
  62
  63         static public function create($table,smp_Db $db=null)
  64         {
  65                 $t = new self($db);
  66                 $t->setTable($table);
  67                 return $t;
  68         }
  69
  70         final public function reset()
  71         {
  72                 $this->_data = array();
  73                 $this->_id = false;
  74                 $this->_order = array();
  75         }
  76
  77         final public function getId()
  78         {
  79                 return $this->_id;
  80         }
  81
  82         final public function isCacheEnabled()
  83         {
  84                 if ($this instanceof self) {
  85                         return isset($this->_cache_enabled) ? $this->_cache_enabled : self::$_global_cache_enabled;
  86                 } else {
  87                         return self::$_global_cache_enabled;
  88                 }
  89         }
  90
  91         final public function enableCaching()
  92         {
  93                 if ($this instanceof self) {
  94                         $this->_cache_enabled = true;
  95                 } else {
  96                         self::$_global_cache_enabled = true;
  97                 }
  98         }
  99
 100         final public function disableCaching()
 101         {
 102                 if ($this instanceof self) {
 103                         $this->_cache_enabled = false;
 104                 } else {
 105                         self::$_global_cache_enabled = false;
 106                 }
 107         }
 108
 109         final public function __construct(smp_Db $db = null)
 110         {
 111                 if ($this->isCacheEnabled() && !(self::$_cache instanceof smp_Cache))
 112                 {
 113                         self::$_cache = Simplicity::getInstance()->getCache();
 114                 }
 115
 116                 $this->_conn = isset($db) ? $db : self::$_db;
 117
 118                 $this->init();
 119         }
 120
 121         final protected function setTable($table)
 122         {
 123                 $this->_table = $table;
 124         }
 125
 126         final protected function setType($column,smp_DataTableType $type)
 127         {
 128                 $this->_types[$column] = $type;
 129         }
 130
 131         final protected function setPrimary($primary)
 132         {
 133                 $this->_primary = $primary;
 134         }
 135
 136         public function init() {}
 137
 138         private function setCacheData($prefix,array $data,$timeout=null)
 139         {
 140                 if (!$this->isCacheEnabled()) return false;
 141                 foreach ($data as $k => $v)
 142                 {
 143                         $key = md5($this->_table.$prefix.$k);
 144                         self::$_cache->set($key,$v,$timeout);
 145                 }
 146         }
 147
 148         private function getCacheData($prefix,$key)
 149         {
 150                 if (!$this->isCacheEnabled()) return false;
 151                 $key = md5($this->_table.$prefix.$key);
 152                 return self::$_cache->get($key);
 153         }
 154
 155         private function delCacheData($prefix,array $keys)
 156         {
 157                 if (!$this->isCacheEnabled()) return false;
 158                 foreach ($data as $key)
 159                 {
 160                         $key = md5($this->_table.$prefix.$key);
 161                         self::$_cache->del($key);
 162                 }
 163         }
 164
 165         final public function find($search,$cache=null)
 166         {
 167                 $this->reset();
 168
 169                 if (is_array($search)) {
 170                         $key = implode(array_keys($search)).implode($search);
 171                         $key = md5($key);
 172                 } else {
 173                         $key = $search;
 174                 }
 175
 176                 if (!$id = $this->getCacheData('find',$key))
 177                 {
 178                         if (is_array($search))
 179                         {
 180                                 list($qry,$params) = $this->_search($search);
 181                                 $row = $this->_conn->query($qry,$params);
 182                                 if (isset($row[0])) $row = $row[0];
 183                                 $id = isset($row[$this->_primary]) ? $row[$this->_primary] : false;
 184                         }
 185                         else
 186                         {
 187                                 $qry = "select `{$this->_primary}` from `{$this->_table}` where `{$this->_primary}` = ?";
 188                                 $row = $this->_conn->query($qry,array($search));
 189                                 $id = isset($row[$this->_primary]) ? $row[$this->_primary] : false;
 190                         }
 191
 192                         $this->setCacheData('find',array($key => $id),(is_array($search) ? $cache : null));
 193                 }
 194
 195                 $this->_id = $id;
 196                 return $this;
 197         }
 198
 199         final public function get($name,$no_overload=false)
 200         {
 201                 if (!$no_overload && $val = $this->preGet($name)) $this->_data[$name] = $val;
 202
 203                 if (!isset($this->_data[$name]) && !$this->_data[$name] = $this->getCacheData('get'.$this->_id,$name)) {
 204                         if (!$this->_id) return false;
 205
 206                         $qry = "select `{$name}` from `{$this->_table}` where `{$this->_primary}` = ?";
 207
 208                         $row = $this->_conn->query($qry,array($this->_id));
 209
 210                         if (!isset($row[$name])) return false;
 211
 212                         $this->_data[$name] = $row[$name];
 213
 214                         $this->setCacheData('get'.$this->_id,array($name => $this->_data[$name]));
 215                 }
 216
 217                 if ($this->_data[$name]) {
 218                         if (isset($this->_types[$name])) {
 219                                 return $this->_types[$name]->formatOut($this->_data[$name]);
 220                         }
 221                         return $this->_data[$name];
 222                 }
 223
 224                 return false;
 225         }
 226
 227         final public function __get($name) {
 228                 return $this->get($name);
 229         }
 230
 231         final public function __set($name,$value) {
 232                 return $this->set($name,$value);
 233         }
 234
 235         final public function __unset($name)
 236         {
 237                 $this->del($name);
 238         }
 239
 240         final public function del($name)
 241         {
 242                 unset($this->_data[$name]);
 243         }
 244
 245         final public function set($name,$value)
 246         {
 247                 $value = $this->preSet($name,$value);
 248
 249                 if ($value == self::NOSET) return false;
 250
 251                 if (isset($this->_types[$name]))
 252                 {
 253                         $value = $this->_types[$name]->formatIn($value);
 254                 }
 255
 256                 if ($name == $this->_primary)
 257                 {
 258                         $this->_id = $value;
 259                 }
 260
 261                 $this->_data[$name] = $value;
 262         }
 263
 264         final private function filterSearchValue($val,$col)
 265         {
 266                 $op = key($val);
 267                 $op = isset(self::$_ops[$op]) ? self::$_ops[$op] : '=';
 268                 return "`{$col}` {$op} ?";
 269         }
 270
 271         final private function filterSearch($filter,$col) {
 272                 $filters = array();
 273                 $vals = array();
 274                 if (is_array($filter)) {
 275                         if (!is_numeric(key($filter))) {
 276                                 $filter = array($filter);
 277                         }
 278                         while ($fil = array_shift($filter))
 279                         {
 280                                 $vals[] = current($fil);
 281                                 $filters[] = $this->filterSearchValue($fil,$col);
 282                         }
 283
 284                         $filters = implode(' and ',$filters);
 285                 }
 286                 else {
 287                         $filters = "`{$col}` = ?";
 288                         $vals[] = $filter;
 289                 }
 290
 291                 return array($filters,$vals);
 292         }
 293
 294         final private function formatSearchFilter($v)
 295         {
 296                 return "({$v})";
 297         }
 298
 299         final private function mergeSearchFilters($filter)
 300         {
 301                 $mfilters = array();
 302                 $mvals = array();
 303                 while ($fil = array_shift($filter))
 304                 {
 305                         $mfilters[] = $fil[0];
 306                         $mvals = array_merge($mvals,$fil[1]);
 307                 }
 308                 $mfilters = array_map(array($this,'formatSearchFilter'),$mfilters);
 309                 $mfilters = implode(' and ',$mfilters);
 310                 return array($mfilters,$mvals);
 311         }
 312
 313         final private function _search($search)
 314         {
 315                 $vals = array();
 316                 $params = null;
 317
 318                 if ($search != 'all') {
 319                         list($filters,$params) = $this->mergeSearchFilters(array_map(array($this,'filterSearch'),$search,array_keys($search)));
 320                 }
 321
 322                 $qry = "select `{$this->_primary}` from `{$this->_table}`";
 323
 324                 if ($search != 'all')
 325                 {
 326                         $qry .= " where {$filters}";
 327                 };
 328
 329                 if (!is_array($params)) $params = array();
 330
 331                 return array($qry,$params);
 332         }
 333
 334         final private function fixSearchIds($val)
 335         {
 336                 return $val[$this->_primary];
 337         }
 338
 339         /**
 340          * Get a smp_DataTableIterator
 341          *
 342          * @param array|string $search Search query
 343          * @param int $cache Cache timeout in seconds (0 for until cleared)
 344          * @return smp_DataTableIterator
 345          */
 346         final public function search($search,$cache=null)
 347         {
 348                 if (is_array($search)) {
 349                         $key = md5(var_export($search,true));
 350                 } else {
 351                         $key = 'all';
 352                 }
 353
 354                 if (!$ids = $this->getCacheData('search',$key))
 355                 {
 356                         list($qry,$params) = $this->_search($search);
 357
 358                         $ids = $this->_conn->query($qry,$params);
 359                         $ids = array_map(array($this,'fixSearchIds'),$ids);
 360                         if (isset($cache)) $this->setCacheData('search',array($key=>$ids),$cache);
 361                 }
 362
 363                 $it = new smp_DataTableIterator($ids,$this);
 364
 365                 if ($this->_order) {
 366                         $it->orderBy($this->_order);
 367                         $this->_order = false;
 368                 }
 369
 370                 return $it;
 371         }
 372
 373         final public function getData() {
 374                 if (!$this->_id) return false;
 375
 376                 $cols = $this->_conn->getMeta()->getTable($this->_table);
 377
 378                 foreach($cols as $col => $meta) {
 379                         $row[$col] = $this->get($col);
 380                 }
 381
 382                 return $row;
 383         }
 384
 385         final public function getColumnMeta($column)
 386         {
 387                 $cols = $this->_conn->getMeta()->getTable($this->_table);
 388                 return isset($cols[$column]) ? $cols[$column] : false;
 389         }
 390
 391         final public function setData($data=array()) {
 392                 foreach ($data as $name => $value)
 393                 {
 394                         $this->set($name,$value);
 395                 }
 396         }
 397
 398         final public function save($no_hooks=false)
 399         {
 400                 if ($this->_id) return $this->update($no_hooks);
 401
 402                 return $this->insert($no_hooks);
 403         }
 404
 405         final public function delete($no_hooks=false)
 406         {
 407                 if (!$this->_id) {return false;}
 408
 409                 if (!$no_hooks) $this->preDelete();
 410
 411                 $qry = "delete from {$this->_table} where `{$this->_primary}` = ?";
 412
 413                 $this->_conn->query($qry,array($this->_id));
 414
 415                 $this->delCacheData($this->_id,array_keys($this->_data));
 416
 417                 if (!$no_hooks) $this->postDelete($this->_id);
 418
 419                 return true;
 420         }
 421
 422         protected function preSet($name,$value) { return $value; }
 423         protected function preGet($name) { return false; }
 424
 425         protected function preAdd() {}
 426         protected function postAdd() {}
 427         protected function preUpdate() {}
 428         protected function postUpdate() {}
 429         protected function preDelete() {}
 430         protected function postDelete($id) {}
 431
 432         final private function fixInsertVal($val)
 433         {
 434                 return "`{$val}`";
 435         }
 436
 437         final private function insert($no_hooks)
 438         {
 439                 if (!count($this->_data)) return false;
 440
 441                 if (!$no_hooks) $this->preAdd();
 442
 443                 if (isset($this->_data[$this->_primary])) unset($this->_data[$this->_primary]);
 444
 445                 $cols = array_keys($this->_data);
 446
 447                 $vals = implode(',',array_fill(0,count($cols),'?'));
 448
 449                 $cols = array_map(array($this,'fixInsertVal'),$cols);
 450                 $cols = implode(',',$cols);
 451
 452                 $qry = "insert into {$this->_table} ({$cols}) values ({$vals})";
 453                 $this->_conn->query($qry,array_values($this->_data));
 454
 455                 $id = $this->_conn->lastInsertId();
 456
 457                 $this->find($id);
 458
 459                 $this->setCacheData($this->_id,$this->_data);
 460
 461                 if (!$no_hooks) $this->postAdd($this->_id);
 462
 463                 return $this->_id;
 464         }
 465
 466         final private function fixUpdateVal($val)
 467         {
 468                 return "`{$val}` = ?";
 469         }
 470
 471         final private function update($no_hooks)
 472         {
 473                 if (!$this->_id) return false;
 474                 if (!count($this->_data)) return true;
 475
 476                 if (!$no_hooks) $this->preUpdate();
 477
 478                 if (isset($this->_data[$this->_primary])) unset($this->_data[$this->_primary]);
 479
 480                 $cols = array_keys($this->_data);
 481                 $cols = array_map(array($this,'fixUpdateVal'),$cols);
 482                 $cols = implode(',',$cols);
 483
 484                 $qry = "update {$this->_table} set {$cols} where `{$this->_primary}` = ?";
 485
 486                 $params = array_merge(array_values($this->_data),array($this->_id));
 487
 488                 $this->_conn->query($qry,$params);
 489
 490                 $this->setCacheData($this->_id,$this->_data);
 491
 492                 if (!$no_hooks) $this->postUpdate($this->_id);
 493
 494                 return true;
 495         }
 496 }