如何写一个属于自己的数据库封装(3)

 function construct() {
 // 新建两个实例
 // 如果已经理解Connector的原理后自然明白这个Connector实例已经联通了数据库
 $this->connector = new Connector;
 $this->grammar = new Grammar;
 }

public function select($columns = ['*']) {
 // $columns只能存入数组, 所以需要判定, 如果不是, 将所有参数合成一个数组再存入
 // 这是一个更人性化的设定, 用户可以选择以下两种调用方式
 // select(['first_name', 'last_name']), 以数组的方式
 // select('first_name', 'last_name'), 以参数的方式
 // 最后一点, 你可以发现所有函数最后都会存入对应的Builder属性中
 // 这和你在做饭前先处理材料是同一个道理, 也就是预处理
 $this->columns = is_array($columns) ? $columns : func_get_args();
 return $this;
 }

public function distinct() {
 // 开启过滤
 $this->distinct = true;
 return $this;
 }

 public function from($table) {
 $this->from = $table;
 return $this;
 }

/**
 * @param string $table 需要连接的副表名
 * 为什么主键和外键可以单个或数组呢
 * 原因是join语法可以on多个键
 * @param string/array $foregin 外键
 * @param string/array $primary 主键
 * @param string $type 连接方式, 默认inner
 * @return Builder 返回Builder实例
 */
 public function join($table, $foregin , $primary, $type = 'inner') {
 // 判定外键变量的数据类型
 if(is_array($foregin)) {
 // 如果是数组, 循环加上副表名在前头
 foreach($foregin as &$f)
 $f = $table.".".$f;
 }else {
 // 反之, 不需循环直接加
 $foregin = $table.".".$foregin;
 }

 // 与$foreign的逻辑同理
 if(is_array($primary)) {
 foreach($primary as &$p)
 $p = $this->from.".".$p;
 }else {
 $primary = $this->from.".".$primary;
 }

 // 将所有经过处理的参数收入$joins待用
 $this->joins[] = (object)[
 'from' => $this->from,
 'table' => $table,
 'foregin' => $foregin,
 'primary' => $primary,
 'type' => $type
 ];

 // 返回Builder实例
 return $this;
 }

// 所有逻辑同join(), 不过这是left join
 public function leftJoin($table, $foregin , $primary) {
 return $this->join($table, $foregin , $primary, 'left');
 }

 // 所有逻辑同join(), 不过这是right join
 public function rightJoin($table, $foregin , $primary) {
 return $this->join($table, $foregin , $primary, 'right');
 }

/**
 * @param string/array $value 字段匹配的值
 * @param string $type 条件类型, 默认为where, 具体查看$bindings
 */
 public function addBinding($value, $type = 'where') {
 // 如果$type并不是$bindings的键, 跳出错误
 if (!array_key_exists($type, $this->bindings)) 
 throw new InvalidArgumentException("Invalid binding type: {$type}.");

 // 如果$value是数组,将其与之前存入的值整合为一维数组
 if (is_array($value)) 
 $this->bindings[$type] = array_values(array_merge($this->bindings[$type], $value));
 // 反之, 直接存入最后一位即可
 else
 $this->bindings[$type][] = $value;

 // 返回Builder实例
 return $this;
 }

