<?php

defined('IN_MET') or exit('No permission');

# 数据结构处理
class tsql
{
    
    private $sql         = [];
    private $m_name      = M_NAME;
    private $special     = [];
    private $ufield      = [];
    private $query;
    private $multi_table = false;   //采用分组才会采用子查询计算总数
    
    public function __construct()
    {
        global $_M;
        self::table_unset();
    }
    
    # 清空
    public function table_unset()
    {
        global $_M;
        unset($this->sql, $this->special, $this->ufield);
        return $this;
    }
    
    # 数据库
    # $sign false 不添加应用文件名前缀
    public function table($tname, $sign = true)
    {
        global $_M;
        self::table_unset();
        $this->sql['table'] = self::full_table_name($tname, $sign);
        return $this;
    }
    
    # 多表联合查询数据库，制作表的联合方式，通过多次调用来实现
    # $tname 包含缩写数据名和 缩写名
    # $join 数据库连接方式
    # $sign false 不添加应用文件名前缀
    # 
    public function tables($tname = [], $join = '', $sign = true)
    {
        global $_M;
        list($name, $ab) = $tname;
        $table              = self::full_table_name($name, $sign);
        $this->sql['table'] .= $table . " AS {$ab} {$join} ";
        return $this;
    }
    
    # 需要特殊处理的值，例如：counts+1 等类似的 或者执行函数
    # 传入的为特殊处理的值，并 非字段名
    public function special($_special)
    {
        global $_M;
        $this->special = is_array($_special) ? $_special : [$_special];
        return $this;
    }
    
    # 需要删除的字段，仅支持约束条件下
    # 目前仅用于adup()时的 unique() 方法
    public function ufield($_field = '')
    {
        global $_M;
        $this->ufield = is_array($_field) ? $_field : [$_field];
        return $this;
    }
    
    # 查询字段
    # 查询或者多条插入信息
    public function qfield($_field = '*')
    {
        global $_M;
        if (is_array($_field)) $_field = arrayto_string($_field, ',');
        $this->sql['field'] = $_field;
        return $this;
    }
    
    # 插入更新字段
    # $sign 单条插入或者更新设置其他值，查询或者多条插入信息时使用qfield()
    public function field($_field = '')
    {
        global $_M;
        if (is_array($_field)) $_field = self::field_arr($_field);
        $this->sql['field'] = $_field;
        return $this;
    }
    
    # 分组查询 $_having 同where 一样
    public function group($_group = '', $_having = '')
    {
        global $_M;
        
        if (is_array($_group)) $_group = arrayto_string($_group, ',');
        if (!empty($_group)) $this->sql['group'] = " GROUP BY " . $_where;
        if ($_group) {
            $this->multi_table = true;
            if (is_array($_having)) $_having = self::where_arr($_having);
            if (!empty($_having)) $this->sql['group'] .= " HAVING " . $_having;
        }
        return $this;
    }
    
    # 查询条件
    public function where($_where = '1=1')
    {
        global $_M;
        if (is_array($_where)) $_where = self::where_arr($_where);
        if (!empty($_where)) $this->sql['where'] = " WHERE " . $_where;
        return $this;
    }
    
    # 排序条件
    public function order($_order = 'id DESC')
    {
        global $_M;
        $this->sql['order'] = " ORDER BY " . $_order;
        return $this;
    }
    
    # 单独值，用于 多条信息插入，或者约束插入更新
    public function values($_values = '')
    {
        global $_M;
        if (is_array($_values)) $_values = self::values_arr($_values);
        $this->sql['values'] = $_values;
        return $this;
    }
    
    # 约束条件下的UPDATE 
    public function unique($_unique = '')
    {
        global $_M;
        if (is_array($_unique)) {
            $_unique = self::field_del($_unique);
            $_unique = self::unique_arr($_unique);
        }
        $this->sql['unique'] = " ON DUPLICATE KEY UPDATE " . $_unique;
        return $this;
    }
    
    # 查询条数限制
    public function limit($_limit = '30', $_start = '0')
    {
        global $_M;
        $this->sql['limit'] = " LIMIT {$_start}," . $_limit;
        return $this;
    }
    
