源码分享站 - 分享有用的

fatfree 展示 mapper.php源代码

返回 下载fatfree: 单独下载mapper.php源代码 - 下载整个fatfree源代码 - 类型:.php文件
  1. <?php
  2.  
  3. /*
  4.  
  5.         Copyright (c) 2009-2016 F3::Factory/Bong Cosca, All rights reserved.
  6.  
  7.         This file is part of the Fat-Free Framework (http://fatfreeframework.com).
  8.  
  9.         This is free software: you can redistribute it and/or modify it under the
  10.         terms of the GNU General Public License as published by the Free Software
  11.         Foundation, either version 3 of the License, or later.
  12.  
  13.         Fat-Free Framework is distributed in the hope that it will be useful,
  14.         but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.         General Public License for more details.
  17.  
  18.         You should have received a copy of the GNU General Public License along
  19.         with Fat-Free Framework.  If not, see <http://www.gnu.org/licenses/>.
  20.  
  21. */
  22.  
  23. namespace DB\SQL;
  24.  
  25. //! SQL data mapper
  26. class Mapper extends \DB\Cursor {
  27.  
  28.         protected
  29.                 //! PDO wrapper
  30.                 $db,
  31.                 //! Database engine
  32.                 $engine,
  33.                 //! SQL table
  34.                 $source,
  35.                 //! SQL table (quoted)
  36.                 $table,
  37.                 //! Last insert ID
  38.                 $_id,
  39.                 //! Defined fields
  40.                 $fields,
  41.                 //! Adhoc fields
  42.                 $adhoc=[];
  43.  
  44.         /**
  45.         *       Return database type
  46.         *       @return string
  47.         **/
  48.         function dbtype() {
  49.                 return 'SQL';
  50.         }
  51.  
  52.         /**
  53.         *       Return mapped table
  54.         *       @return string
  55.         **/
  56.         function table() {
  57.                 return $this->source;
  58.         }
  59.  
  60.         /**
  61.         *       Return TRUE if field is defined
  62.         *       @return bool
  63.         *       @param $key string
  64.         **/
  65.         function exists($key) {
  66.                 return array_key_exists($key,$this->fields+$this->adhoc);
  67.         }
  68.  
  69.         /**
  70.         *       Return TRUE if any/specified field value has changed
  71.         *       @return bool
  72.         *       @param $key string
  73.         **/
  74.         function changed($key=NULL) {
  75.                 if (isset($key))
  76.                         return $this->fields[$key]['changed'];
  77.                 foreach($this->fields as $key=>$field)
  78.                         if ($field['changed'])
  79.                                 return TRUE;
  80.                 return FALSE;
  81.         }
  82.  
  83.         /**
  84.         *       Assign value to field
  85.         *       @return scalar
  86.         *       @param $key string
  87.         *       @param $val scalar
  88.         **/
  89.         function set($key,$val) {
  90.                 if (array_key_exists($key,$this->fields)) {
  91.                         $val=is_null($val) && $this->fields[$key]['nullable']?
  92.                                 NULL:$this->db->value($this->fields[$key]['pdo_type'],$val);
  93.                         if ($this->fields[$key]['initial']!==$val ||
  94.                                 $this->fields[$key]['default']!==$val && is_null($val))
  95.                                 $this->fields[$key]['changed']=TRUE;
  96.                         return $this->fields[$key]['value']=$val;
  97.                 }
  98.                 // adjust result on existing expressions
  99.                 if (isset($this->adhoc[$key]))
  100.                         $this->adhoc[$key]['value']=$val;
  101.                 else
  102.                         // Parenthesize expression in case it's a subquery
  103.                         $this->adhoc[$key]=['expr'=>'('.$val.')','value'=>NULL];
  104.                 return $val;
  105.         }
  106.  
  107.         /**
  108.         *       Retrieve value of field
  109.         *       @return scalar
  110.         *       @param $key string
  111.         **/
  112.         function &get($key) {
  113.                 if ($key=='_id')
  114.                         return $this->_id;
  115.                 elseif (array_key_exists($key,$this->fields))
  116.                         return $this->fields[$key]['value'];
  117.                 elseif (array_key_exists($key,$this->adhoc))
  118.                         return $this->adhoc[$key]['value'];
  119.                 user_error(sprintf(self::E_Field,$key),E_USER_ERROR);
  120.         }
  121.  
  122.         /**
  123.         *       Clear value of field
  124.         *       @return NULL
  125.         *       @param $key string
  126.         **/
  127.         function clear($key) {
  128.                 if (array_key_exists($key,$this->adhoc))
  129.                         unset($this->adhoc[$key]);
  130.         }
  131.  
  132.         /**
  133.         *       Get PHP type equivalent of PDO constant
  134.         *       @return string
  135.         *       @param $pdo string
  136.         **/
  137.         function type($pdo) {
  138.                 switch ($pdo) {
  139.                         case \PDO::PARAM_NULL:
  140.                                 return 'unset';
  141.                         case \PDO::PARAM_INT:
  142.                                 return 'int';
  143.                         case \PDO::PARAM_BOOL:
  144.                                 return 'bool';
  145.                         case \PDO::PARAM_STR:
  146.                                 return 'string';
  147.                         case \DB\SQL::PARAM_FLOAT:
  148.                                 return 'float';
  149.                 }
  150.         }
  151.  
  152.         /**
  153.         *       Convert array to mapper object
  154.         *       @return object
  155.         *       @param $row array
  156.         **/
  157.         protected function factory($row) {
  158.                 $mapper=clone($this);
  159.                 $mapper->reset();
  160.                 foreach ($row as $key=>$val) {
  161.                         if (array_key_exists($key,$this->fields))
  162.                                 $var='fields';
  163.                         elseif (array_key_exists($key,$this->adhoc))
  164.                                 $var='adhoc';
  165.                         else
  166.                                 continue;
  167.                         $mapper->{$var}[$key]['value']=$val;
  168.                         $mapper->{$var}[$key]['initial']=$val;
  169.                         if ($var=='fields' && $mapper->{$var}[$key]['pkey'])
  170.                                 $mapper->{$var}[$key]['previous']=$val;
  171.                 }
  172.                 $mapper->query=[clone($mapper)];
  173.                 if (isset($mapper->trigger['load']))
  174.                         \Base::instance()->call($mapper->trigger['load'],$mapper);
  175.                 return $mapper;
  176.         }
  177.  
  178.         /**
  179.         *       Return fields of mapper object as an associative array
  180.         *       @return array
  181.         *       @param $obj object
  182.         **/
  183.         function cast($obj=NULL) {
  184.                 if (!$obj)
  185.                         $obj=$this;
  186.                 return array_map(
  187.                         function($row) {
  188.                                 return $row['value'];
  189.                         },
  190.                         $obj->fields+$obj->adhoc
  191.                 );
  192.         }
  193.  
  194.         /**
  195.         *       Build query string and execute
  196.         *       @return static[]
  197.         *       @param $fields string
  198.         *       @param $filter string|array
  199.         *       @param $options array
  200.         *       @param $ttl int|array
  201.         **/
  202.         function select($fields,$filter=NULL,array $options=NULL,$ttl=0) {
  203.                 if (!$options)
  204.                         $options=[];
  205.                 $options+=[
  206.                         'group'=>NULL,
  207.                         'order'=>NULL,
  208.                         'limit'=>0,
  209.                         'offset'=>0
  210.                 ];
  211.                 $db=$this->db;
  212.                 $sql='SELECT '.$fields.' FROM '.$this->table;
  213.                 $args=[];
  214.                 if (is_array($filter)) {
  215.                         $args=isset($filter[1]) && is_array($filter[1])?
  216.                                 $filter[1]:
  217.                                 array_slice($filter,1,NULL,TRUE);
  218.                         $args=is_array($args)?$args:[1=>$args];
  219.                         list($filter)=$filter;
  220.                 }
  221.                 if ($filter)
  222.                         $sql.=' WHERE '.$filter;
  223.                 if ($options['group']) {
  224.                         $sql.=' GROUP BY '.implode(',',array_map(
  225.                                 function($str) use($db) {
  226.                                         return preg_replace_callback(
  227.                                                 '/\b(\w+)\h*(HAVING.+|$)/i',
  228.                                                 function($parts) use($db) {
  229.                                                         return $db->quotekey($parts[1]).(isset($parts[2])?(' '.$parts[2]):'');
  230.                                                 },
  231.                                                 $str
  232.                                         );
  233.                                 },
  234.                                 explode(',',$options['group'])));
  235.                 }
  236.                 if ($options['order']) {
  237.                         $sql.=' ORDER BY '.implode(',',array_map(
  238.                                 function($str) use($db) {
  239.                                         return preg_match('/^(\w+)(?:\h+(ASC|DESC))?\h*(?:,|$)/i',
  240.                                                 $str,$parts)?
  241.                                                 ($db->quotekey($parts[1]).
  242.                                                 (isset($parts[2])?(' '.$parts[2]):'')):$str;
  243.                                 },
  244.                                 explode(',',$options['order'])));
  245.                 }
  246.                 if (preg_match('/mssql|sqlsrv|odbc/', $this->engine) &&
  247.                         ($options['limit'] || $options['offset'])) {
  248.                         $pkeys=[];
  249.                         foreach ($this->fields as $key=>$field)
  250.                                 if ($field['pkey'])
  251.                                         $pkeys[]=$key;
  252.                         $ofs=$options['offset']?(int)$options['offset']:0;
  253.                         $lmt=$options['limit']?(int)$options['limit']:0;
  254.                         if (strncmp($db->version(),'11',2)>=0) {
  255.                                 // SQL Server 2012
  256.                                 if (!$options['order'])
  257.                                         $sql.=' ORDER BY '.$db->quotekey($pkeys[0]);
  258.                                 $sql.=' OFFSET '.$ofs.' ROWS';
  259.                                 if ($lmt)
  260.                                         $sql.=' FETCH NEXT '.$lmt.' ROWS ONLY';
  261.                         }
  262.                         else {
  263.                                 // SQL Server 2008
  264.                                 $sql=str_replace('SELECT',
  265.                                         'SELECT '.
  266.                                         ($lmt>0?'TOP '.($ofs+$lmt):'').' ROW_NUMBER() '.
  267.                                         'OVER (ORDER BY '.
  268.                                                 $db->quotekey($pkeys[0]).') AS rnum,',$sql);
  269.                                 $sql='SELECT * FROM ('.$sql.') x WHERE rnum > '.($ofs);
  270.                         }
  271.                 }
  272.                 else {
  273.                         if ($options['limit'])
  274.                                 $sql.=' LIMIT '.(int)$options['limit'];
  275.                         if ($options['offset'])
  276.                                 $sql.=' OFFSET '.(int)$options['offset'];
  277.                 }
  278.                 $result=$this->db->exec($sql,$args,$ttl);
  279.                 $out=[];
  280.                 foreach ($result as &$row) {
  281.                         foreach ($row as $field=>&$val) {
  282.                                 if (array_key_exists($field,$this->fields)) {
  283.                                         if (!is_null($val) || !$this->fields[$field]['nullable'])
  284.                                                 $val=$this->db->value(
  285.                                                         $this->fields[$field]['pdo_type'],$val);
  286.                                 }
  287.                                 elseif (array_key_exists($field,$this->adhoc))
  288.                                         $this->adhoc[$field]['value']=$val;
  289.                                 unset($val);
  290.                         }
  291.                         $out[]=$this->factory($row);
  292.                         unset($row);
  293.                 }
  294.                 return $out;
  295.         }
  296.  
  297.         /**
  298.         *       Return records that match criteria
  299.         *       @return static[]
  300.         *       @param $filter string|array
  301.         *       @param $options array
  302.         *       @param $ttl int|array
  303.         **/
  304.         function find($filter=NULL,array $options=NULL,$ttl=0) {
  305.                 if (!$options)
  306.                         $options=[];
  307.                 $options+=[
  308.                         'group'=>NULL,
  309.                         'order'=>NULL,
  310.                         'limit'=>0,
  311.                         'offset'=>0
  312.                 ];
  313.                 $adhoc='';
  314.                 foreach ($this->adhoc as $key=>$field)
  315.                         $adhoc.=','.$field['expr'].' AS '.$this->db->quotekey($key);
  316.                 return $this->select(
  317.                         ($options['group'] && !preg_match('/mysql|sqlite/',$this->engine)?
  318.                                 $options['group']:
  319.                                 implode(',',array_map([$this->db,'quotekey'],
  320.                                         array_keys($this->fields)))).$adhoc,$filter,$options,$ttl);
  321.         }
  322.  
  323.         /**
  324.         *       Count records that match criteria
  325.         *       @return int
  326.         *       @param $filter string|array
  327.         *       @param $ttl int|array
  328.         **/
  329.         function count($filter=NULL,$ttl=0) {
  330.                 $sql='SELECT COUNT(*) AS '.
  331.                         $this->db->quotekey('rows').' FROM '.$this->table;
  332.                 $args=[];
  333.                 if ($filter) {
  334.                         if (is_array($filter)) {
  335.                                 $args=isset($filter[1]) && is_array($filter[1])?
  336.                                         $filter[1]:
  337.                                         array_slice($filter,1,NULL,TRUE);
  338.                                 $args=is_array($args)?$args:[1=>$args];
  339.                                 list($filter)=$filter;
  340.                         }
  341.                         $sql.=' WHERE '.$filter;
  342.                 }
  343.                 $result=$this->db->exec($sql,$args,$ttl);
  344.                 return $result[0]['rows'];
  345.         }
  346.  
  347.         /**
  348.         *       Return record at specified offset using same criteria as
  349.         *       previous load() call and make it active
  350.         *       @return array
  351.         *       @param $ofs int
  352.         **/
  353.         function skip($ofs=1) {
  354.                 $out=parent::skip($ofs);
  355.                 $dry=$this->dry();
  356.                 foreach ($this->fields as $key=>&$field) {
  357.                         $field['value']=$dry?NULL:$out->fields[$key]['value'];
  358.                         $field['initial']=$field['value'];
  359.                         $field['changed']=FALSE;
  360.                         if ($field['pkey'])
  361.                                 $field['previous']=$dry?NULL:$out->fields[$key]['value'];
  362.                         unset($field);
  363.                 }
  364.                 foreach ($this->adhoc as $key=>&$field) {
  365.                         $field['value']=$dry?NULL:$out->adhoc[$key]['value'];
  366.                         unset($field);
  367.                 }
  368.                 if (!$dry && isset($this->trigger['load']))
  369.                         \Base::instance()->call($this->trigger['load'],$this);
  370.                 return $out;
  371.         }
  372.  
  373.         /**
  374.         *       Insert new record
  375.         *       @return object
  376.         **/
  377.         function insert() {
  378.                 $args=[];
  379.                 $actr=0;
  380.                 $nctr=0;
  381.                 $fields='';
  382.                 $values='';
  383.                 $filter='';
  384.                 $pkeys=[];
  385.                 $nkeys=[];
  386.                 $ckeys=[];
  387.                 $inc=NULL;
  388.                 foreach ($this->fields as $key=>$field)
  389.                         if ($field['pkey'])
  390.                                 $pkeys[$key]=$field['previous'];
  391.                 if (isset($this->trigger['beforeinsert']) &&
  392.                         \Base::instance()->call($this->trigger['beforeinsert'],
  393.                                 [$this,$pkeys])===FALSE)
  394.                         return $this;
  395.                 foreach ($this->fields as $key=>&$field) {
  396.                         if ($field['pkey']) {
  397.                                 $field['previous']=$field['value'];
  398.                                 if (!$inc && $field['pdo_type']==\PDO::PARAM_INT &&
  399.                                         empty($field['value']) && !$field['nullable'])
  400.                                         $inc=$key;
  401.                                 $filter.=($filter?' AND ':'').$this->db->quotekey($key).'=?';
  402.                                 $nkeys[$nctr+1]=[$field['value'],$field['pdo_type']];
  403.                                 $nctr++;
  404.                         }
  405.                         if ($field['changed'] && $key!=$inc) {
  406.                                 $fields.=($actr?',':'').$this->db->quotekey($key);
  407.                                 $values.=($actr?',':'').'?';
  408.                                 $args[$actr+1]=[$field['value'],$field['pdo_type']];
  409.                                 $actr++;
  410.                                 $ckeys[]=$key;
  411.                         }
  412.                         $field['changed']=FALSE;
  413.                         unset($field);
  414.                 }
  415.                 if ($fields) {
  416.                         $this->db->exec(
  417.                                 (preg_match('/mssql|dblib|sqlsrv/',$this->engine) &&
  418.                                 array_intersect(array_keys($pkeys),$ckeys)?
  419.                                         'SET IDENTITY_INSERT '.$this->table.' ON;':'').
  420.                                 'INSERT INTO '.$this->table.' ('.$fields.') '.
  421.                                 'VALUES ('.$values.')',$args
  422.                         );
  423.                         $seq=NULL;
  424.                         if ($this->engine=='pgsql') {
  425.                                 $names=array_keys($pkeys);
  426.                                 $aik=end($names);
  427.                                 if ($this->fields[$aik]['pdo_type']==\PDO::PARAM_INT)
  428.                                         $seq=$this->source.'_'.$aik.'_seq';
  429.                         }
  430.                         if ($this->engine!='oci' && !($this->engine=='pgsql' && !$seq))
  431.                                 $this->_id=$this->db->lastinsertid($seq);
  432.                         // Reload to obtain default and auto-increment field values
  433.                         if ($inc || $filter)
  434.                                 $this->load($inc?
  435.                                         [$inc.'=?',$this->db->value(
  436.                                                 $this->fields[$inc]['pdo_type'],$this->_id)]:
  437.                                         [$filter,$nkeys]);
  438.                         if (isset($this->trigger['afterinsert']))
  439.                                 \Base::instance()->call($this->trigger['afterinsert'],
  440.                                         [$this,$pkeys]);
  441.                 }
  442.                 return $this;
  443.         }
  444.  
  445.         /**
  446.         *       Update current record
  447.         *       @return object
  448.         **/
  449.         function update() {
  450.                 $args=[];
  451.                 $ctr=0;
  452.                 $pairs='';
  453.                 $filter='';
  454.                 $pkeys=[];
  455.                 foreach ($this->fields as $key=>$field)
  456.                         if ($field['pkey'])
  457.                                 $pkeys[$key]=$field['previous'];
  458.                 if (isset($this->trigger['beforeupdate']) &&
  459.                         \Base::instance()->call($this->trigger['beforeupdate'],
  460.                                 [$this,$pkeys])===FALSE)
  461.                         return $this;
  462.                 foreach ($this->fields as $key=>$field)
  463.                         if ($field['changed']) {
  464.                                 $pairs.=($pairs?',':'').$this->db->quotekey($key).'=?';
  465.                                 $args[++$ctr]=[$field['value'],$field['pdo_type']];
  466.                         }
  467.                 foreach ($this->fields as $key=>$field)
  468.                         if ($field['pkey']) {
  469.                                 $filter.=($filter?' AND ':' WHERE ').
  470.                                         $this->db->quotekey($key).'=?';
  471.                                 $args[++$ctr]=[$field['previous'],$field['pdo_type']];
  472.                         }
  473.                 if ($pairs) {
  474.                         $sql='UPDATE '.$this->table.' SET '.$pairs.$filter;
  475.                         $this->db->exec($sql,$args);
  476.                         if (isset($this->trigger['afterupdate']))
  477.                                 \Base::instance()->call($this->trigger['afterupdate'],
  478.                                         [$this,$pkeys]);
  479.                 }
  480.                 // reset changed flag after calling afterupdate
  481.                 foreach ($this->fields as $key=>&$field) {
  482.                                 $field['changed']=FALSE;
  483.                                 $field['initial']=$field['value'];
  484.                                 unset($field);
  485.                         }
  486.                 return $this;
  487.         }
  488.  
  489.         /**
  490.         *       Delete current record
  491.         *       @return int
  492.         *       @param $filter string|array
  493.         **/
  494.         function erase($filter=NULL) {
  495.                 if ($filter) {
  496.                         $args=[];
  497.                         if (is_array($filter)) {
  498.                                 $args=isset($filter[1]) && is_array($filter[1])?
  499.                                         $filter[1]:
  500.                                         array_slice($filter,1,NULL,TRUE);
  501.                                 $args=is_array($args)?$args:[1=>$args];
  502.                                 list($filter)=$filter;
  503.                         }
  504.                         return $this->db->
  505.                                 exec('DELETE FROM '.$this->table.' WHERE '.$filter.';',$args);
  506.                 }
  507.                 $args=[];
  508.                 $ctr=0;
  509.                 $filter='';
  510.                 $pkeys=[];
  511.                 foreach ($this->fields as $key=>&$field) {
  512.                         if ($field['pkey']) {
  513.                                 $filter.=($filter?' AND ':'').$this->db->quotekey($key).'=?';
  514.                                 $args[$ctr+1]=[$field['previous'],$field['pdo_type']];
  515.                                 $pkeys[$key]=$field['previous'];
  516.                                 $ctr++;
  517.                         }
  518.                         $field['value']=NULL;
  519.                         $field['changed']=(bool)$field['default'];
  520.                         if ($field['pkey'])
  521.                                 $field['previous']=NULL;
  522.                         unset($field);
  523.                 }
  524.                 foreach ($this->adhoc as &$field) {
  525.                         $field['value']=NULL;
  526.                         unset($field);
  527.                 }
  528.                 parent::erase();
  529.                 if (isset($this->trigger['beforeerase']) &&
  530.                         \Base::instance()->call($this->trigger['beforeerase'],
  531.                                 [$this,$pkeys])===FALSE)
  532.                         return 0;
  533.                 $out=$this->db->
  534.                         exec('DELETE FROM '.$this->table.' WHERE '.$filter.';',$args);
  535.                 if (isset($this->trigger['aftererase']))
  536.                         \Base::instance()->call($this->trigger['aftererase'],
  537.                                 [$this,$pkeys]);
  538.                 return $out;
  539.         }
  540.  
  541.         /**
  542.         *       Reset cursor
  543.         *       @return NULL
  544.         **/
  545.         function reset() {
  546.                 foreach ($this->fields as &$field) {
  547.                         $field['value']=NULL;
  548.                         $field['initial']=NULL;
  549.                         $field['changed']=FALSE;
  550.                         if ($field['pkey'])
  551.                                 $field['previous']=NULL;
  552.                         unset($field);
  553.                 }
  554.                 foreach ($this->adhoc as &$field) {
  555.                         $field['value']=NULL;
  556.                         unset($field);
  557.                 }
  558.                 parent::reset();
  559.         }
  560.  
  561.         /**
  562.         *       Hydrate mapper object using hive array variable
  563.         *       @return NULL
  564.         *       @param $var array|string
  565.         *       @param $func callback
  566.         **/
  567.         function copyfrom($var,$func=NULL) {
  568.                 if (is_string($var))
  569.                         $var=\Base::instance()->get($var);
  570.                 if ($func)
  571.                         $var=call_user_func($func,$var);
  572.                 foreach ($var as $key=>$val)
  573.                         if (in_array($key,array_keys($this->fields)))
  574.                                 $this->set($key,$val);
  575.         }
  576.  
  577.         /**
  578.         *       Populate hive array variable with mapper fields
  579.         *       @return NULL
  580.         *       @param $key string
  581.         **/
  582.         function copyto($key) {
  583.                 $var=&\Base::instance()->ref($key);
  584.                 foreach ($this->fields+$this->adhoc as $key=>$field)
  585.                         $var[$key]=$field['value'];
  586.         }
  587.  
  588.         /**
  589.         *       Return schema and, if the first argument is provided, update it
  590.         *       @return array
  591.         *       @param $fields NULL|array
  592.         **/
  593.         function schema($fields=null) {
  594.                 if ($fields)
  595.                         $this->fields = $fields;
  596.                 return $this->fields;
  597.         }
  598.  
  599.         /**
  600.         *       Return field names
  601.         *       @return array
  602.         *       @param $adhoc bool
  603.         **/
  604.         function fields($adhoc=TRUE) {
  605.                 return array_keys($this->fields+($adhoc?$this->adhoc:[]));
  606.         }
  607.  
  608.         /**
  609.         *       Return TRUE if field is not nullable
  610.         *       @return bool
  611.         *       @param $field string
  612.         **/
  613.         function required($field) {
  614.                 return isset($this->fields[$field]) &&
  615.                         !$this->fields[$field]['nullable'];
  616.         }
  617.  
  618.         /**
  619.         *       Retrieve external iterator for fields
  620.         *       @return object
  621.         **/
  622.         function getiterator() {
  623.                 return new \ArrayIterator($this->cast());
  624.         }
  625.  
  626.         /**
  627.         *       Instantiate class
  628.         *       @param $db object
  629.         *       @param $table string
  630.         *       @param $fields array|string
  631.         *       @param $ttl int|array
  632.         **/
  633.         function __construct(\DB\SQL $db,$table,$fields=NULL,$ttl=60) {
  634.                 $this->db=$db;
  635.                 $this->engine=$db->driver();
  636.                 if ($this->engine=='oci')
  637.                         $table=strtoupper($table);
  638.                 $this->source=$table;
  639.                 $this->table=$this->db->quotekey($table);
  640.                 $this->fields=$db->schema($table,$fields,$ttl);
  641.                 $this->reset();
  642.         }
  643.  
  644. }
  645.  