// 所有逻辑同where(), 不过这是or where
 public function orWhere($column, $operator = null, $value = null) {
 return $this->where($column, $operator, $value, 'or');
 }

 /**
 * where in 语法, 字段匹配多个值
 * @param string $column 字段
 * @param array $values 一组字段需匹配的值
 * @param string $boolean 默认为and
 * @param boolean $not 默认为假, 真为排除所有$value里的数据
 * @return Builder 返回Builder实例
 */
 public function whereIn($column, $values, $boolean = 'and', $not = false) {
 // 判定条件查询的类型, false = where in ($value),true = where not in ($value)
 $type = $not ? 'NotIn' : 'In';
 // 将条件存入$wheres
 $this->wheres[] = compact('type', 'column', 'values', 'boolean');
 // 循环将字段需要匹配的值存入$bindings中的where
 foreach ($values as $value) 
 $this->addBinding($value, 'where');

 // 返回Builder实例
 return $this;
 }

 // 所有逻辑同whereIn(), 不过这是or where in
 public function orWhereIn($column, $values) {
 return $this->whereIn($column, $values, 'or');
 }

 // 所有逻辑同whereIn(), 不过这是and where not in
 public function whereNotIn($column, $values, $boolean = 'and') {
 return $this->whereIn($column, $values, $boolean, true);
 }

 // 所有逻辑同whereNotIn(), 不过这是or where not in
 public function orWhereNotIn($column, $values) {
 return $this->whereNotIn($column, $values, 'or');
 }

 /**
 * where $coulmn is null 语法, 搜索字段为空的数据
 * @param string $column 字段
 * @param string $boolean 默认为and
 * @param boolean $not 默认为假, 真为排除所有字段为空的数据
 * @return Builder 返回Builder实例
 */
 public function whereNull($column, $boolean = 'and', $not = false) {
 // 判定条件查询的类型, false = where $column is null,true = where $column is not null
 $type = $not ? 'NotNull' : 'Null';
 // 将条件存入$wheres
 $this->wheres[] = compact('type', 'column', 'boolean');
 // 返回Builder实例
 return $this;
 }

 // 所有逻辑同whereNull(), 不过这是or where $column is null
 public function orWhereNull($column) {
 return $this->whereNull($column, 'or');
 }

 // 所有逻辑同whereNull(), 不过这是and where $column is not null
 public function whereNotNull($column, $boolean = 'and') {
 return $this->whereNull($column, $boolean, true);
 }

 // 所有逻辑同whereNotNull(), 不过这是or where $column is not null
 public function orWhereNotNull($column) {
 return $this->whereNotNull($column, 'or');
 }

/**
 * @param string/array $column 字段
 * @param string $direction 排序,默认为asc, 顺序
 * @return Builder 返回Builder实例
 */
 public function orderBy($column, $direction = 'asc') {
 // 局限性在于必须声明顺序或逆序
 if(is_array($column)) {
 foreach ($column as $key => $value) 
 $this->orderBy($key, $value);
 }else {
 // 简单判定后直接存入$orders, $direction输入错误不跳错误直接选择顺序
 $this->orders[] = [
 'column' => $column,
 'direction' => strtolower($direction) == 'desc' ? 'desc' : 'asc',
 ];
 }

 // 返回Builder实例
 return $this;
 }

function array_flatten(array $array) {
 $return = array();
 array_walk_recursive($array, function($a) use (&$return) { 
 $return[] = $a; 
 });
 return $return;
}

$a = array('this', 'is', array('a', 'multidimentional', array('array') ), 'to', 'make', 'the', 'tutotal', array('more', 'easier', 'to', 'understand') );
dd(array_flatten($a));

array (size=13)
0 => string 'this' (length=4)
1 => string 'is' (length=2)
2 => string 'a' (length=1)
3 => string 'multidimentional' (length=16)
4 => string 'array' (length=5)
5 => string 'to' (length=2)
6 => string 'make' (length=4)
7 => string 'the' (length=3)
8 => string 'tutotal' (length=7)
9 => string 'more' (length=4)
10 => string 'easier' (length=6)
11 => string 'to' (length=2)
12 => string 'understand' (length=10)

/**
 * @param string/array $groups 字段
 * @return Builder 返回Builder实例
 */
 public function groupBy(...$groups) {
 if(empty($this->groups)) $this->groups = [];
 $this->groups = array_merge($this->groups, array_flatten($groups));
 // 返回Builder实例
 return $this;
 }

 public function limit($value) {
 // 如果$value大于零这条函数才生效
 if ($value >= 0) $this->limit = $value;
 return $this;
 }

 // limit函数的别名, 增加函数链的可读性
 public function take($value) {
 return $this->limit($value);
 }

 public function offset($value) {
 // 如果$value大于零这条函数才生效
 if ($value >= 0) $this->offset = $value;
 return $this;
 }

 // offset函数的别名, 增加函数链的可读性
 public function skip($value) {
 return $this->offset($value);
 }

