当前位置：Gxlcms > PHP教程 > PHP数据库表操作的封装类及用法实例详解

PHP数据库表操作的封装类及用法实例详解

时间：2021-07-01 10:21:17 帮助过：40人阅读

本文实例讲述了PHP数据库表操作的封装类及用法。分享给大家供大家参考，具体如下：

数据库表结构：

  1. CREATE TABLE `test_user` (
  2. `id` int(11) NOT NULL AUTO_INCREMENT,
  3. `username` varchar(45) NOT NULL,
  4. `password` varchar(45) NOT NULL,
  5. `nickname` varchar(45) NOT NULL,
  6. `r` tinyint(4) NOT NULL,
  7. PRIMARY KEY (`id`)
  8. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  9. CREATE TABLE `test_blog` (
  10.  `id` int(11) NOT NULL AUTO_INCREMENT,
  11.  `user_id` int(11) NOT NULL,
  12.  `title` varchar(45) NOT NULL,
  13.  PRIMARY KEY (`id`)
  14. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

设置字符编码：

  1. header('Content-Type: text/html; charset=utf-8');

引入Table类：

  1. require 'Table.php';

设置数据库参数：

  1. Table::$__host = '127.0.0.1:3306';
  2. Table::$__user = 'root';
  3. Table::$__pass = '123456';
  4. Table::$__name = 'test';
  5. Table::$__charset = 'utf8';

创建实体对象：

Table类有三个参数: $table, $pk, $pdo=null

$table: 表名称.
$pk: 主键名称. 不支持联合主键
$pdo: 独立的PDO对象. 一般不需要传
Notice: Table类是表操作的封装,不是Model层的基类,所以不支持表前缀,表前缀应该在Model层实现

  1. $userTable = new Table('test_blog');
  2. $blogTable = new Table('test_blog');

插入数据：

  1. $user = array(
  2.     'username' => "admin1",
  3.     'password' => "admin1",
  4.     'nickname' => "管理员1",
  5.     'r' => mt_rand(0, 5),
  6. );
  7. echo $userTable->insert($user)->rowCount(), "\n";
  8. echo $userTable->lastInsertId(), "\n";

批量插入数据：

  1. $fields = array('username','password','nickname','r');
  2. for ($i=2; $i<=100; $i++) {
  3.   $rows[] = array("admin$i", "admin$i", "管理员$i", mt_rand(0, 5));
  4. }
  5. $userTable->batchInsert($fields, $rows);

查询所有数据：

select方法返回一个PDOStatement对象, fetchAll返回多行, fetch返回单行

  1. var_dump($userTable->select()->fetchAll());

field自定义：

  1. var_dump($userTable->select('id,nickname')->fetchAll());

where查询：

  1. var_dump($userTable->where('id > ?', 50)->select()->fetchAll());

where and条件：

  1. var_dump($userTable->where('id > ?', 6)->where('id in (?)', array(5,7,9))
  2.   ->select()->fetchAll());

where or条件：

  1. var_dump($userTable->where('id = ? OR id = ?', 6, 8)->select()->fetchAll());

group分组 having过滤：

  1. var_dump($userTable->group('r')->having('c between ? and ?', 10, 20)
  2.   ->select('*, r, count(*) as c')->fetchAll());

order排序：

  1. var_dump($userTable->order('r desc, id')->select()->fetchAll());

limit 行数：

跳过30行 返回10行

  1. var_dump($userTable->limitOffset(10, 30)->select()->fetchAll());

查询单行：

  1. var_dump($userTable->where('id = ?', 6)->select()->fetch());

根据主键查询数据：

  1. var_dump($userTable->find(4));

update更新数据：

  1. $user = array( 'username' => 'admin4-1', 'nickname' => '管理员4-1', );
  2. echo $userTable->where('id = ?', 4)->update($user)->rowCount(), "\n";

replace替换数据：

使用了MySQL的REPLACE语句

  1. $user = array(
  2.     'id' => 4,
  3.     'username' => 'admin4',
  4.     'password' => 'admin4',
  5.     'nickname' => '管理员4',
  6.     'r' => mt_rand(0, 5),
  7. );
  8. echo $userTable->replace($user)->rowCount(), "\n";

删除数据：

  1. echo $userTable->where('id = ?', 4)->delete()->rowCount(), "\n";

分页查询

第2页, 每页10行数据：

  1. var_dump($userTable->page(2, 10)->select()->fetchAll());

分页查询的总行数：

  1. $userTable->where('r=?', 3)->order('id desc')->page(2, 10)
  2.   ->select()->fetchAll();
  3. echo $userTable->count(), "\n";

复杂查询：

  1. var_dump($userTable->where('id > ?', 1)->where('id < ?', 100)
  2.   ->group('r')->having('c between ? and ?', 1, 100)->having('c > ?', 1)
  3.   ->order('c desc')->page(2, 3)->select('*, count(*) as c')->fetchAll());

自增：

  1. $id = 2;
  2. // 加一
  3. var_dump($userTable->where('id = ?', $id)->plus('r')->find($id));
  4. // 减一
  5. var_dump($userTable->where('id = ?', $id)->plus('r', -1)->find($id));
  6. // 多列
  7. var_dump($userTable->where('id = ?', $id)->plus('r', 1, 'r', -1)->find($id));

自增,并获得自增后的值：

  1. $id = 2;
  2. // 加一
  3. echo $userTable->where('id = ?', $id)->incr('r'), "\n";
  4. // 减一
  5. echo $userTable->where('id = ?', $id)->incr('r', -1), "\n";

save 保存修改：

判断数据中是否存在主键字段,如果存在主键字段就update数据,反之insert数据

  1. // 修改
  2. $user = array(
  3.   'id' => 3,
  4.   'nickname' => '管理员3-3',
  5. );
  6. echo $userTable->save($user)->rowCount(), "\n";
  7. var_dump($userTable->find(3));
  8. // 添加
  9. $user = array(
  10.     'username' => 'admin11',
  11.     'password' => 'admin11',
  12.     'nickname' => '管理员11',
  13.     'r' => mt_rand(0, 5),
  14. );
  15. echo $userTable->save($user)->rowCount(), "\n";
  16. $id = $userTable->lastInsertId();
  17. var_dump($userTable->find($id));

生成外表测试数据：

  1. $users = $userTable->select('id')->fetchAll();
  2. $id = 0;
  3. foreach ($users as $user) {
  4.   for ($i=0; $i<10; $i++) {
  5.     $id++;
  6.     $blog = array(
  7.         'user_id' => $user['id'],
  8.         'title' => "blog$id",
  9.     );
  10.     $blogTable->insert($blog);
  11.   }
  12. }

Table类不支持JOIN查询

需要的朋友可以手写sql语句,使用query方法来执行.或者自己修改Table类来支持JOIN

获取外表数据：

  1. $blogs = $blogTable->where('id in (?)', array(1,12,23,34,56,67,78,89,90,101))
  2.   ->select()->fetchAll();
  3. // 获取外表数据 key为外表id value为外表行数据
  4. var_dump($userTable->foreignKey($blogs, 'user_id')
  5.   ->fetchAll(PDO::FETCH_UNIQUE));
  6. var_dump($userTable->foreignKey($blogs, 'user_id', '*,id')
  7.   ->fetchAll(PDO::FETCH_UNIQUE));
  8. var_dump($userTable->foreignKey($blogs, 'user_id', 'id,username,nickanem,id')
  9.   ->fetchAll(PDO::FETCH_UNIQUE));
  10. // 获取外表数据 返回键值对数组 key为id value为username
  11. var_dump($userTable->foreignKey($blogs, 'user_id', 'id,username')
  12.   ->fetchAll(PDO::FETCH_KEY_PAIR));

PDOStatement::fetchAll 示例：

  1. // 获取映射数据
  2. var_dump($userTable->select('*, id')->fetchAll(PDO::FETCH_UNIQUE));
  3. // 获取数组
  4. var_dump($userTable->select('nickname')->fetchAll(PDO::FETCH_COLUMN));
  5. // 获取键值对
  6. var_dump($userTable->select('id, nickname')->fetchAll(PDO::FETCH_KEY_PAIR));
  7. // 获取数据分组
  8. var_dump($userTable->select('r, id, nickname')->fetchAll(PDO::FETCH_GROUP));
  9. // 获取数据分组
  10. var_dump($userTable->select('r, id')->fetchAll(PDO::FETCH_GROUP|PDO::FETCH_COLUMN));
  11. // 获取数据分组
  12. var_dump($userTable->select('r, nickname')->fetchAll(PDO::FETCH_GROUP|PDO::FETCH_KEY_PAIR));
  13. // 获取对象 指定获取方式，将结果集中的每一行作为一个属性名对应列名的对象返回。
  14. var_dump($userTable->select()->fetchAll(PDO::FETCH_OBJ));
  15. // 获取对象 指定获取方式，返回一个所请求类的新实例，映射列到类中对应的属性名。
  16. // Note: 如果所请求的类中不存在该属性，则调用 __set() 魔术方法
  17. var_dump($userTable->select()->fetchAll(PDO::FETCH_CLASS));
  18. // 获取对象 指定获取方式，更新一个请求类的现有实例，映射列到类中对应的属性名。
  19. var_dump($userTable->select()->fetchAll(PDO::FETCH_INTO));
  20. // 获取自定义行
  21. var_dump($userTable->select()->fetchAll(PDO::FETCH_FUNC, function($id, $username, $password, $r){
  22.   return array('id'=>$id, 'name'=>"$username - $password - $r");
  23. }));
  24. // 获取单一值
  25. var_dump($userTable->select()->fetchAll(PDO::FETCH_FUNC, function($id, $username, $password, $r){
  26.   return "$id - $username - $password - $r";
  27. }));

Table类源代码：

  1. <?php
  2. /**
  3.  * @author dotcoo zhao <dotcoo at 163 dot com>
  4.  */
  5. /**
  6.  * 模型
  7. */
  8. class Table {
  9.   /**
  10.    * @var PDO
  11.    */
  12.   public static $__pdo = null;      // 默认PDO对象
  13.   public static $__host = '127.0.0.1';  // 默认主机
  14.   public static $__user = 'root';     // 默认账户
  15.   public static $__pass = '123456';    // 默认密码
  16.   public static $__name = 'test';     // 默认数据库名称
  17.   public static $__charset = 'utf8';   // 默认字符集
  18.   /**
  19.    * @var PDO
  20.    */
  21.   public $_pdo = null;          // PDO对象
  22.   public $_table = null;         // 表名
  23.   public $_pk = 'id';           // paramry
  24.   public $_where = array();        // where
  25.   public $_where_params = array();    // where params
  26.   public $_count_where = array();     // count where
  27.   public $_count_where_params = array(); // count where params
  28.   public $_group = '';          // group
  29.   public $_having = array();       // having
  30.   public $_having_params = array();    // having params
  31.   public $_order = null;         // order
  32.   public $_limit = null;         // limit
  33.   public $_offset = null;         // offset
  34.   public $_for_update = '';        // read lock
  35.   public $_lock_in_share_model = '';   // write lock
  36.   /**
  37.    * Table Construct
  38.    * @param string $table_name
  39.    * @param string $pk
  40.    * @param string $prefix
  41.    * @param PDO $pdo
  42.    */
  43.   function __construct($table=null, $pk=null, PDO $pdo=null) {
  44.     $this->_table = isset($table) ? $table : $this->_table;
  45.     $this->_pk = isset($pk) ? $pk : $this->_pk;
  46.     $this->_pdo = $pdo;
  47.   }
  48.   /**
  49.    * @return PDO
  50.    */
  51.   public function getPDO() {
  52.     if (isset($this->_pdo)) {
  53.       return $this->_pdo;
  54.     }
  55.     if (isset(self::$__pdo)) {
  56.       return self::$__pdo;
  57.     }
  58.     $dsn = sprintf("mysql:host=%s;dbname=%s;charset=%s;", self::$__host, self::$__name, self::$__charset);
  59.     $options = array(
  60.         PDO::ATTR_PERSISTENT => true,
  61.         PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
  62.         PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
  63.     );
  64.     return self::$__pdo = new PDO($dsn, self::$__user, self::$__pass, $options);
  65.   }
  66.   /**
  67.    * 执行语句
  68.    * @param string $sql
  69.    * @return PDOStatement
  70.    */
  71.   public function query($sql) {
  72.     $params = func_get_args();
  73.     array_shift($params);
  74.     return $this->queryParams($sql, $params);
  75.   }
  76.   /**
  77.    * 执行语句
  78.    * @param string $sql
  79.    * @return PDOStatement
  80.    */
  81.   public function queryParams($sql, array $params) {
  82.     $sqls = explode('?', $sql);
  83.     $sql_new = array_shift($sqls);
  84.     $params_new = array();
  85.     foreach ($sqls as $i => $sql_item) {
  86.       if (is_array($params[$i])) {
  87.         $sql_new .= str_repeat('?,', count($params[$i])-1).'?'.$sql_item;
  88.         $params_new = array_merge($params_new, $params[$i]);
  89.       } else {
  90.         $sql_new .= '?'.$sql_item;
  91.         $params_new[] = $params[$i];
  92.       }
  93.     }
  94.     $stmt = $this->getPDO()->prepare($sql_new);
  95.     foreach ($params_new as $i => $param) {
  96.       switch (gettype($param)) {
  97.         case 'integer':
  98.           $stmt->bindValue($i+1, $param, PDO::PARAM_INT);
  99.           break;
  100.         case 'NULL':
  101.           $stmt->bindValue($i+1, $param, PDO::PARAM_NULL);
  102.           break;
  103.         default :
  104.           $stmt->bindValue($i+1, $param);
  105.       }
  106.     }
  107. //   echo $sql_new, "\n"; var_dump($params_new); // exit();
  108.     $stmt->executeResult = $stmt->execute();
  109.     $this->reset();
  110.     return $stmt;
  111.   }
  112.   /**
  113.    * 查询数据
  114.    * @param string $field
  115.    * @return PDOStatement
  116.    */
  117.   public function select($columns='*') {
  118.     $params = array_merge($this->_where_params, $this->_having_params);
  119.     $sql = "SELECT $columns FROM `{$this->_table}`";
  120.     $sql .= empty($this->_where) ? '' : ' WHERE '. implode(' AND ', $this->_where);
  121.     $sql .= empty($this->_group) ? '' : ' GROUP BY '. $this->_group;
  122.     $sql .= empty($this->_having) ? '' : ' HAVING '. implode(' AND ', $this->_having);
  123.     $sql .= empty($this->_order) ? '' : ' ORDER BY '. $this->_order;
  124.     if (isset($this->_limit)) {
  125.       $sql .= ' LIMIT ?';
  126.       $params[] = $this->_limit;
  127.       if (isset($this->_offset)) {
  128.         $sql .= ' OFFSET ?';
  129.         $params[] = $this->_offset;
  130.       }
  131.     }
  132.     $sql .= $this->_for_update;
  133.     $sql .= $this->_lock_in_share_model;
  134.     $this->_count_where = $this->_where;
  135.     $this->_count_where_params = $this->_where_params;
  136.     return $this->queryParams($sql, $params);
  137.   }
  138.   /**
  139.    * 添加数据
  140.    * @param array $data
  141.    * @return PDOStatement
  142.    */
  143.   public function insert(array $data) {
  144.     $sql = "INSERT `{$this->_table}` SET";
  145.     $params = array();
  146.     foreach ($data as $col=>$val) {
  147.       $sql .= " `$col` = ?,";
  148.       $params[] = $val;
  149.     }
  150.     $sql{strlen($sql)-1} = ' ';
  151.     return $this->queryParams($sql, $params);
  152.   }
  153.   /**
  154.    * 批量插入数据
  155.    * @param array $names
  156.    * @param array $rows
  157.    * @param number $batch
  158.    * @return Table
  159.    */
  160.   public function batchInsert(array $fields, array $rows, $batch=1000) {
  161.     $i = 0;
  162.     $sql = "INSERT `{$this->_table}` (`".implode('`, `', $fields)."`) VALUES ";
  163.     foreach ($rows as $row) {
  164.       $i++;
  165.       $sql .= "('".implode("','", array_map('addslashes', $row))."'),";
  166.       if ($i >= $batch) {
  167.         $sql{strlen($sql)-1} = ' ';
  168.         $this->query($sql);
  169.         $i = 0;
  170.         $sql = "INSERT `{$this->_table}` (`".implode('`, `', $fields)."`) VALUES ";
  171.       }
  172.     }
  173.     if ($i > 0) {
  174.       $sql{strlen($sql)-1} = ' ';
  175.       $this->query($sql);
  176.     }
  177.     return $this;
  178.   }
  179.   /**
  180.    * 更新数据
  181.    * @param array $data
  182.    * @return PDOStatement
  183.    */
  184.   public function update(array $data) {
  185.     $sql = "UPDATE `{$this->_table}` SET";
  186.     $params = array();
  187.     foreach ($data as $col=>$val) {
  188.       $sql .= " `$col` = ?,";
  189.       $params[] = $val;
  190.     }
  191.     $sql{strlen($sql)-1} = ' ';
  192.     $sql .= empty($this->_where) ? '' : 'WHERE '. implode(' AND ', $this->_where);
  193.     $params = array_merge($params, $this->_where_params);
  194.     return $this->queryParams($sql, $params);
  195.   }
  196.   /**
  197.    * 替换数据
  198.    * @param array $data
  199.    * @return PDOStatement
  200.    */
  201.   public function replace(array $data) {
  202.     $sql = "REPLACE `{$this->_table}` SET";
  203.     $params = array();
  204.     foreach ($data as $col=>$val) {
  205.       $sql .= " `$col` = ?,";
  206.       $params[] = $val;
  207.     }
  208.     $sql{strlen($sql)-1} = ' ';
  209.     $sql .= empty($this->_where) ? '' : 'WHERE '. implode(' AND ', $this->_where);
  210.     $params = array_merge($params, $this->_where_params);
  211.     return $this->queryParams($sql, $params);
  212.   }
  213.   /**
  214.    * 删除数据
  215.    * @return PDOStatement
  216.    */
  217.   public function delete() {
  218.     $sql = "DELETE FROM `{$this->_table}`";
  219.     $sql .= empty($this->_where) ? '' : ' WHERE '. implode(' AND ', $this->_where);
  220.     return $this->queryParams($sql, $this->_where_params);
  221.   }
  222.   /**
  223.    * 重置所有
  224.    * @return Table
  225.    */
  226.   public function reset() {
  227.     $this->_where = array();
  228.     $this->_where_params = array();
  229.     $this->_group = null;
  230.     $this->_having = array();
  231.     $this->_having_params = array();
  232.     $this->_order = null;
  233.     $this->_limit = null;
  234.     $this->_offset = null;
  235.     $this->_for_update = '';
  236.     $this->_lock_in_share_model = '';
  237.     return $this;
  238.   }
  239.   /**
  240.    * where查询条件
  241.    * @param string $format
  242.    * @return Table
  243.    */
  244.   public function where($format) {
  245.     $args = func_get_args();
  246.     array_shift($args);
  247.     $this->_where[] = $format;
  248.     $this->_where_params = array_merge($this->_where_params, $args);
  249.     return $this;
  250.   }
  251.   /**
  252.    * group分组
  253.    * @param string $columns
  254.    * @return Table
  255.    */
  256.   public function group($columns) {
  257.     $this->_group = $columns;
  258.     return $this;
  259.   }
  260.   /**
  261.    * having过滤条件
  262.    * @param string $format
  263.    * @return Table
  264.    */
  265.   public function having($format) {
  266.     $args = func_get_args();
  267.     array_shift($args);
  268.     $this->_having[] = $format;
  269.     $this->_having_params = array_merge($this->_having_params, $args);
  270.     return $this;
  271.   }
  272.   /**
  273.    * order排序
  274.    * @param string $columns
  275.    * @return Table
  276.    */
  277.   public function order($order) {
  278.     $this->_order = $order;
  279.     return $this;
  280.   }
  281.   /**
  282.    * limit数据偏移
  283.    * @param number $offset
  284.    * @param number $limit
  285.    * @return Table
  286.    */
  287.   public function limitOffset($limit, $offset=null) {
  288.     $this->_limit = $limit;
  289.     $this->_offset = $offset;
  290.     return $this;
  291.   }
  292.   /**
  293.    * 独占锁，不可读不可写
  294.    * @return Table
  295.    */
  296.   public function forUpdate() {
  297.     $this->forUpdate = ' FOR UPDATE';
  298.     return $this;
  299.   }
  300.   /**
  301.    * 共享锁，可读不可写
  302.    * @return Table
  303.    */
  304.   public function lockInShareMode() {
  305.     $this->_lock_in_share_model = ' LOCK IN SHARE MODE';
  306.     return $this;
  307.   }
  308.   /**
  309.    * 事务开始
  310.    * @return bool
  311.    */
  312.   public function begin() {
  313.     return $this->getPDO()->beginTransaction();
  314.   }
  315.   /**
  316.    * 事务提交
  317.    * @return bool
  318.    */
  319.   public function commit() {
  320.     return $this->getPDO()->commit();
  321.   }
  322.   /**
  323.    * 事务回滚
  324.    * @return bool
  325.    */
  326.   public function rollBack() {
  327.     return $this->getPDO()->rollBack();
  328.   }
  329.   /**
  330.    * page分页
  331.    * @param number $page
  332.    * @param number $pagesize
  333.    * @return Table
  334.    */
  335.   public function page($page, $pagesize = 15) {
  336.     $this->_limit = $pagesize;
  337.     $this->_offset = ($page - 1) * $pagesize;
  338.     return $this;
  339.   }
  340.   /**
  341.    * 获取自增ID
  342.    * @return int
  343.    */
  344.   public function lastInsertId() {
  345.     return $this->getPDO()->lastInsertId();
  346.   }
  347.   /**
  348.    * 获取符合条件的行数
  349.    * @return int
  350.    */
  351.   public function count() {
  352.     $sql = "SELECT count(*) FROM `{$this->_table}`";
  353.     $sql .= empty($this->_count_where) ? '' : ' WHERE '. implode(' AND ', $this->_count_where);
  354.     return $this->queryParams($sql, $this->_count_where_params)->fetchColumn();
  355.   }
  356.   /**
  357.    * 将选中行的指定字段加一
  358.    * @param string $col
  359.    * @param number $val
  360.    * @return Table
  361.    */
  362.   public function plus($col, $val = 1) {
  363.     $sets = array("`$col` = `$col` + $val");
  364.     $args = array_slice(func_get_args(), 2);
  365.     while (count($args) > 1) {
  366.       $col = array_shift($args);
  367.       $val = array_shift($args);
  368.       $sets[] = "`$col` = `$col` + $val";
  369.     }
  370.     $sql = "UPDATE `{$this->_table}` SET ".implode(', ', $sets);
  371.     $sql .= empty($this->_where) ? '' : ' WHERE '. implode(' AND ', $this->_where);
  372.     $params = array_merge(array($val), $this->_where_params);
  373.     $this->queryParams($sql, $params);
  374.     return $this;
  375.   }
  376.   /**
  377.    * 将选中行的指定字段加一
  378.    * @param string $col
  379.    * @param number $val
  380.    * @return int
  381.    */
  382.   public function incr($col, $val = 1) {
  383.     $sql = "UPDATE `{$this->_table}` SET `$col` = last_insert_id(`$col` + ?)";
  384.     $sql .= empty($this->_where) ? '' : ' WHERE '. implode(' AND ', $this->_where);
  385.     $params = array_merge(array($val), $this->_where_params);
  386.     $this->queryParams($sql, $params);
  387.     return $this->getPDO()->lastInsertId();
  388.   }
  389.   /**
  390.    * 根据主键查找行
  391.    * @param number $id
  392.    * @return array
  393.    */
  394.   public function find($id) {
  395.     return $this->where("`{$this->_pk}` = ?", $id)->select()->fetch();
  396.   }
  397.   /**
  398.    * 保存数据,自动判断是新增还是更新
  399.    * @param array $data
  400.    * @return PDOStatement
  401.    */
  402.   public function save(array $data) {
  403.     if (array_key_exists($this->_pk, $data)) {
  404.       $pk_val = $data[$this->_pk];
  405.       unset($data[$this->_pk]);
  406.       return $this->where("`{$this->_pk}` = ?", $pk_val)->update($data);
  407.     } else {
  408.       return $this->insert($data);
  409.     }
  410.   }
  411.   /**
  412.    * 获取外键数据
  413.    * @param array $rows
  414.    * @param string $fkey
  415.    * @param string $field
  416.    * @param string $key
  417.    * @return PDOStatement
  418.    */
  419.   public function foreignKey(array $rows, $fkey, $field='*') {
  420.     $ids = array(); foreach($rows as $row) { $ids[] = $row[$fkey]; }
  421. //   $ids = array_column($rows, $fkey);
  422.     if (empty($ids)) {
  423.       return new PDOStatement();
  424.     }
  425.     return $this->where("`{$this->_pk}` in (?)", $ids)->select($field);
  426.   }
  427. }

github地址：

https://github.com/dotcoo/php/blob/master/Table/Table.php

更多关于PHP相关内容感兴趣的读者可查看本站专题：《PHP+MongoDB数据库操作技巧大全》、《PHP基于pdo操作数据库技巧总结》、《php面向对象程序设计入门教程》、《php字符串(string)用法总结》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家PHP程序设计有所帮助。

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！