单独下载 单独下载mapper.php源码 - 下载整个fatfree源程序
相关源码/软件:
TSA-Travel-Sentry-master-keys - TSA 主密钥的 3D 再现 2017-05-12
python3-cookbook - 《Python Cookbook》 3rd Edition Translatio 2017-05-12
isso - Disqus 替代 https://posativ.org/isso/ 2017-05-12
hologram - 降价基于文件系统的风格指南。 http://trulia.github.io... 2017-05-12
www.html5rocks.com - .......a 争创一流资源为 web 开发人员 2017-05-12
rolify - Role management library with resource scoping ... 2017-05-13
jquery-mockjax - JQuery Mockjax 插件提供了简单、 极其灵活的接口,以嘲笑或模拟 ajax 请求和响应 2017-05-13
yo - CLI 工具运行自耕农发电机 http://yeoman.io 2017-05-13
GrowingTextView - UITextView 增长/收缩与文本并开始滚动时的含量达到一定数量的行。类似于苹果在 SMS 应用... 2017-05-13
phan - 潘是 php 的静态分析器。潘倾向于避免误报,并试图证明不正确,而不是正确性。 2017-05-13
CRYENGINE - CRYENGINE 是由 Crytek 创建一个功能强大的实时游戏开发平台。 ... 2017-06-11
postal - 2017-06-11
reactide - Reactide 是反应 web 应用程序开发的第一个专用的 IDE。http://reactide... 2017-06-11
rkt - rkt 是为 Linux 的 pod 本机容器引擎。它是可组合、 安全和建筑标准。 2017-06-11
uWebSockets - 小小的 Websocket https://forest.webvrexpe... 2017-06-11
realworld - 真实的世界-动力反应、 角、 节点,Django,和更多的模范 fullstack Medium.c... 2017-06-11
goreplay - GoReplay 是用于捕获和重播活 HTTP 交通到测试环境以不断地测试您的系统与实际数据的开源工... 2017-06-10
pyenv - 简单的 Python 版本管理 2017-06-10
redux-saga - Redux 应用程序替代副作用模型 https://redux-saga.g... 2017-06-10
angular-starter - 2017-06-10

 返回顶部