// 返回一组数据库数据, 可以在这里设定想返回的字段, 但是select()的优先度最高
 public function get($columns = ['*']) {
 // 如果Builder的$columns依然为空, 那么就用该函数的$columns, 反之则使用select()所声明的字段
 if (is_null($this->columns)) $this->columns = $columns;
 // 如果Builder的$orders依然为空, 那么就默认第一个字段顺序
 // 发现一个莫名的bug, 可能是我理解错了, 不加 order by 1数据返回竟然不是按照主键(第一个字段)排序
 // 所以以防万一加一个默认
 if (is_null($this->orders)) $this->orderBy(1);
 // 将Grammar类生成的语句,和处理过的字段所对应的值,都交给Connector类, 让它与数据库进行通信,返回数据
 // 注意这里的三个函数
 // read() 不用说Connector篇介绍过了
 // compileSelect()是用来编译生成查询语句
 // getBindings()用来获取收在$bindings中条件的值, 下方会有说明
 $results = $this->connector->read($this->grammar->compileSelect($this), $this->getBindings());
 // 返回一组数据库数据,如果查询为空,返回空数组
 // cast()下方会有说明
 return $this->cast($results);
 }

 // get函数的别名, 增加函数链的可读性
 public function all($columns = ['*']) {
 return $this->get($columns);
 }

 public function getBindings() {
 // 抚平数组成一维数组后再返回
 return array_flatten($this->bindings);
 }

 public function cast($results){
 // 获取Model子类的名称
 $class = get_class($this->model);
 // 新建一个Model子类
 $model = new $class();
 // 如果获得的数据库数据是数组
 if (gettype($results)=="array") {
 $arr = [];
 // 循环数据
 foreach ($results as $result) 
 // 再调用本函数
 $arr[] = $this->cast($result);
 // 返回经过转化的数据数组
 return $arr;
 // 如果获得的数据库数据是对象
 }elseif(gettype($results)=="object"){
 // 存入数据对象
 $model->setData($results);
 // 加入主键或unique key以实现数据的可操作性
 // 如果表存在主键和返回的数据中有主键的字段
 if($model->getIdentity() && isset($results->{$model->getIdentity()})) {
 $model->where($model->getIdentity(), $results->{$model->getIdentity()});
 // 如果表存在unique key和返回的数据中有unique key的字段
 }elseif($model->getUnique() && array_check($model->getUnique(),$results)) {
 foreach ($model->getUnique() as $key) 
 $model->where($key, $results->$key);
 // 改写和删除操作仅仅在符合以上两种条件其中之一的时候
 // 反之, 开启写保护不允许改写
 }else {
 // 其实还可以考虑直接复制query
 // 但变数太多干脆直接一棍子打死
 $model->getBuilder()->writeLock = true;
 }
 // 返回该实例
 return $model;
 }
 // 如果转化失败返回false
 return false;
 }

