PHP 데이터베이스 시트 작업 의 패 키 징 클래스 및 용법 인 스 턴 스 상세 설명

24664 단어 PHP 데이터 뱅 크 패키지 클래스

본 논문 의 사례 는 PHP 데이터베이스 시트 작업 의 패 키 징 류 와 용법 을 서술 하 였 다.여러분 께 참고 하도록 공유 하 겠 습 니 다.구체 적 으로 는 다음 과 같 습 니 다.
데이터베이스 테이블 구조:


CREATE TABLE `test_user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(45) NOT NULL,
`password` varchar(45) NOT NULL,
`nickname` varchar(45) NOT NULL,
`r` tinyint(4) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `test_blog` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `user_id` int(11) NOT NULL,
 `title` varchar(45) NOT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

문자 인 코딩 설정:

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

Table 클래스 도입:


require 'Table.php';

데이터베이스 파라미터 설정:


Table::$__host = '127.0.0.1:3306';
Table::$__user = 'root';
Table::$__pass = '123456';
Table::$__name = 'test';
Table::$__charset = 'utf8';

실체 개체 만 들 기:
Table 클래스 는 세 개의 인자 가 있 습 니 다:$table,$pk,$pdo=null
$table:표 이름.
$pk:홈 키 이름 입 니 다.연합 홈 키 는 지원 되 지 않 습 니 다.
$pdo:독립 된 PDO 대상 입 니 다.일반적으로 전송 할 필요 가 없습니다.
Notice:Table 류 는 표 작업 의 패키지 입 니 다.Model 층 의 기본 클래스 가 아니 기 때문에 표 접 두 사 는 지원 되 지 않 습 니 다.표 접 두 사 는 Model 층 에서 이 루어 져 야 합 니 다.


$userTable = new Table('test_blog');
$blogTable = new Table('test_blog');

데이터 삽입:


$user = array(
    'username' => "admin1",
    'password' => "admin1",
    'nickname' => "   1",
    'r' => mt_rand(0, 5),
);
echo $userTable->insert($user)->rowCount(), "
";
echo $userTable->lastInsertId(), "
";

데이터 일괄 삽입:

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

모든 데이터 조회:
select 방법 은 PDOStatement 대상 을 되 돌려 줍 니 다.fetchAll 은 여러 줄 로 되 돌아 가 고 fetch 는 한 줄 로 되 돌아 갑 니 다.

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

field 사용자 정의:

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

where 조회:

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

where and condition 조건:

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

where or condition:

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

그룹 그룹 필터 링:

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

order 정렬:

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

limit 줄 수:
30 줄 건 너 뛰 고 10 줄 로 돌아 가기

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

검색 줄:

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

홈 키 에 따라 데이터 조회:

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

업데이트 업데이트 데이터:


$user = array( 'username' => 'admin4-1', 'nickname' => '   4-1', );
echo $userTable->where('id = ?', 4)->update($user)->rowCount(), "
";

replace 교체 데이터:
MySQL 의 REPLACE 문 구 를 사 용 했 습 니 다.


$user = array(
    'id' => 4,
    'username' => 'admin4',
    'password' => 'admin4',
    'nickname' => '   4',
    'r' => mt_rand(0, 5),
);
echo $userTable->replace($user)->rowCount(), "
";

데이터 삭제:

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

페이지 별 조회
2 페이지,각 페이지 10 줄 데이터:

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

페이지 조회 의 총 줄 수:

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

복잡 한 조회:

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

자동 증가:


$id = 2;
//   
var_dump($userTable->where('id = ?', $id)->plus('r')->find($id));
//   
var_dump($userTable->where('id = ?', $id)->plus('r', -1)->find($id));
//   
var_dump($userTable->where('id = ?', $id)->plus('r', 1, 'r', -1)->find($id));

증가,증가 후의 값 획득:


$id = 2;
//   
echo $userTable->where('id = ?', $id)->incr('r'), "
";
//   
echo $userTable->where('id = ?', $id)->incr('r', -1), "
";

저장 변경 사항 저장:
데이터 에 홈 키 필드 가 존재 하 는 지 판단 하고 홈 키 필드 가 존재 하면 데 이 터 를 업데이트 하 며 반대로 insert 데이터


//   
$user = array(
  'id' => 3,
  'nickname' => '   3-3',
);
echo $userTable->save($user)->rowCount(), "
";
var_dump($userTable->find(3));
//   
$user = array(
    'username' => 'admin11',
    'password' => 'admin11',
    'nickname' => '   11',
    'r' => mt_rand(0, 5),
);
echo $userTable->save($user)->rowCount(), "
";
$id = $userTable->lastInsertId();
var_dump($userTable->find($id));

외모 테스트 데이터 생 성:


$users = $userTable->select('id')->fetchAll();
$id = 0;
foreach ($users as $user) {
  for ($i=0; $i<10; $i++) {
    $id++;
    $blog = array(
        'user_id' => $user['id'],
        'title' => "blog$id",
    );
    $blogTable->insert($blog);
  }
}

Table 클래스 는 JOIN 검색 을 지원 하지 않 습 니 다.
필요 한 친 구 는 sql 문 구 를 손 으로 쓰 고 query 방법 으로 실행 하거나 Table 류 를 수정 하여 JOIN 을 지원 할 수 있 습 니 다.
외부 데이터 가 져 오기:


$blogs = $blogTable->where('id in (?)', array(1,12,23,34,56,67,78,89,90,101))
  ->select()->fetchAll();
//        key   id value      
var_dump($userTable->foreignKey($blogs, 'user_id')
  ->fetchAll(PDO::FETCH_UNIQUE));
var_dump($userTable->foreignKey($blogs, 'user_id', '*,id')
  ->fetchAll(PDO::FETCH_UNIQUE));
var_dump($userTable->foreignKey($blogs, 'user_id', 'id,username,nickanem,id')
  ->fetchAll(PDO::FETCH_UNIQUE));
//                key id value username
var_dump($userTable->foreignKey($blogs, 'user_id', 'id,username')
  ->fetchAll(PDO::FETCH_KEY_PAIR));

PDOStatement::fetchAll 예제:


//       
var_dump($userTable->select('*, id')->fetchAll(PDO::FETCH_UNIQUE));
//     
var_dump($userTable->select('nickname')->fetchAll(PDO::FETCH_COLUMN));
//      
var_dump($userTable->select('id, nickname')->fetchAll(PDO::FETCH_KEY_PAIR));
//       
var_dump($userTable->select('r, id, nickname')->fetchAll(PDO::FETCH_GROUP));
//       
var_dump($userTable->select('r, id')->fetchAll(PDO::FETCH_GROUP|PDO::FETCH_COLUMN));
//       
var_dump($userTable->select('r, nickname')->fetchAll(PDO::FETCH_GROUP|PDO::FETCH_KEY_PAIR));
//            ，                         。
var_dump($userTable->select()->fetchAll(PDO::FETCH_OBJ));
//            ，            ，            。
// Note:               ，    __set()     
var_dump($userTable->select()->fetchAll(PDO::FETCH_CLASS));
//            ，            ，            。
var_dump($userTable->select()->fetchAll(PDO::FETCH_INTO));
//       
var_dump($userTable->select()->fetchAll(PDO::FETCH_FUNC, function($id, $username, $password, $r){
  return array('id'=>$id, 'name'=>"$username - $password - $r");
}));
//      
var_dump($userTable->select()->fetchAll(PDO::FETCH_FUNC, function($id, $username, $password, $r){
  return "$id - $username - $password - $r";
}));

Table 클래스 소스 코드:


<?php
/**
 * @author dotcoo zhao <dotcoo at 163 dot com>
 */
/**
 *   
*/
class Table {
  /**
   * @var PDO
   */
  public static $__pdo = null;      //   PDO  
  public static $__host = '127.0.0.1';  //     
  public static $__user = 'root';     //     
  public static $__pass = '123456';    //     
  public static $__name = 'test';     //        
  public static $__charset = 'utf8';   //      
  /**
   * @var PDO
   */
  public $_pdo = null;          // PDO  
  public $_table = null;         //   
  public $_pk = 'id';           // paramry
  public $_where = array();        // where
  public $_where_params = array();    // where params
  public $_count_where = array();     // count where
  public $_count_where_params = array(); // count where params
  public $_group = '';          // group
  public $_having = array();       // having
  public $_having_params = array();    // having params
  public $_order = null;         // order
  public $_limit = null;         // limit
  public $_offset = null;         // offset
  public $_for_update = '';        // read lock
  public $_lock_in_share_model = '';   // write lock
  /**
   * Table Construct
   * @param string $table_name
   * @param string $pk
   * @param string $prefix
   * @param PDO $pdo
   */
  function __construct($table=null, $pk=null, PDO $pdo=null) {
    $this->_table = isset($table) ? $table : $this->_table;
    $this->_pk = isset($pk) ? $pk : $this->_pk;
    $this->_pdo = $pdo;
  }
  /**
   * @return PDO
   */
  public function getPDO() {
    if (isset($this->_pdo)) {
      return $this->_pdo;
    }
    if (isset(self::$__pdo)) {
      return self::$__pdo;
    }
    $dsn = sprintf("mysql:host=%s;dbname=%s;charset=%s;", self::$__host, self::$__name, self::$__charset);
    $options = array(
        PDO::ATTR_PERSISTENT => true,
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
    );
    return self::$__pdo = new PDO($dsn, self::$__user, self::$__pass, $options);
  }
  /**
   *     
   * @param string $sql
   * @return PDOStatement
   */
  public function query($sql) {
    $params = func_get_args();
    array_shift($params);
    return $this->queryParams($sql, $params);
  }
  /**
   *     
   * @param string $sql
   * @return PDOStatement
   */
  public function queryParams($sql, array $params) {
    $sqls = explode('?', $sql);
    $sql_new = array_shift($sqls);
    $params_new = array();
    foreach ($sqls as $i => $sql_item) {
      if (is_array($params[$i])) {
        $sql_new .= str_repeat('?,', count($params[$i])-1).'?'.$sql_item;
        $params_new = array_merge($params_new, $params[$i]);
      } else {
        $sql_new .= '?'.$sql_item;
        $params_new[] = $params[$i];
      }
    }
    $stmt = $this->getPDO()->prepare($sql_new);
    foreach ($params_new as $i => $param) {
      switch (gettype($param)) {
        case 'integer':
          $stmt->bindValue($i+1, $param, PDO::PARAM_INT);
          break;
        case 'NULL':
          $stmt->bindValue($i+1, $param, PDO::PARAM_NULL);
          break;
        default :
          $stmt->bindValue($i+1, $param);
      }
    }
//   echo $sql_new, "
"; var_dump($params_new); // exit();
    $stmt->executeResult = $stmt->execute();
    $this->reset();
    return $stmt;
  }
  /**
   *     
   * @param string $field
   * @return PDOStatement
   */
  public function select($columns='*') {
    $params = array_merge($this->_where_params, $this->_having_params);
    $sql = "SELECT $columns FROM `{$this->_table}`";
    $sql .= empty($this->_where) ? '' : ' WHERE '. implode(' AND ', $this->_where);
    $sql .= empty($this->_group) ? '' : ' GROUP BY '. $this->_group;
    $sql .= empty($this->_having) ? '' : ' HAVING '. implode(' AND ', $this->_having);
    $sql .= empty($this->_order) ? '' : ' ORDER BY '. $this->_order;
    if (isset($this->_limit)) {
      $sql .= ' LIMIT ?';
      $params[] = $this->_limit;
      if (isset($this->_offset)) {
        $sql .= ' OFFSET ?';
        $params[] = $this->_offset;
      }
    }
    $sql .= $this->_for_update;
    $sql .= $this->_lock_in_share_model;
    $this->_count_where = $this->_where;
    $this->_count_where_params = $this->_where_params;
    return $this->queryParams($sql, $params);
  }
  /**
   *     
   * @param array $data
   * @return PDOStatement
   */
  public function insert(array $data) {
    $sql = "INSERT `{$this->_table}` SET";
    $params = array();
    foreach ($data as $col=>$val) {
      $sql .= " `$col` = ?,";
      $params[] = $val;
    }
    $sql{strlen($sql)-1} = ' ';
    return $this->queryParams($sql, $params);
  }
  /**
   *       
   * @param array $names
   * @param array $rows
   * @param number $batch
   * @return Table
   */
  public function batchInsert(array $fields, array $rows, $batch=1000) {
    $i = 0;
    $sql = "INSERT `{$this->_table}` (`".implode('`, `', $fields)."`) VALUES ";
    foreach ($rows as $row) {
      $i++;
      $sql .= "('".implode("','", array_map('addslashes', $row))."'),";
      if ($i >= $batch) {
        $sql{strlen($sql)-1} = ' ';
        $this->query($sql);
        $i = 0;
        $sql = "INSERT `{$this->_table}` (`".implode('`, `', $fields)."`) VALUES ";
      }
    }
    if ($i > 0) {
      $sql{strlen($sql)-1} = ' ';
      $this->query($sql);
    }
    return $this;
  }
  /**
   *     
   * @param array $data
   * @return PDOStatement
   */
  public function update(array $data) {
    $sql = "UPDATE `{$this->_table}` SET";
    $params = array();
    foreach ($data as $col=>$val) {
      $sql .= " `$col` = ?,";
      $params[] = $val;
    }
    $sql{strlen($sql)-1} = ' ';
    $sql .= empty($this->_where) ? '' : 'WHERE '. implode(' AND ', $this->_where);
    $params = array_merge($params, $this->_where_params);
    return $this->queryParams($sql, $params);
  }
  /**
   *     
   * @param array $data
   * @return PDOStatement
   */
  public function replace(array $data) {
    $sql = "REPLACE `{$this->_table}` SET";
    $params = array();
    foreach ($data as $col=>$val) {
      $sql .= " `$col` = ?,";
      $params[] = $val;
    }
    $sql{strlen($sql)-1} = ' ';
    $sql .= empty($this->_where) ? '' : 'WHERE '. implode(' AND ', $this->_where);
    $params = array_merge($params, $this->_where_params);
    return $this->queryParams($sql, $params);
  }
  /**
   *     
   * @return PDOStatement
   */
  public function delete() {
    $sql = "DELETE FROM `{$this->_table}`";
    $sql .= empty($this->_where) ? '' : ' WHERE '. implode(' AND ', $this->_where);
    return $this->queryParams($sql, $this->_where_params);
  }
  /**
   *     
   * @return Table
   */
  public function reset() {
    $this->_where = array();
    $this->_where_params = array();
    $this->_group = null;
    $this->_having = array();
    $this->_having_params = array();
    $this->_order = null;
    $this->_limit = null;
    $this->_offset = null;
    $this->_for_update = '';
    $this->_lock_in_share_model = '';
    return $this;
  }
  /**
   * where    
   * @param string $format
   * @return Table
   */
  public function where($format) {
    $args = func_get_args();
    array_shift($args);
    $this->_where[] = $format;
    $this->_where_params = array_merge($this->_where_params, $args);
    return $this;
  }
  /**
   * group  
   * @param string $columns
   * @return Table
   */
  public function group($columns) {
    $this->_group = $columns;
    return $this;
  }
  /**
   * having    
   * @param string $format
   * @return Table
   */
  public function having($format) {
    $args = func_get_args();
    array_shift($args);
    $this->_having[] = $format;
    $this->_having_params = array_merge($this->_having_params, $args);
    return $this;
  }
  /**
   * order  
   * @param string $columns
   * @return Table
   */
  public function order($order) {
    $this->_order = $order;
    return $this;
  }
  /**
   * limit    
   * @param number $offset
   * @param number $limit
   * @return Table
   */
  public function limitOffset($limit, $offset=null) {
    $this->_limit = $limit;
    $this->_offset = $offset;
    return $this;
  }
  /**
   *    ，      
   * @return Table
   */
  public function forUpdate() {
    $this->forUpdate = ' FOR UPDATE';
    return $this;
  }
  /**
   *    ，     
   * @return Table
   */
  public function lockInShareMode() {
    $this->_lock_in_share_model = ' LOCK IN SHARE MODE';
    return $this;
  }
  /**
   *     
   * @return bool
   */
  public function begin() {
    return $this->getPDO()->beginTransaction();
  }
  /**
   *     
   * @return bool
   */
  public function commit() {
    return $this->getPDO()->commit();
  }
  /**
   *     
   * @return bool
   */
  public function rollBack() {
    return $this->getPDO()->rollBack();
  }
  /**
   * page  
   * @param number $page
   * @param number $pagesize
   * @return Table
   */
  public function page($page, $pagesize = 15) {
    $this->_limit = $pagesize;
    $this->_offset = ($page - 1) * $pagesize;
    return $this;
  }
  /**
   *     ID
   * @return int
   */
  public function lastInsertId() {
    return $this->getPDO()->lastInsertId();
  }
  /**
   *          
   * @return int
   */
  public function count() {
    $sql = "SELECT count(*) FROM `{$this->_table}`";
    $sql .= empty($this->_count_where) ? '' : ' WHERE '. implode(' AND ', $this->_count_where);
    return $this->queryParams($sql, $this->_count_where_params)->fetchColumn();
  }
  /**
   *            
   * @param string $col
   * @param number $val
   * @return Table
   */
  public function plus($col, $val = 1) {
    $sets = array("`$col` = `$col` + $val");
    $args = array_slice(func_get_args(), 2);
    while (count($args) > 1) {
      $col = array_shift($args);
      $val = array_shift($args);
      $sets[] = "`$col` = `$col` + $val";
    }
    $sql = "UPDATE `{$this->_table}` SET ".implode(', ', $sets);
    $sql .= empty($this->_where) ? '' : ' WHERE '. implode(' AND ', $this->_where);
    $params = array_merge(array($val), $this->_where_params);
    $this->queryParams($sql, $params);
    return $this;
  }
  /**
   *            
   * @param string $col
   * @param number $val
   * @return int
   */
  public function incr($col, $val = 1) {
    $sql = "UPDATE `{$this->_table}` SET `$col` = last_insert_id(`$col` + ?)";
    $sql .= empty($this->_where) ? '' : ' WHERE '. implode(' AND ', $this->_where);
    $params = array_merge(array($val), $this->_where_params);
    $this->queryParams($sql, $params);
    return $this->getPDO()->lastInsertId();
  }
  /**
   *        
   * @param number $id
   * @return array
   */
  public function find($id) {
    return $this->where("`{$this->_pk}` = ?", $id)->select()->fetch();
  }
  /**
   *     ,           
   * @param array $data
   * @return PDOStatement
   */
  public function save(array $data) {
    if (array_key_exists($this->_pk, $data)) {
      $pk_val = $data[$this->_pk];
      unset($data[$this->_pk]);
      return $this->where("`{$this->_pk}` = ?", $pk_val)->update($data);
    } else {
      return $this->insert($data);
    }
  }
  /**
   *       
   * @param array $rows
   * @param string $fkey
   * @param string $field
   * @param string $key
   * @return PDOStatement
   */
  public function foreignKey(array $rows, $fkey, $field='*') {
    $ids = array(); foreach($rows as $row) { $ids[] = $row[$fkey]; }
//   $ids = array_column($rows, $fkey);
    if (empty($ids)) {
      return new PDOStatement();
    }
    return $this->where("`{$this->_pk}` in (?)", $ids)->select($field);
  }
}

github 주소:
https://github.com/dotcoo/php/blob/master/Table/Table.php
더 많은 PHP 관련 내용 에 관심 이 있 는 독자 들 은 본 사이트 의 주 제 를 볼 수 있다.
본 논문 에서 말 한 것 이 여러분 의 PHP 프로 그래 밍 에 도움 이 되 기 를 바 랍 니 다.

이 내용에 흥미가 있습니까?

현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:

laravel에 yo에서 angularJs&coffeescript를 사용할 수 있도록 한다.

먼저 yo 명령을 사용할 수 있어야하므로 아래에서 설치 global에 설치한 곳에서 laravel의 프로젝트 루트로 이동. 클라이언트 코드를 관리하는 디렉토리를 만들고 이동합니다. 클라이언트 환경 만들기 이것으로 히...

텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.

CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.

python list 지식(추천)

Python 프로 그래 밍 정규 삭제 명령 기능 구현

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다