Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
95.73%
112 / 117
94.74%
18 / 19
 CRAP
0.00%
0 / 1
Base
95.73%
112 / 117
94.74%
18 / 19
 34
0.00%
0 / 1
 __construct
100.00%
2 / 2
100.00%
1 / 1
 1
 init
100.00%
2 / 2
100.00%
1 / 1
 1
 getWriter
100.00%
4 / 4
100.00%
1 / 1
 2
 getReader
100.00%
5 / 5
100.00%
1 / 1
 3
 fetchPreparedStatement
100.00%
9 / 9
100.00%
1 / 1
 3
 startExecute
100.00%
5 / 5
100.00%
1 / 1
 1
 pdoExceptionHandler
100.00%
13 / 13
100.00%
1 / 1
 4
 fetchStatement
100.00%
3 / 3
100.00%
1 / 1
 1
 fetchOne
100.00%
7 / 7
100.00%
1 / 1
 2
 fetchRow
100.00%
7 / 7
100.00%
1 / 1
 1
 fetchValue
100.00%
7 / 7
100.00%
1 / 1
 1
 fetchAll
100.00%
7 / 7
100.00%
1 / 1
 1
 fetchHandle
100.00%
5 / 5
100.00%
1 / 1
 1
 fetchList
100.00%
8 / 8
100.00%
1 / 1
 2
 writeItem
100.00%
7 / 7
100.00%
1 / 1
 1
 deleteItem
100.00%
1 / 1
100.00%
1 / 1
 1
 perform
100.00%
7 / 7
100.00%
1 / 1
 1
 fetchAffected
100.00%
8 / 8
100.00%
1 / 1
 1
 readResolvedReferences
n/a
0 / 0
n/a
0 / 0
 1
 hashStringValue
50.00%
5 / 10
0.00%
0 / 1
 8.12
