vendor/lm/db/src/SqlService.php line 679

Open in your IDE?
  1. <?php
  2. /**
  3.  * @version EC-CUBE4系
  4.  * @copyright 株式会社 翔 kakeru.co.jp
  5.  *
  6.  * 2021年12月05日作成
  7.  *
  8.  * app\Customize\Service\SqlService.php
  9.  *
  10.  * SQL文を作成する
  11.  *
  12.  * このクラスを変更する場合は株式会社 翔の許可を取ってください
  13.  * 2021/12/07修正 WHERE句 AS句 スペースを修正
  14.  * 2021/12/07 AS句 スペースを修正
  15.  * 2022/08/18 IN区 パラメーター化
  16.  *
  17.  *                                        ≡≡≡┏(＾o＾)┛
  18.  *****************************************************/
  20. namespace Lm\Service\Db;
  22. use Lm\Service\Cache\CacheService;
  23. use Lm\Service\Cache\LmCacheTrait;
  25. class SqlService
  26. {
  28.     use LmCacheTrait {
  29.         LmCacheTrait::__construct as __traitConstruct;
  30.     }
  32.     const READ = true;
  33.     const WRITE = false;
  34.     const AS_SYMBOL = 'T'; #Tableの簡略化名 AS句
  36.     const AS_PATAN = '/^[T0-9]+\./';
  38.     #初期値
  39.     const DEF = '';
  40.     #戻り値
  41.     const RE = null;
  43.     const SELECT = self::AS_SYMBOL . '.* ';
  44.     const ParamKIgo = ':P_';
  46.     protected static $_Connect = [];
  47.     #DB接続
  48.     protected $Connect; #Object;
  49.     protected $Stmt; #object
  50.     protected $Table_;
  51.     protected $Select_ = '';
  52.     protected $Selects_ = [];
  53.     protected $Set_ = [];
  54.     protected $Sql_;
  55.     protected $Values_ = [];
  56.     protected $Where_ = [];
  57.     protected $WhereLogical = [];
  58.     protected $Param_ = [];
  59.     protected $Order_ = [];
  60.     protected $OrderBy_;
  61.     protected $Join_ = [];
  62.     protected $Limit_;
  63.     protected $OffSet_;
  64.     protected $Group_;
  65.     protected $ConName;
  66.     protected $Num = 0;
  67.     protected $ForeignKey_ = 1;
  68.     protected $Column_ = [];
  70.     #SQl分をエコーで表示する パラメーターは配列
  71.     protected $ViewFlg;
  74.     /**
  75.      * コンストラクト
  76.      * DBの接続
  77.      */
  78.     function __construct()
  79.     {
  80.         $cacheService = new CacheService();
  81.         //
  82.         $this->__traitConstruct($cacheService);
  83.         //
  84.         $this->Connect = $this->ConnectDB(false);
  85.     }
  87.     function ConnectDB($forceReconnect = false)
  88.     {
  89.         if ($forceReconnect || empty(self::$_Connect)) {
  90.             $dbManagerRead = new DbManager([], self::READ);
  91.             $dbManagerWrite = new DbManager([], self::WRITE);
  92.             self::$_Connect[self::READ] = $dbManagerRead->get();
  93.             self::$_Connect[self::WRITE] = $dbManagerWrite->get();
  94.             return self::$_Connect;
  95.         } else {
  96.             return self::$_Connect;
  97.         }
  98.     }
  100.     /**
  101.      * 初期化
  102.      * SQL 発行後変数の初期化します
  103.      */
  104.     protected function Initialize()
  105.     {
  107.         $this->Table_ = null;
  108.         $this->Select_ = '';
  109.         $this->Selects_ = [];
  110.         $this->Set_ = [];
  111.         $this->Where_ = [];
  112.         $this->WhereLogical = [];
  113.         $this->Param_ = [];
  114.         $this->Order_ = [];
  115.         $this->OrderBy_ = [];
  116.         $this->Join_ = [];
  117.         $this->Limit_ = null;
  118.         $this->OffSet_ = null;
  119.         $this->Group_ = null;
  120.         $this->Values_ = [];
  121.         $this->Sql_ = null;
  122.         $this->Num = 0;
  123.         $this->ViewFlg = false;
  124.         $this->Stmt = null;
  125.         $this->Column_ = [];
  127.         if (0 == $this->ForeignKey_) {
  128.             $this->ForeignKey_ = 1;
  129.         }
  132.         $this->ForeignKey_ = null;
  134.     }
  136.     /**
  137.      * getter
  138.      *
  139.      * @return string
  140.      */
  141.     public function getSql()
  142.     {
  143.         return $this->Sql_;
  144.     }
  146.     /**
  147.      * シングルの連想配列を返す
  148.      * @param int $ViewFlg $ViewFlg 1 #SQl分をエコーで表示する パラメーターは配列 2 exit 付き
  149.      *
  150.      * @return array 無ければ NULLを返す
  151.      */
  152.     public function Find($ViewFlg = 0)
  153.     {
  154.         $this->ViewFlg = $ViewFlg;
  155.         #Select分 の作成
  156.         $this->MakeSelect();
  159.         $Value = $this->Fetch();
  160.         return $Value ? $Value : self::RE;
  161.     }
  163.     /**
  164.      * リストとして連想配列で返す
  165.      * @param int|bool $Flg $ViewFlg 1 #SQl分をエコーで表示する パラメーターは配列 2 exit 付き
  166.      *
  167.      * @return array 無ければ NULLを返す
  168.      */
  169.     public function FindAll($Flg = false)
  170.     {
  171.         #Select分 の作成
  172.         $this->MakeSelect();
  174.         return $this->FetchAll($Flg);
  176.     }
  178.     /**
  179.      * リストとして連想配列で返す
  180.      * @param int|bool $Flg 1 #SQl分をエコーで表示する パラメーターは配列 2 exit 付き
  181.      *
  182.      * @return array 無ければ  配列を返す
  183.      */
  184.     public function FindArr($Flg = false)
  185.     {
  186.         $Re = $this->FindAll($Flg);
  187.         return $Re == self::RE ? [] : $Re;
  188.     }
  190.     /**
  191.      * SQL文を実行し想配列で返す
  192.      * @param int|bool $Flg 1 #SQl分をエコーで表示する パラメーターは配列 2 exit 付き
  193.      *
  194.      * @return array 無ければ  NULLを返す
  195.      */
  197.     public function Finds($Flg = false)
  198.     {
  200.         $this->ViewFlg = $Flg;
  201.         #Select分 の作成
  202.         $this->MakeSelect();
  203.         return $this->FetchAll($Flg);
  204.     }
  207.     /**
  208.      * 最大値を返すリ
  209.      *
  210.      * @param int|bool $Flg
  211.      * @param string $Column
  212.      * @return int
  213.      */
  214.     public function Max($Flg = false, $Column = null)
  215.     {
  217.         if (!$Column = isset($Column) ? $Column : (isset($this->Column_[0]) ? $this->Column_[0] : '')) {
  218.             return 0;
  219.         }
  221.         $this->Select_ = "MAX(" . self::SetAs($Column) . ') AS Value';
  222.         $this->Column_ = [];
  223.         #Select分 の作成
  224.         $Max = $this->Find($Flg);
  225.         return isset($Max['Value']) ? $Max['Value'] : 0;
  226.     }
  228.     /**
  229.      * 最小値値を返すリ
  230.      *
  231.      * @param int|bool $Flg
  232.      * @param string $Column
  233.      * @return int
  234.      */
  235.     public function Min($Flg = false, $Column = null)
  236.     {
  238.         if (!$Column = isset($Column) ? $Column : (isset($this->Column_[0]) ? $this->Column_[0] : '')) {
  239.             return 0;
  240.         }
  243.         $this->Select_ = "MIN(" . self::SetAs($Column) . ') AS Value';
  244.         $this->Column_ = [];
  245.         #Select分 の作成
  246.         $Min = $this->Find($Flg);
  248.         return isset($Min['Value']) ? $Min['Value'] : 0;
  249.     }
  252.     /**
  253.      * カウントする
  254.      *
  255.      * @param int|bool $Flg
  256.      * @param string $Column
  257.      * @return int
  258.      */
  259.     public function Count($Flg = false, $Column = null)
  260.     {
  261.         if (!$Column = isset($Column) ? $Column : (isset($this->Column_[0]) ? $this->Column_[0] : '')) {
  262.             $this->Select_ = "COUNT(*) AS Value";
  263.         } else {
  264.             $this->Select_ = "Count(" . self::SetAs($Column) . ') AS Value';
  265.         }
  267.         $this->Column_ = [];
  268.         $Count = $this->Find($Flg);
  270.         return isset($Count['Value']) ? $Count['Value'] : 0;
  271.     }
  274.     /**
  275.      * UPDATE する
  276.      *
  277.      * @param int|bool $Flg
  278.      * @param array $Values
  279.      * @return bool|null
  280.      */
  281.     public function Update($Flg = false, $Values = [])
  282.     {
  284.         $this->ViewFlg = $Flg;
  286.         if ($Values) {
  287.             $this->Values($Values);
  288.         }
  290.         #Update文の作成
  291.         $this->MakeUpdate();
  293.         return $this->Exec();
  294.     }
  296.     /**
  297.      * @param int|bool $Flg
  298.      * @param array $Values
  299.      * @param int $lastInsertId
  300.      * @return bool|null
  301.      */
  302.     public function Insert($Flg = false, $Values = self::DEF, &$lastInsertId = null)
  303.     {
  305.         $this->ViewFlg = $Flg;
  307.         if ($Values) {
  308.             $this->Values($Values);
  309.         }
  312.         $this->MakeInsert();
  314.         if ($Num = $this->Exec()) {
  315.             //
  316.             $lastInsertId = $this->Connect[self::WRITE]->lastInsertId();
  317.         }
  319.         return $Num;
  320.     }
  323.     /**
  324.      * 2020/06/03
  325.      * 有ればUP 無ければINSERT
  326.      * @param int|bool $Flg
  327.      * @return bool|null
  328.      */
  329.     public function Inserts($Flg = false)
  330.     {
  332.         $this->ViewFlg = $Flg;
  334.         $this->MakeInserts();
  336.         return $this->Exec();
  337.     }
  339.     /**
  340.      * @param int|bool $Flg
  341.      * @return bool|null
  342.      */
  343.     public function Delete($Flg = false)
  344.     {
  346.         $this->ViewFlg = $Flg;
  348.         $this->MakeDelete();
  351.         return $this->Exec();
  352.     }
  354.     /**
  355.      * TRUNCATE DATA の初期化
  356.      *
  357.      * @param int|bool $Flg
  358.      * @return void
  359.      */
  360.     public function Truncate($Flg = false)
  361.     {
  362.         if (!$this->Table_) {
  363.             return;
  364.         }
  366.         $this->ViewFlg = $Flg;
  368.         $this->Sql_ = 'TRUNCATE ' . $this->Table_;
  370.         $this->Exec();
  372.         return;
  374.     }
  376.     /**
  377.      * ForeignKey
  378.      * 外部キーのチェックを無効にする
  379.      *
  380.      * @return $this
  381.      */
  382.     public function ForeignKey()
  383.     {
  384.         $this->ForeignKey_ = 0;
  385.         return $this;
  386.     }
  389.     /**
  390.      * カラムの表示
  391.      *
  392.      * @param int|bool $Flg
  393.      * @return array|null
  394.      */
  395.     public function ShowColumns($Flg = false)
  396.     {
  398.         $this->Sql_ = "SHOW COLUMNS FROM {$this->Table_} ";
  400.         $Arr = $this->FetchAll();
  402.         if (!$Flg) {
  403.             return $Arr;
  404.         }
  406.         foreach ($Arr as $i => $Val) {
  407.             $Re[$Val['Field']] = $Val;
  408.         }
  410.         return $Re;
  411.     }
  413.     /**
  414.      * テーブルの表示
  415.      *
  416.      * @param int|bool $Flg
  417.      * @return array|null
  418.      */
  419.     public function ShowTable($Flg = false)
  420.     {
  421.         $this->Sql_ = "SHOW TABLE STATUS";
  424.         $Arr = $this->FetchAll();
  425.         if (!$Flg) {
  426.             return $Arr;
  427.         }
  429.         foreach ($Arr as $val) {
  430.             $Re[$val['Name']] = $val;
  431.         }
  432.         return $Re;
  433.     }
  435.     /**
  436.      * バージョンの表示
  437.      *
  438.      * @return mixed
  439.      */
  440.     public function VerSion()
  441.     {
  443.         $this->ConName;
  444.         $this->Sql_ = 'select version()';
  445.         $Re = $this->Fetch();
  446.         return $Re['version()'];
  448.     }
  450.     /**
  451.      * 自動採番の値の変更
  452.      *
  453.      * @param int $Num
  454.      * @return bool|null
  455.      */
  456.     public function Auto_Num($Num = 1)
  457.     {
  459.         $this->Sql_ = "ALTER TABLE {$this->Table_} AUTO_INCREMENT={$Num}";
  461.         return $this->Exec();
  463.     }
  465.     /**
  466.      * テーブルのの定義
  467.      *
  468.      * @param string $Table
  469.      * @return $this
  470.      */
  471.     public function Table($Table)
  472.     {
  473.         $this->Table_ = $Table;
  474.         return $this;
  475.     }
  477.     /**
  478.      * SELECTの定義
  479.      *
  480.      * @param string Select
  481.      * @return $this
  482.      */
  483.     public function Select($Select = '')
  484.     {
  485.         if (!$Select) {
  486.             return $this;
  487.         }
  488.         $this->Select_ = $Select;
  489.         return $this;
  490.     }
  492.     /**
  493.      * Whereの設定
  494.      *
  495.      * @param $Where string WHERE文
  496.      * @param $Logical string 理論演算子
  497.      * @return $this
  498.      */
  499.     public function Where($Where, $Logical = 'AND')
  500.     {
  502.         $this->Where_[] = $Where;
  504.         $this->WhereLogical[] = $Logical;
  505.         return $this;
  506.     }
  508.     /**
  509.      * Paramsの設定
  510.      *
  511.      * @param string $Param
  512.      * @param string $Value
  513.      * @return $this
  514.      */
  515.     public function Param($Param, $Value)
  516.     {
  518.         $this->Param_[$Param] = $Value;
  519.         return $this;
  521.     }
  523.     /**
  524.      * Paramsの一括設定
  525.      *
  526.      * @param array $params
  527.      * @return $this
  528.      */
  529.     public function Params(array $params)
  530.     {
  531.         foreach ($params as $Param => $Value) {
  532.             $this->Param($Param, $Value);
  533.         }
  534.         return $this;
  535.     }
  537.     /**
  538.      * Sql文の設定
  539.      * @param string $Sql
  540.      * @return $this
  541.      */
  542.     public function Sql($Sql)
  543.     {
  545.         $this->Sql_ = $Sql;
  546.         return $this;
  547.     }
  549.     /**
  550.      * Parameの設定
  551.      * @param array $Values
  552.      * @return $this
  553.      */
  554.     public function Values(array $Values)
  555.     {
  556.         $this->Values_ = $Values;
  557.         return $this;
  558.     }
  560.     /**
  561.      * Setの定義 And でつなぐ
  562.      *
  563.      * @param string $Column
  564.      * @param string $Value 値
  565.      * @param string $Math 四則 =,!=,<,<=,>,>=,NULL等
  566.      * @param array $Param 未使用
  567.      * @return $this
  568.      */
  569.     public function Set($Column, $Value, $Math = '=', array $Param = [])
  570.     {
  571.         $Math = isset($Math) ? $Math : '=';
  572.         $this->Set_[] = array_merge(['Column' => $Column, 'Value' => $Value, 'Math' => $Math], $Param);
  573.         return $this;
  574.     }
  576.     /**
  577.      * Joinの定義
  578.      * @param string $Table
  579.      * @param string $On
  580.      * @param string $Join
  581.      * @return $this
  582.      */
  583.     public function Join($Table, $On, $Join = 'LEFT')
  584.     {
  585.         $this->Join_[] = ['Table' => $Table, 'On' => $On, 'Join' => $Join];
  586.         return $this;
  587.     }
  590.     /**
  591.      * OrderBYの取得
  592.      * @param string $Column
  593.      * @param string $Sort 初期値 ASC DESC
  594.      * @return $this
  595.      */
  596.     public function Order($Column, $Sort = 'ASC')
  597.     {
  598.         $this->Order_[] = ['Column' => $Column, 'Sort' => $Sort];
  599.         return $this;
  600.     }
  602.     /**
  603.      * OrderBYの取得
  604.      * @param string $Column
  605.      * @return $this
  606.      */
  607.     public function OrderBy($OrderBy)
  608.     {
  609.         $this->OrderBy_ = $OrderBy;
  610.         return $this;
  611.     }
  613.     /**
  614.      * GroupByの取得
  615.      * @param string $Group
  616.      * @return $this
  617.      */
  618.     public function GroupBy($Group)
  619.     {
  620.         $this->Group_ = $Group;
  621.         return $this;
  622.     }
  624.     /**
  625.      * Selectsの取得
  626.      * @param string Selects
  627.      * @return $this
  628.      */
  629.     public function Selects($Column)
  630.     {
  631.         $this->Selects_[] = $Column;
  632.         return $this;
  634.     }
  636.     /**
  637.      * Columnの取得
  638.      * @param string $Column
  639.      * @return $this
  640.      */
  642.     public function Column($Column)
  643.     {
  644.         $this->Column_[] = $Column;
  645.         return $this;
  646.     }
  648.     /**
  649.      * Limitの設定
  650.      * @param $Limit int
  651.      * @param $Limit2 int
  652.      */
  653.     public function Limit($Limit, $Limit2 = '')
  654.     {
  655.         $this->Limit_ = $Limit;
  656.         if ($Limit2){
  657.             $this->Limit_.= ','.$Limit2;
  658.         }
  659.         return $this;
  660.     }
  662.     /**
  663.      * Limitの設定
  664.      * @param int $OffSet
  665.      * @return $this
  666.      */
  667.     public function Offset($OffSet)
  668.     {
  669.         $this->OffSet_ = $OffSet;
  670.         return $this;
  671.     }
  673.     /**
  674.      * SELECT SQL文の作成
  675.      *
  676.      * @return $this
  677.      */
  679.     protected function MakeSelect()
  680.     {
  682.         #SELRCT句の作成
  683.         $this->Sql_ = 'SELECT ' . $this->SetSelect() . ' ';
  685.         #FROM句の作成
  686.         $from = 'FROM ' . self::SetAsTable($this->Table_);
  687.         #Join句の作成
  688.         $join = $this->SetJoin();
  689.         #Where句の作成
  690.         $where = $this->SetWhere();
  691.         #GroupBy句の作成
  692.         $groupby = self::SetGroupBy($this->Group_);
  694.         $this->Sql_ .= $from . $join . $where . $groupby;
  696.         #OrderBY句の作製
  697.         $this->Sql_ .= $this->SetOrder();
  698.         #Limit句の作成
  699.         $this->Sql_ .= self::SetLimit($this->Limit_);
  700.         #OffSet句の作成
  701.         $this->Sql_ .= self::SetOffSet($this->OffSet_);
  703.         return $this;
  705.     }
  707.     /**
  708.      * UpDate の  SQL文の作成
  709.      *
  710.      * @return $this
  711.      */
  712.     protected function MakeUpdate()
  713.     {
  715.         $this->Sql_ = 'UPDATE ' . self::SetAsTable($this->Table_);
  716.         $this->Sql_ .= ' SET ';
  717.         $this->Sql_ .= $this->SetValues();
  718.         $this->Sql_ .= $this->SetWhere();
  720.         return $this;
  721.     }
  723.     /**
  724.      * Insert の  SQL文の作成
  725.      *
  726.      * @return string
  727.      */
  728.     protected function MakeInsert()
  729.     {
  731.         $this->Sql_ = 'INSERT INTO ' . $this->Table_;
  732.         $this->Sql_ .= ' SET ';
  733.         $this->Sql_ .= $this->SetValues(false);
  735.     }
  737.     /**
  738.      * Inserts の  SQL文の作成
  739.      *
  740.      * @return string
  741.      */
  742.     protected function MakeInserts()
  743.     {
  746.         $this->Sql_ = "INSERT INTO {$this->Table_} ";
  747.         $this->Sql_ .= '(' . implode(',', array_keys(current($this->Values_))) . ')';
  748.         $this->Sql_ .= ' VALUES ';
  750.         $i = 0;
  752.         foreach ($this->Values_ as $Values) {
  753.             $Re = [];
  755.             foreach ($Values as $Column => $Value) {
  758.                 $Param = ':' . $Column . '_' . $i;
  760.                 $Param = $this->SetValue($Value, $Param);
  763.                 $Re[] = $Param;
  766.             }
  768.             $i++;
  769.             $this->Sql_ .= '(' . implode(',', $Re) . '),';
  770.         }
  771.         $this->Sql_ = trim($this->Sql_, ',');
  773.         # ON DUPLICATE KEY UPDATE の設定
  774.         if (count($this->Column_) > 0) {
  775.             $Keys = [];
  776.             foreach ($this->Column_ as $Column) {
  777.                 $Columns[] = preg_match('/\=/', $Column) ? $Column : "{$Column} = VALUES({$Column})";
  778.             }
  779.             $this->Sql_ .= " ON DUPLICATE KEY UPDATE " . implode(',', $Columns);
  780.         }
  782.     }
  784.     protected function MakeDelete()
  785.     {
  786.         $this->Sql_ = 'DELETE FROM ' . $this->Table_;
  787.         $this->Sql_ .= $this->SetWhere(false);
  789.     }
  791.     /**
  792.      * SELECT 文に AS句を付ける
  793.      * @return string
  794.      */
  795.     protected function SetSelect()
  796.     {
  798.         $Re = [];
  800.         if (Count($this->Column_) > 0) {
  801.             $this->Select_ .= ($this->Select_ ? ',' : '') . implode(',', $this->Column_);
  803.         }
  806.         $Selects = $this->Select_ ? explode(',', $this->Select_) : [];
  809.         $Selects = array_merge($Selects, $this->Selects_);
  811.         if (count($Selects) < 1) {
  812.             return self::SELECT;
  813.         }
  814.         foreach ($Selects as $Select) {
  815.             $Re[] = self::SetAs($Select);
  816.         }
  818.         return implode(',', $Re);
  820.     }
  822.     /**
  823.      * 外部連結を作成する
  824.      *
  825.      * @return string $Join
  826.      */
  827.     protected function SetJoin()
  828.     {
  830.         $Joins = '';
  832.         foreach ($this->Join_ as $i => $Join) {
  834.             $As = $i + 1;
  835.             // TODO: BETWEEN ANDの対応
  836.             $Ons2 = preg_split('/\s+(AND|OR)\s+/i', $Join['On'], -1, PREG_SPLIT_DELIM_CAPTURE);
  837.             $Ons3 = [];
  838.             foreach ($Ons2 as $On2) {
  839.                 // TODO: 括弧付きの複雑な式の対応
  840.                 if (in_array(strtoupper($On2), [
  841.                     'AND',
  842.                     'OR',
  843.                 ])) {
  844.                     $Ons = $On2;
  845.                 } else {
  846.                     // TODO: INの対応
  847.                     // TODO: ISの対応
  848.                     // $Ons = explode('=', $On2);
  849.                     // for ($i = 0; $i <= 1; $i++) {
  850.                     //     $Ons[$i] = trim((isset($Ons[$i]) ? $Ons[$i] : ''), ' ');
  851.                     //     $Ons[$i] = self::SetAs($Ons[$i], ($i ? $As : ''));
  852.                     // }
  853.                     // $Ons = $Ons[0] . ' = ' . $Ons[1];
  854.                     $Ons = preg_split('/(!=|=|<>|<|>)/', $On2, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
  855.                     foreach (array_chunk($Ons, 3) as $OnChunk) {
  856.                         foreach ($OnChunk as $i => $On) {
  857.                             if (($i + 1) % 2 === 0) {
  858.                                 $delim = $On;
  859.                             } else {
  860.                                 $Ons[$i] = trim((isset($Ons[$i]) ? $Ons[$i] : ''), ' ');
  861.                                 $Ons[$i] = self::SetAs($Ons[$i], ($i ? $As : ''));
  862.                             }
  863.                         }
  864.                         $Ons = "{$Ons[0]} {$delim} {$Ons[2]}";
  865.                     }
  866.                 }
  867.                 $Ons3 = array_merge($Ons3, (array)$Ons);
  868.             }
  870.             $Table = self::SetAsTable($Join['Table'], $As);
  872.             $Joins .= ' ' . strtoupper($Join['Join']) . ' JOIN ' . $Table . ' ON ' . implode(' ', $Ons3);
  873.         }
  874.         return $Joins;
  875.     }
  878.     /**
  879.      * 配列の値をセットする
  880.      * @param int|bool $Flg
  881.      * @return string
  882.      */
  883.     protected function SetValues($Flg = true)
  884.     {
  886.         $Sql = '';
  887.         $Values = [];
  889.         foreach ($this->Values_ as $Column => $Value) {
  891.             $Param = ":{$Column}";
  892.             #値を パラメーターに設定する
  893.             $Param = $this->SetValue($Value, $Param);
  895.             $Values[] = ($Flg ? self::SetAs($Column) : $Column) . ' = ' . $Param;
  897.         }
  900.         return implode(',', $Values);
  902.     }
  904.     /**
  905.      * 値のセットをする
  906.      *
  907.      * @param string $Value
  908.      * @param string $Param
  909.      * @return mixed|string
  910.      */
  911.     protected function SetValue($Value, $Param)
  912.     {
  914.         switch (true) {
  915.             case preg_match('/^(NOW\(\)|NOW)$/i', trim($Value)):
  916.                 $Param = 'NOW()';
  917.                 break;
  919.             default:
  920.                 $this->Param_[$Param] = $Value;
  921.                 break;
  922.         }
  924.         return $Param;
  925.     }
  928.     /**
  929.      * WHERE句を作成する
  930.      *
  931.      * @Param int|bool $Flg
  932.      * @return string $Where
  933.      */
  934.     protected function SetWhere($Flg = true)
  935.     {
  937.         $Where = '';
  938.         foreach ($this->Set_ as $i => $Set) {
  940.             #論理記号を入れる ここで変更することは可能
  941.             $Logical = 'AND';
  942.             $Where .= $Where ? " {$Logical} " : ' WHERE (';
  943.             #演算子のセット
  944.             $Where .= $this->MakeWhere($Set, $Flg);
  945.         }
  946.         #$this->Set_を閉じる
  947.         $Where .= $Where ? ')' : self::DEF;
  949.         foreach ($this->Where_ as $i => $Wheres) {
  950.             //* 要確認：下記の判定があると、WhereLogical に設定した値が入らずSQL構文エラーとなるため削除
  951.             //******** if ($Wheres === reset($this->Where_)) {
  952.             $Where .= $Where ? ' ' . $this->WhereLogical[$i] : ' WHERE ';
  953.             //******** }
  954.             $Where .= ' ( ' . $Wheres . ' ) ';
  957.         }
  960.         return $Where;
  962.     }
  964.     protected function MakeWhere($Set, $Flg = true)
  965.     {
  967.         #カラムの設定
  968.         $Column = $Flg ? self::SetAs($Set['Column']) : $Set['Column'];
  970.         $Param = self::ParamKIgo . preg_replace(self::AS_PATAN, '', $Column) . '_' . $this->Num++;
  972.         $Math = $Set['Math'];
  973.         $Value = $Set['Value'];
  975.         switch (true) {
  976.             case 'IN' == $Math:
  977.                 $Math = "IN ( " . self::SetIn($Value,$Param) . " ) ";
  978.                 $Param = '';
  979.                 break;
  980.             case 'NOT IN' == $Math:
  981.                 $Math = "NOT IN ( " .self::SetIn($Value,$Param) . " ) ";
  982.                 $Param = '';
  983.                 break;
  984.             case preg_match('/NOT NULL|NOTNULL|IS NOT NULL/i', $Value):
  985.             case preg_match('/NOT NULL|NOTNULL|IS NOT NULL/i', $Math):
  986.                 $Math = 'IS NOT NULL';
  987.                 $Param = '';
  988.                 break;
  989.             case is_null($Value);
  990.             case preg_match('/NULL|IS NULL/i', $Value):
  991.             case preg_match('/NULL|IS NULL/i', $Math):
  992.                 $Math = 'IS NULL';
  993.                 $Param = '';
  994.                 break;
  995.             case preg_match('/NOT LIKE/i', $Math):
  996.             case preg_match('/\%NOT LIKE\%/i', $Math):
  997.                 $Math = 'NOT LIKE';
  998.                 $this->Param_[$Param] = '%' . $Value . '%';
  999.                 break;
  1000.             case preg_match('/\%NOT LIKE/i', $Math):
  1001.                 $Math = 'NOT LIKE';
  1002.                 $this->Param_[$Param] = '%' . $Value;
  1003.                 break;
  1004.             case preg_match('/NOT LIKE\%/i', $Math):
  1005.                 $Math = 'NOT LIKE';
  1006.                 $this->Param_[$Param] = $Value . '%';
  1007.                 break;
  1009.             case preg_match('/LIKE/i', $Math):
  1010.             case preg_match('/\%LIKE\%/i', $Math):
  1011.                 $Math = 'LIKE';
  1012.                 $this->Param_[$Param] = '%' . $Value . '%';
  1013.                 break;
  1014.             case preg_match('/\%LIKE/i', $Math):
  1015.                 $Math = 'LIKE';
  1016.                 $this->Param_[$Param] = '%' . $Value;
  1017.                 break;
  1018.             case preg_match('/LIKE\%/i', $Math):
  1019.                 $Math = 'LIKE';
  1020.                 $this->Param_[$Param] = $Value . '%';
  1021.                 break;
  1022.             case preg_match('/BETWEEN/i', $Math):
  1023.                 $separator = preg_match('/\-/', $Value) ? '-' : ',';
  1024.                 $Betweens = explode($separator, $Value);
  1025.                 $this->Param_[$Param . '_f'] = isset($Betweens[0]) ? $Betweens[0] : 0;
  1026.                 $this->Param_[$Param . '_e'] = isset($Betweens[1]) ? $Betweens[1] : 0;
  1028.                 $Param = $Param . '_f AND ' . $Param . '_f';
  1030.                 break;
  1032.             case 'EXISTS' == $Math:
  1033.                 $As = '';
  1034.                 $Param = '';
  1035.                 $Column = $Math . ' ' . $Column;
  1036.                 break;
  1037.             default:
  1038.                 $this->Param_[$Param] = $Value;
  1039.                 break;
  1040.         }
  1042.         return $Column . ' ' . $Math . ' ' . $Param . ' ';
  1045.     }
  1047.     /**
  1048.      * WHERE句 INの設定
  1049.      * @param $Value string | array()
  1050.      * @param $Param srting
  1051.      * @return string
  1052.      */
  1054.     protected function SetIn($Value,$Param)
  1055.     {
  1057.         if (!is_array($Value)) {
  1058.                 $Value = explode(',', $Value);
  1059.             }
  1060.         $Re=[];
  1062.         foreach($Value as $i=>$Val){
  1063.             $Params = $Param . '_' .$i;
  1064.             $this->Param_[$Params] = $Val ;
  1065.             $Re[] = $Params;
  1066.         }
  1068.         return implode(',',$Re);
  1069.     }
  1071.     /**
  1072.      * Order()の設定
  1073.      * OrderBy()の設定
  1074.      *
  1075.      * @return string $ReOrder
  1076.      */
  1077.     protected function SetOrder()
  1078.     {
  1080.         $ReOrder = '';
  1081.         if ($this->OrderBy_) {
  1082.             $ReOrder = ' ORDER BY ';
  1083.             foreach (explode(',', $this->OrderBy_) as $OrderBy) {
  1084.                 $Orders[] = self::SetAs($OrderBy);
  1085.             }
  1087.             $ReOrder .= implode(',', $Orders);
  1088.         }
  1090.         if (count($this->Order_) < 1) {
  1091.             return $ReOrder;
  1092.         }
  1094.         if (!$ReOrder) {
  1095.             $ReOrder = ' ORDER BY ';
  1096.         }
  1098.         $Orders = [];
  1099.         foreach ($this->Order_ as $Order) {
  1101.             $Orders[] = self::SetAs($Order['Column']) . ' ' . $Order['Sort'];
  1102.         }
  1103.         $ReOrder .= implode(',', $Orders);
  1105.         return $ReOrder;
  1107.     }
  1109.     /**
  1110.      * GroupByの設定
  1111.      *
  1112.      * @param string $Group
  1113.      * @return string GroupBy句
  1114.      */
  1115.     protected static function SetGroupBy($Group)
  1116.     {
  1118.         if (!$Group) {
  1119.             return self::DEF;
  1120.         }
  1122.         $Re = [];
  1123.         foreach (explode(',', $Group) as $Column) {
  1124.             $Re[] = self::SetAs($Column);
  1125.         }
  1126.         return ' GROUP BY ' . implode(',', $Re);
  1127.     }
  1129.     /**
  1130.      * Limitの設定
  1131.      *
  1132.      * @param int $Limit
  1133.      * @return string Limit句
  1134.      */
  1135.     protected static function SetLimit($Limit)
  1136.     {
  1137.         if (!$Limit) {
  1138.             return self::DEF;
  1139.         }
  1140.         return ' Limit ' . $Limit;
  1141.     }
  1143.     /**
  1144.      * OffSetの設定
  1145.      *
  1146.      * @param int $OffSet
  1147.      * @return string OffSet句
  1148.      */
  1149.     protected static function SetOffSet($OffSet)
  1150.     {
  1151.         if (!$OffSet) {
  1152.             return self::DEF;
  1153.         }
  1154.         return ' OFFSET ' . $OffSet;
  1155.     }
  1157.     /**
  1158.      * カラムのアズ句を管理する
  1159.      * Table,SELECT,
  1160.      *
  1161.      * @param string $Column
  1162.      * @param string $As
  1163.      * @return string $Column
  1164.      */
  1165.     protected static function SetAs($Column, $As = '')
  1166.     {
  1167.         #既にAS句がある
  1168.         $Column = trim($Column);
  1169.         if (preg_match(self::AS_PATAN, $Column)) {
  1170.             return $Column;
  1171.         }
  1172.         #括弧等の記号が有る
  1173.         if (preg_match('/\(|\)|\.|:/', $Column)) {
  1174.             return $Column;
  1175.         }
  1176.         #カラム名でない(文字列リテラル)
  1177.         if (preg_match('/^[\'"].*[\'"]$/', $Column)) {
  1178.             return $Column;
  1179.         }
  1180.         #カラム名でない(数値)
  1181.         if (preg_match('/^[0-9]/', $Column)) {
  1182.             return $Column;
  1183.         }
  1184.         return self::AS_SYMBOL . $As . '.' . $Column;
  1185.     }
  1187.     /**
  1188.      * TABLのアズ句を管理する
  1189.      * Table,SELECT,
  1190.      *
  1191.      * @param string $Table
  1192.      * @param string $As
  1193.      * @return string $Table
  1194.      */
  1195.     protected static function SetAsTable($Table, $As = '')
  1196.     {
  1197.         #既にAS句がある
  1198.         if (preg_match('/ AS /', $Table)) {
  1199.             return $Table;
  1200.         }
  1201.         return $Table . ' AS ' . self::AS_SYMBOL . $As;
  1202.     }
  1205.     /**
  1206.      * 1以上Sql分を表示する パラメーターは配列で表示
  1207.      * =2 exit付き
  1208.      */
  1209.     protected function ViewSql()
  1210.     {
  1211.         if (!$this->ViewFlg) {
  1212.             return;
  1213.         }
  1215.         echo $this->Sql_;
  1216.         print_r($this->Param_);
  1218.         if (2 == $this->ViewFlg) {
  1219.             exit;
  1220.         }
  1222.     }
  1227.     /*
  1228.     http://dozo.matrix.jp/pear/index.php/PECL/pdo/fetch.html
  1229.     execute()  準備したprepareに入っているSQL文を実行
  1230.     prepare()  値部分にパラメータを付けて実行待ち
  1231.     query()    prepareを使わずにSQL文を実行
  1232.     PDOException  エラーを投げる
  1233.     bindParam  与えられた変数を文字列としてパラメータに入れる
  1234.     bindValue  与えられた変数や数値を型を指定してパラメータに入れる※1
  1235.     PDO::PARAM_STR 変数の値を文字列として扱う
  1236.     PDO::PARAM_INT 変数の値を数値として扱う
  1237.     PDO::PARAM_BOOL
  1238.     PDO::PARAM_NULL (integer)
  1239.     :nameなど    パラメータ（：の後に任意の文字）
  1240.     PDO::FETCH_ASSOC   連想配列として取得します。※2
  1242.     PDO::ATTR_ORACLE_NULLS
  1243.     $stmt->bindParam(':name', $name, PDO::PARAM_STR);
  1244.     $stmt->bindValue(':value', 1, PDO::PARAM_INT);
  1245.     $stmt->bindValue(":value", null, PDO::PARAM_NULL); NULL を入れる
  1247.     */
  1249.     /**
  1250.      * クエリを実行し、結果をすべて取得
  1251.      *
  1252.      * @param  int|bool $Flg $ViewFlg 1 #SQl分をエコーで表示する パラメーターは配列 2 exit 付き
  1253.      * @return array
  1254.      * 空の戻り値がbArrayを返す を DEF 初期値 に統一
  1255.      */
  1256.     public function FetchAll($Flg = false)
  1257.     {
  1258.         if ($Flg) {
  1259.             $this->ViewFlg = $Flg;
  1260.         }
  1261.         if (!$this->Sql_) {
  1262.             return self::RE;
  1263.         }
  1264.         $this->ViewSql();
  1266.         $label = [
  1267.             'Sql_' => $this->Sql_,
  1268.             'Param_' => $this->Param_,
  1269.         ];
  1271.         try {
  1272.             return $this->getCached(function () {
  1274.                 $Re = [];
  1276.                 if (count($this->Param_) > 0) {
  1278.                     #PDOStatementの取得
  1279.                     $this->Stmt = $this->Connect[self::READ]->prepare($this->Sql_, [\PDO::ATTR_CURSOR => \PDO::CURSOR_FWDONLY]);
  1281.                     #パラメーターのセット
  1282.                     $this->SetParameter();
  1283.                     $this->Stmt->execute();
  1285.                 } else {
  1286.                     $this->Stmt = $this->Connect[self::READ]->query($this->Sql_);
  1287.                 }
  1289.                 $Re = $this->Stmt->fetchAll(\PDO::FETCH_ASSOC);
  1291.                 return Count($Re) > 0 ? $Re : self::RE;
  1292.             }, $label);
  1293.         } finally {
  1294.             $this->Initialize();
  1295.         }
  1296.     }
  1298.     /**
  1299.      * クエリを実行し、結果を1行取得
  1300.      *
  1301.      * @param int|bool $Flg
  1302.      * @return array
  1303.      *
  1304.      * 空の戻り値がboolean =falseを返す FetchAllと統一
  1305.      */
  1306.     public function Fetch($Flg = false)
  1307.     {
  1309.         if ($Flg) {
  1310.             $this->ViewFlg = $Flg;
  1311.         }
  1312.         if (!$this->Sql_) {
  1313.             return self::RE;
  1314.         }
  1315.         $this->ViewSql();
  1317.         if (count($this->Param_) > 0) {
  1318.             $stmt = $this->Connect[self::READ]->prepare($this->Sql_, [\PDO::ATTR_CURSOR => \PDO::CURSOR_FWDONLY]);
  1320.             foreach ($this->Param_ as $Param => $Value) {
  1322.                 $stmt->bindValue($Param, $Value, \PDO::PARAM_STR);
  1324.             }
  1325.             $stmt->execute();
  1326.         } else {
  1328.             $stmt = $this->Connect[self::READ]->query($this->Sql_);
  1329.         }
  1331.         $this->Initialize();
  1333.         $Value = $stmt->fetch(\PDO::FETCH_ASSOC);
  1335.         return $Value;
  1337.     }
  1340.     protected function FOREIGN_KEY($Flg = 0)
  1341.     {
  1343.         $this->Stmt = $this->Connect[self::WRITE]->prepare("SET FOREIGN_KEY_CHECKS={$Flg};");
  1344.         $this->Stmt->execute();
  1346.     }
  1349.     public function Exec($Flg = false)
  1350.     {
  1352.         if ($Flg) {
  1353.             $this->ViewFlg = $Flg;
  1354.         }
  1356.         if (!$this->Sql_) {
  1357.             return self::RE;
  1358.         }
  1360.         #外部キーリレーションシップの解除
  1361.         if (!is_null($this->ForeignKey_)) {
  1362.             $this->FOREIGN_KEY($this->ForeignKey_);
  1363.         }
  1365.         $this->ViewSql();
  1367.         $this->Stmt = $this->Connect[self::WRITE]->prepare($this->Sql_, [\PDO::ATTR_CURSOR => \PDO::CURSOR_FWDONLY]);
  1369.         #パラメーターのセット
  1370.         $this->SetParameter();
  1372.         #実行
  1373.         $Num = $this->Stmt->execute();
  1375.         #初期化
  1376.         $this->Initialize();
  1378.         return $Num;
  1379.     }
  1381.     /**
  1382.      * パラメーターをセットする
  1383.      * @param $this->Param_
  1384.      * @param $this->Stmt
  1385.      */
  1386.     protected function SetParameter()
  1387.     {
  1389.         foreach ($this->Param_ as $Param => $Value) {
  1390.             //echo gettype($Value);
  1391.             switch (gettype($Value)) {
  1392.                 case 'NULL':
  1393.                     $this->Stmt->bindValue($Param, null, \PDO::PARAM_NULL);
  1394.                     break;
  1395.                 case 'boolean':
  1396.                       $Value =  $Value ? 1 : 0 ;
  1397.                 case 'integer':
  1398.                     if (preg_match('/^0+[0-9]+$/', $Value)){ #頭が0の数字は 文字として判断
  1399.                     $this->Stmt->bindValue($Param, $Value, \PDO::PARAM_STR);
  1400.                     break;
  1401.                     }
  1402.                     $this->Stmt->bindValue($Param, $Value, \PDO::PARAM_INT);
  1403.                     break;
  1404.                 case 'double':
  1405.                 case 'string':
  1406.                 default:
  1407.                     $this->Stmt->bindValue($Param, $Value, \PDO::PARAM_STR);
  1408.                     break;
  1409.             }
  1410.         }
  1411.     }
  1413.     /**
  1414.      * トランザクション: 開始
  1415.      *
  1416.      * @return bool
  1417.      */
  1418.     public function beginTransaction()
  1419.     {
  1420.         return $this->Connect[self::WRITE]->beginTransaction();
  1421.     }
  1423.     /**
  1424.      * トランザクション: コミット
  1425.      *
  1426.      * @return bool
  1427.      */
  1428.     public function commit()
  1429.     {
  1430.         return $this->Connect[self::WRITE]->commit();
  1431.     }
  1433.     /**
  1434.      * トランザクション: ロールバック
  1435.      *
  1436.      * @return bool
  1437.      */
  1438.     public function rollBack()
  1439.     {
  1440.         return $this->Connect[self::WRITE]->rollBack();
  1441.     }
  1443. }