/**
 * @param array $columns 如果Builder的$columns依然为空, 那么就用该函数的$columns, 反之则使用select()所声明的字段
 * @return boolean/Model 查询为空返回false, 反之则返回附带数据的表类
 */
 public function first($columns = ['*']) {
 $results = $this->take(1)->get($columns);
 return empty($results) ? false : $results[0];
 }

 public function setModel(Model $model) {
 $this->model = $model;
 return $this;
 }

 protected function concatenate($segments) {
 return implode(' ', array_filter($segments, function ($value) {
 return (string) $value !== '';
 }));
 }

 // 还记得Builder->get()中的compileSelect()吗?
 public function compileSelect(Builder $query) {
 // concatenate()排除编译后可能存在空的值,然后连接整句SQL语句
 // 去掉可能存在的前后端空格再返回
 return trim($this->concatenate($this->compileComponents($query)));
 }

 protected function compileComponents(Builder $query) {
 $sql = [];
 // 循环$selectComponents
 foreach ($this->selectComponents as $component) {
 // 如果Builder实例中对应的函数曾经被调用,那意味着对应的语法非空
 if (!is_null($query->$component)) {
 $method = 'compile'.ucfirst($component);
 // 编译该语法并将之收入$sql
 $sql[$component] = $this->$method($query, $query->$component);
 }
 }
 // 返回$sql数组
 return $sql;
 }

 protected function compileDistinct(Builder $query, $distinct) {
 return $distinct ? 'select distinct' : 'select';
 }

 protected function compileLimit(Builder $query, $limit) {
 return "limit $limit";
 }

 protected function compileOffset(Builder $query, $offset) {
 return "offset $offset";
 }

 protected function compileColumns(Builder $query, $columns) {
 return implode(', ', $columns);
 }

 protected function compileFrom(Builder $query, $table) {
 return 'from '.$table;
 }

 protected function compileJoins(Builder $query, $joins) {
 $sql = [];
 foreach ($joins as $join) {
 // 如果存在多个副键和主键
 if(is_array($join->foregin) && is_array($join->primary)) {
 $on = [];
 // 循环键的数量, 将之与对应的主键组合
 for($i=0; $i<sizeof($join->foregin); $i++)
 $on[] = $join->foregin[$i]." = ".$join->primary[$i];
 // 最后再将所有句子用and连接
 $on = implode(' and ', $on);
 } else {
 //反之, 直接连接即可
 $on = "$join->foregin = $join->primary";
 }
 // 附上join的类型和副表
 $sql[] = trim("{$join->type} join {$join->table} on $on");
 }

 // 连接再返回
 return implode(' ', $sql);
 }

 protected function compileWheres(Builder $query) {
 $sql = [];
 // 类似与compileComponents(), 循环Builder实例中的$wheres
 foreach ($query->wheres as $where) {
 // 根据不同的$type来进行编译
 $method = "where{$where['type']}";
 // 返回的部分语句先收入数组
 $sql[] = $where['boolean'].' '.$this->$method($query, $where);
 }
 // 最后将$sql数组连接起来, 删掉最前面的and或or在返回
 return 'where '.preg_replace('/and |or /i', '', implode(" ", $sql), 1);
 }

 protected function whereBasic(Builder $query, $where) {
 // 检测$where[column]是否存在小数点
 // 是, 就意味着前缀已经附带了表名
 // 否, 为之后的字段添上表名
 // 因为join存在副表, 所以部分$where可能有附带表名, 这时候就不用添加了
 $table = !preg_match('/\./', $where['column']) ? $query->from."." : '';
 // 返回添上表名的字段,和表达式, 再一个问号
 // 为何使用问号而不是:变量名? 因为:变量名存在太多局限性,不能标点符号,不能数字开头
 return $table.$where['column'].' '.$where['operator'].' ?';
 }

 protected function whereIn(Builder $query, $where) {
 // 检测$where[column]是否存在小数点, 同理whereBasic()
 $table = !preg_match('/\./', $where['column']) ? $query->from."." : '';
 // 有多少个匹配值那就连接多少个问号
 $values = implode(', ', array_fill(0, sizeof($where['values']), '?'));
 // 返回where in 语句
 return $table.$where['column'].' in ('.$values.')';
 }

 protected function whereNotIn(Builder $query, $where) {
 // 检测$where[column]是否存在小数点, 同理whereBasic()
 $table = !preg_match('/\./', $where['column']) ? $query->from."." : '';
 // 有多少个匹配值那就连接多少个问号
 $values = implode(', ', array_fill(0, sizeof($where['values']), '?'));
 // 返回where not in 语句
 return $table.$where['column'].' not in ('.$values.')';
 }

 protected function whereNull(Builder $query, $where) {
 // 检测$where[column]是否存在小数点, 同理whereBasic()
 $table = !preg_match('/\./', $where['column']) ? $query->from."." : '';
 // 返回where is null 语句
 return $table.$where['column'].' is null';
 }

 protected function whereNotNull(Builder $query, $where) {
 // 检测$where[column]是否存在小数点, 同理whereBasic()
 $table = !preg_match('/\./', $where['column']) ? $query->from."." : '';
 // 返回where is not null 语句
 return $table.$where['column'].' is not null';
 }

 protected function compileGroups(Builder $query, $groups) {
 // 连接$groups, 返回group by语句
 return 'group by '.implode(', ', $groups);
 }

 protected function compileOrders(Builder $query, $orders) {
 // 连接每一个$order与其$direction, 然后返回order by语句
 return 'order by '.implode(', ', array_map(function ($order) {
 return $order['column'].' '.$order['direction'];
 }, $orders));
 }

 public function getTable() {
 return isset($this->table) ? $this->table : false;
 }

 public function getIdentity() {
 return isset($this->identity) ? $this->identity : false;
 }

 public function getUnique() {
 // 检测是否存在unique key, 不存在返回假, 存在就在检查是否数组, 不是就装入数组再返回
 return isset($this->unique) ? is_array($this->unique) ? $this->unique : [$this->unique] : false;
 }

 public function check() {
 // 如果数据库表的名称和Model的子类相同,可以选择不填,默认直接取类的名称
 if(!$this->getTable()) 
 $this->table = get_class($this);

 // 跳出提醒必须设置$identity或$unique其中一项
 if(!$this->getIdentity() && !$this->getUnique())
 throw new Exception('One of $identity or $unique should be assigned in Model "'.get_called_class().'"');

 }