1<?php
2
3namespace BO\Zmsbackend;
4
5/**
6 * @SuppressWarnings(NumberOfChildren)
7 * @SuppressWarnings(Public)
8 *
9 */
10abstract class Base
11{
12    /**
13     * @var Connection\Pdo|null $writeDb Database connection
14     */
15    protected $writeDb = null;
16
17    /**
18     * @var Connection\Pdo|null $readDb Database connection
19     */
20    protected $readDb = null;
21
22    /**
23     * Cache prepared statements
24     *
25     */
26    protected static $preparedCache = [];
27
28    /**
29     * Make sure, we do not cache statements on different connections
30     *
31     */
32    protected static $preparedConnectionId = null;
33
34    /**
35     * @param Connection\Pdo|null $writeConnection
36     * @param Connection\Pdo|null $readConnection
37     */
38    public function __construct(Connection\Pdo $writeConnection = null, Connection\Pdo $readConnection = null)
39    {
40        $this->writeDb = $writeConnection;
41        $this->readDb = $readConnection;
42    }
43
44    public static function init(Connection\Pdo $writeConnection = null, Connection\Pdo $readConnection = null)
45    {
46        $instance = new static($writeConnection, $readConnection);
47        return $instance;
48    }
49
50    public function getWriter(): Connection\Pdo
51    {
52        if (null === $this->writeDb) {
53            $this->writeDb = Connection\Select::getWriteConnection();
54            $this->readDb = $this->writeDb;
55        }
56        return $this->writeDb;
57    }
58
59    public function getReader(): Connection\Pdo
60    {
61        if (null !== $this->writeDb) {
62            // if readDB gets a reset, still use writeDB
63            return $this->writeDb;
64        }
65        if (null === $this->readDb) {
66            $this->readDb = Connection\Select::getReadConnection();
67        }
68        return $this->readDb;
69    }
70
71    public function fetchPreparedStatement($query)
72    {
73        $sql = "$query";
74        $reader = $this->getReader();
75        if (spl_object_hash($reader) != static::$preparedConnectionId) {
76            // do not use prepared statements on a different connection
77            static::$preparedCache = [];
78            static::$preparedConnectionId = spl_object_hash($reader);
79        }
80        if (!isset(static::$preparedCache[$sql])) {
81            $prepared = $this->getReader()->prepare($sql);
82            static::$preparedCache[$sql] = $prepared;
83        }
84        return static::$preparedCache[$sql];
85    }
86
87    public function startExecute($statement, $parameters)
88    {
89        $statement = static::pdoExceptionHandler(function () use ($statement, $parameters) {
90            $statement->execute($parameters);
91            return $statement;
92        });
93        return $statement;
94    }
95
96    protected static function pdoExceptionHandler(\Closure $pdoFunction, $parameters = [])
97    {
98        try {
99            $statement = $pdoFunction($parameters);
100        } catch (\PDOException $pdoException) {
101            if (stripos($pdoException->getMessage(), 'Lock wait timeout') !== false) {
102                throw new \BO\Zmsbackend\Exception\Pdo\LockTimeout();
103            }
104            //@codeCoverageIgnoreStart
105            if (stripos($pdoException->getMessage(), 'Deadlock found') !== false) {
106                throw new \BO\Zmsbackend\Exception\Pdo\DeadLockFound();
107            }
108            //@codeCoverageIgnoreEnd
109            $message = "SQL: "
110                . " Err: "
111                . $pdoException->getMessage()
112                //. " || Statement: "
113                //.$statement->queryString
114                //." || Parameters=". var_export($parameters, true)
115                ;
116            throw new \BO\Zmsbackend\Exception\Pdo\PDOFailed($message, 0, $pdoException);
117        }
118        return $statement;
119    }
120
121    public function fetchStatement(Query\Base $query)
122    {
123        $parameters = $query->getParameters();
124        $statement = $this->startExecute($this->fetchPreparedStatement($query), $parameters);
125        return $statement;
126    }
127
128    /**
129     * @template T of \BO\Zmsentities\Schema\Entity
130     * @param T $entity
131     * @return T
132     */
133    public function fetchOne(Query\Base $query, \BO\Zmsentities\Schema\Entity $entity)
134    {
135        $statement = $this->fetchStatement($query);
136        $data = $statement->fetch(\PDO::FETCH_ASSOC);
137        if ($data) {
138            $entity->exchangeArray($query->postProcessJoins($data));
139            $entity->setResolveLevel($query->getResolveLevel());
140        }
141        $statement->closeCursor();
142        return $entity;
143    }
144
145    public function fetchRow($query, $parameters = null)
146    {
147        return static::pdoExceptionHandler(function () use ($query, $parameters) {
148            $prepared = $this->fetchPreparedStatement($query);
149            $prepared->execute($parameters);
150            $row = $prepared->fetch(\PDO::FETCH_ASSOC);
151            $prepared->closeCursor();
152            return $row;
153        });
154    }
155
156    public function fetchValue($query, $parameters = null)
157    {
158        return static::pdoExceptionHandler(function () use ($query, $parameters) {
159            $prepared = $this->fetchPreparedStatement($query);
160            $prepared->execute($parameters);
161            $value = $prepared->fetchColumn();
162            $prepared->closeCursor();
163            return $value;
164        });
165    }
166
167    public function fetchAll($query, $parameters = null)
168    {
169        return static::pdoExceptionHandler(function () use ($query, $parameters) {
170            $prepared = $this->fetchPreparedStatement($query);
171            $prepared->execute($parameters);
172            $list = $prepared->fetchAll(\PDO::FETCH_ASSOC);
173            $prepared->closeCursor();
174            return $list;
175        });
176    }
177
178    public function fetchHandle($query, $parameters = null)
179    {
180        return static::pdoExceptionHandler(function () use ($query, $parameters) {
181            $prepared = $this->fetchPreparedStatement($query);
182            $prepared->execute($parameters);
183            return $prepared;
184        });
185    }
186
187    public function fetchList(Query\Base $query, \BO\Zmsentities\Schema\Entity $entity, $resultList = [])
188    {
189        $statement = $this->fetchStatement($query);
190        while ($data = $statement->fetch(\PDO::FETCH_ASSOC)) {
191            $dataEntity = clone $entity;
192            $dataEntity->exchangeArray($query->postProcessJoins($data));
193            $dataEntity->setResolveLevel($query->getResolveLevel());
194            $resultList[] = $dataEntity;
195        }
196        $statement->closeCursor();
197        return $resultList;
198    }
199
200    /**
201     * Write an Item to database - Insert, Update
202     *
203     * @param Query\Base $query
204     * @return bool
205     */
206    public function writeItem(Query\Base $query)
207    {
208        return static::pdoExceptionHandler(function () use ($query) {
209            $this->getWriter(); //Switch to writer for write/delete
210            $statement = $this->fetchPreparedStatement($query);
211            $status = $statement->execute($query->getParameters());
212            $statement->closeCursor();
213            return $status;
214        });
215    }
216
217    /**
218     * @param Query\Base $query
219     * @return bool
220     */
221    public function deleteItem(Query\Base $query)
222    {
223        return $this->writeItem($query);
224    }
225
226    public function perform($sql, $parameters = null)
227    {
228        return static::pdoExceptionHandler(function () use ($sql, $parameters) {
229            $this->getWriter(); //Switch to writer for perform
230            $prepared = $this->fetchPreparedStatement($sql);
231            $status = $prepared->execute($parameters);
232            $prepared->closeCursor();
233            return $status;
234        });
235    }
236
237    public function fetchAffected($sql, $parameters = null)
238    {
239        return static::pdoExceptionHandler(function () use ($sql, $parameters) {
240            $this->getWriter(); //Switch to writer for perform
241            $prepared = $this->fetchPreparedStatement($sql);
242            $prepared->execute($parameters);
243            $count = $prepared->rowCount();
244            $prepared->closeCursor();
245            return $count;
246        });
247    }
248
249    /**
250     * @SuppressWarnings(Param)
251     * @codeCoverageIgnore
252     *
253     */
254    public function readResolvedReferences(\BO\Zmsentities\Schema\Entity $entity, $resolveReferences)
255    {
256        return $entity;
257    }
258
259    /**
260     * This function produces a hash value that contains info for comparison
261     *
262     * @param string $value
263     * @param callable|null $callable function to be used for hashing
264     * @return string
265     */
266    public function hashStringValue(string $value, callable $callable = null): string
267    {
268        if ($callable === null) {
269            $callable = 'sha1';
270        }
271
272        if (is_callable($callable)) {
273            $hash = $callable($value);
274
275            if (is_string($callable)) {
276                return $callable . ':' . $hash;
277            }
278            if ($callable instanceof \Closure) {
279                return 'closure:' . $hash;
280            }
281            // else
282            return 'custom:' . $hash;
283        }
284
285        throw new \InvalidArgumentException('hashStringValue() should be called with a callable as second parameter.');
286    }
287}