    # 删除
    public function del($_where)
    {
        global $_M;
        if (empty($this->sql['table'])) return false;
        if (!empty($_where) && empty($this->sql['where'])) self::where($_where);
        $this->query = "DELETE FROM {$this->sql['table']}  {$this->sql['where']} ";
        unset($this->sql);
        DB::query($this->query);
        return $this;
    }
    
    # 单条修改
    public function upd()
    {
        global $_M;
        if (empty($this->sql['table']) || empty($this->sql['field'])) return false;
        $this->query = "UPDATE {$this->sql['table']} SET {$this->sql['field']}  {$this->sql['where']} ";
        unset($this->sql);
        DB::query($this->query);
        return $this;
    }
    
    # 单条新增
    public function add($_field)
    {
        global $_M;
        if (!empty($_field) && empty($this->sql['field'])) self::field($_field);
        if (empty($this->sql['table']) || empty($this->sql['field'])) return false;
        $this->query = "INSERT INTO {$this->sql['table']} SET {$this->sql['field']} ";
        unset($this->sql);
        DB::query($this->query);
        return $this;
    }
    
    # 约束字段新增，更新，unique 值不存在即可实现多条信息插入 
    # field 字段需要查询类型的 qfield()
    # $data 一维二维都可以，key = field 
    # $sign false 并且也没有单独调用unique()是多条信息插入, true 为是约束更新插入
    public function adup($data = [], $sign = true)
    {
        global $_M;
        if (empty($this->sql['table'])) return false;
        if (is_array($data)) {
            $arr    = array_level($data) == 1 ? $data : reset($data);
            $qfield = array_keys($arr);
            if (empty($this->sql['field'])) self::qfield($qfield);
            if (empty($this->sql['values'])) self::values($data);
            if ($sign == true && empty($this->sql['unique'])) {
                $unique = [];
                $arr    = self::field_del($arr);
                foreach ($arr as $key => $val) {
                    if (in_array($val, $this->special, true)) {
                        $unique[ $key ] = $val;
                    } else {
                        $unique[] = $key;
                    }
                }
                self::unique($unique);
            }
        }
        $this->query = "INSERT INTO {$this->sql['table']} ({$this->sql['field']}) VALUES {$this->sql['values']}  {$this->sql['unique']} ";
        unset($this->sql);
        DB::query($this->query);
        return $this;
    }
    
    # 查询单条
    public function one()
    {
        global $_M;
        if (empty($this->sql['table'])) return false;
        if (empty($this->sql['field'])) $this->sql['field'] = '*';
        $this->query = "SELECT {$this->sql['field']} FROM {$this->sql['table']} {$this->sql['where']} {$this->sql['group']} {$this->sql['order']} {$this->sql['limit']} ";
        unset($this->sql);
        return DB::get_one($this->query);
    }
    
    # 查询更多条数
    public function all($key = 'id')
    {
        global $_M;
        if (empty($this->sql['table'])) return false;
        if (empty($this->sql['field'])) $this->sql['field'] = '*';
        $this->query = "SELECT {$this->sql['field']} FROM {$this->sql['table']} {$this->sql['where']} {$this->sql['group']} {$this->sql['order']}  {$this->sql['limit']} ";
        unset($this->sql);
        $res    = [];
        $result = DB::query($this->query);
        while ($val = DB::fetch_array($result)) {
            $res[ $val[ $key ] ] = $val;
        }
        return $res;
    }
    
    # 获取表结构
    public function show()
    {
        global $_M;
        if (empty($this->sql['table'])) return false;
        $this->query = "SHOW FULL COLUMNS FROM .{$this->sql['table']}";
        unset($this->sql);
        $res        = [];
        $rescolumns = DB::query($this->query);
        while ($row = DB::fetch_array($rescolumns)) {
            $res[] = $row;
        }
        return $res;
    }
    