// 设置Builder实例
 public function setBuilder(Builder $builder) {
 $this->builder = $builder;
 return $this;
 }

 // 获取Builder实例
 public function getBuilder() {
 return $this->builder;
 }

 public function setData($data) {
 $this->data = $data;
 return $this;
 }

 function construct() {
 // 检查设定是否正确
 $this->check();
 // 新建一个Builder实例
 $this->setBuilder(new Builder);
 // 设置构建器的主表名称
 $this->getBuilder()->from($this->table);
 // 将Model实例带入Builder
 $this->getBuilder()->setModel($this);
 }

 static public function callStatic($method, $args = null) {
 // 这是一个伪静态, 创建一个实例
 $instance = new static;
 // 在$instance->builder之中, 寻找函数$method, 并附上参数$args
 return call_user_func_array([$instance->builder, $method], $args);
 }

 public function call($method, $args) {
 // 在$this->builder之中, 寻找函数$method, 并附上参数$args
 return call_user_func_array([$this->builder, $method], $args);
 }

 public function debugInfo() {
 // 也不懂算不算bug, 该方法强制要求返回的数据类型必须是array数组
 // 但是就算我强行转换(casting)后返回的数据依然是对象(object)
 return (array)$this->data;
 }

 // 为了避免局外人可以访问Model类的属性
 // 为了避免对象属性和表的字段名字相同
 public function get($field) {
 // 如果调用的属性是Model类内的逻辑
 // 直接返回该属性的值
 if(get_called_class()==="Model") 
 return $this->$field;
 // 反之, 则检查$data内是否存在该属性, 没有的话跳出错误
 if(!isset($this->data->$field)) 
 throw new Exception("column '$field' is not exists in table '$this->table'");
 // 如果存在,由于返回的数据都是存在$data里, 所以要这样调用
 return $this->data->$field;
 }

 public function set($field, $value) {
 // 如果调用的属性是Model类内的逻辑
 // 直接赋值该属性
 if(get_called_class()==="Model")
 return $this->$field = $value;
 // 反之, 则检查$data内是否存在该属性, 没有的话跳出错误
 if(!isset($this->data->$field)) 
 throw new Exception("column '$field' is not exists in table '$this->table'");

 // 如果存在,由于返回的数据都是存在$data里, 所以要这样赋值
 return $this->data->$field = $value;
 }

/**
 * @param int $id 主键
 * @return Model subclass 返回一个Model的子类数据
 */
 public static function find($id) {
 // 这是一个伪静态, 创建一个实例
 $self = new static;

 // 该函数只适用于设置了主键的表, 如果没有设置, 跳出错误
 if(!$self->getIdentity()) 
 throw new Exception("Table's identity key should be assgined");

 return $self->where($self->identity, $id)->first();
 }