    # 条数统计
    # field 采用查询方法 qfield
    # $multi_table 若是采用分组了计算方式要调整为 子查询计算总条数
    public function count($_field = '*')
    {
        global $_M;
        if (empty($this->sql['table'])) return 0;
        if (empty($this->sql['field'])) $this->sql['field'] = "COUNT({$_field})";
        
        $this->query = " SELECT {$this->sql['field']} FROM {$this->sql['table']} {$this->sql['where']} ";
        if ($this->multi_table) $this->query = " SELECT count(*) FROM ($this->query) num ";
        $result    = DB::query($this->query);
        $fetch_row = DB::fetch_row($result);
        return $fetch_row[0];
    }
    
    # 获取刚才插入的信息ID
    public function id()
    {
        global $_M;
        return DB::insert_id();
    }
    
    # 错误信息(对查询是无效的)
    public function error()
    {
        global $_M;
        return DB::error();
    }
    
    # 返回完整数据库名
    public function full_table_name($tname, $sign = true)
    {
        global $_M;
        return $sign == true ? $_M['table'][ $this->m_name . '_' . $tname ] : $_M['table'][ $tname ];
    }
    
    # 字段删除方法
    public function field_del($array = [])
    {
        global $_M;
        foreach ($this->ufield as $val) {
            unset($array[ $val ]);
        }
        return $array;
    }
    
    # where条件的转换
    # 仅是值等于的处理，例如某个字段判断为不等于或者其他的方法，切勿使用数组传递
    public function where_arr($arr)
    {
        global $_M;
        $and = [];
        foreach ($arr as $key => $val) {
            // 函数的使用 数字键名采用函数模式
            if (is_numeric($key)) {
                $and[] = $val;
                continue;
            }
            // 仅是值等于的处理
            if (is_array($val)) {
                $or = [];
                foreach ($val as $ky => $kv) {
                    $or[] = " {$key} = '{$kv}' ";
                    // 函数的使用,非数字则采用函数模式
                    if (!is_numeric($ky)) {
                        $or[] = $val;
                        continue;
                    }
                }
                $orstr = arrayto_string($or, ' OR ');
                $and[] = " ({$orstr}) ";
            } else {
                $and[] = " {$key} = '{$val}' ";
            }
        }
        return arrayto_string($and, ' AND ');
    }
    
    # 入库字段转换
    public function field_arr($arr)
    {
        global $_M;
        $str = [];
        foreach ($arr as $k => $v) {
            if (strstr($v, "'")) $v = str_replace("'", "\'", $v);
            if (in_array($v, $this->special, true)) {
                $str[] = " {$k} = {$v} ";
            } else {
                $str[] = " {$k} = '{$v}' ";
            }
        }
        return arrayto_string($str, ',');
    }
    
    # 单独值的字符串转换
    public function values_arr($arr)
    {
        global $_M;
        $str = [];
        foreach ($arr as $val) {
            if (is_array($val)) {
                $str[] = self::values_arr($val);
            } else {
                if (in_array($val, $this->special, true)) {
                    $str[] = " $val ";
                } else {
                    $str[] = " '$val' ";
                }
            }
        }
        $arrtostr = arrayto_string($str, ',');
        return array_level($arr) == 1 ? "({$arrtostr})" : $arrtostr;
    }
    
    # 约束条件新增的语句更新值的规则（最后一段）
    # 数组key值为字段名非数字 说明是要单独处理的值
    public function unique_arr($arr)
    {
        global $_M;
        $str = [];
        foreach ($arr as $k => $v) {
            if (is_numeric($k)) {
                $str[] = " $v = VALUES($v) ";
            } else {
                $str[] = " $k = $v ";
            }
        }
        return arrayto_string($str, ',');
    }
    
    # 通过数据库整理出该数据库的字段一般是净化form提交的字段，避免一个一个组装
    public function tfield($form, $tablename = '')
    {
        global $_M;
        if (!empty($tablename)) {
            if (is_array($tablename)) $tablename = [$tablename, true];
            list($name, $sign) = array_values($tablename);
            self::table($name, $sign);
        }
        $karr = DB::get_all("DESC {$this->sql['table']}");
        foreach ($karr as $v) {
            $arr[ $v['Field'] ] = $v['Field'];
        }
        #根据数据库字段提炼
        return array_intersect_key($form, $arr);
    }
    
    # 查看刚才执行过的sql语句，方便核查sql语句
    public function query()
    {
        global $_M;
        return $this->query;
    }
    
    
}

?>