Completed
Push — master ( ebd28e...b02daa )
by Ivan
03:34
created
src/schema/TableQuery.php 1 patch
Spacing   +155 added lines, -158 removed lines patch added patch discarded remove patch
@@ -44,7 +44,7 @@  discard block
 block discarded – undo
44 44
     /**
45 45
      * @var int[]
46 46
      */
47
-    protected $li_of = [0,0,0];
47
+    protected $li_of = [0, 0, 0];
48 48
     /**
49 49
      * @var array
50 50
      */
@@ -74,7 +74,7 @@  discard block
 block discarded – undo
74 74
     public function __construct(DBInterface $db, $table)
75 75
     {
76 76
         $this->db = $db;
77
-        $this->definition = $table instanceof Table ? $table : $this->db->definition((string)$table);
77
+        $this->definition = $table instanceof Table ? $table : $this->db->definition((string) $table);
78 78
         $primary = $this->definition->getPrimaryKey();
79 79
         $columns = $this->definition->getColumns();
80 80
         $this->pkey = count($primary) ? $primary : $columns;
@@ -97,7 +97,7 @@  discard block
 block discarded – undo
97 97
     {
98 98
         $column = explode('.', $column);
99 99
         if (count($column) === 1) {
100
-            $column = [ $this->definition->getName(), $column[0] ];
100
+            $column = [$this->definition->getName(), $column[0]];
101 101
             $col = $this->definition->getColumn($column[1]);
102 102
             if (!$col) {
103 103
                 throw new DBException('Invalid column name in own table');
@@ -120,7 +120,7 @@  discard block
 block discarded – undo
120 120
                         throw new DBException('Invalid column name in related table');
121 121
                     }
122 122
                 } else {
123
-                    throw new DBException('Invalid foreign table name: ' . implode(',', $column));
123
+                    throw new DBException('Invalid foreign table name: '.implode(',', $column));
124 124
                 }
125 125
             }
126 126
         } else {
@@ -129,15 +129,15 @@  discard block
 block discarded – undo
129 129
             $table = $this->definition;
130 130
             $table = array_reduce(
131 131
                 $column,
132
-                function ($carry, $item) use (&$table) {
132
+                function($carry, $item) use (&$table) {
133 133
                     $table = $table->getRelation($item)->table;
134 134
                     return $table;
135 135
                 }
136 136
             );
137 137
             $col = $table->getColumn($name);
138
-            $column = [ implode(static::SEP, $column), $name ];
138
+            $column = [implode(static::SEP, $column), $name];
139 139
         }
140
-        return [ 'name' => implode('.', $column), 'data' => $col ];
140
+        return ['name' => implode('.', $column), 'data' => $col];
141 141
     }
142 142
     protected function normalizeValue(TableColumn $col, $value)
143 143
     {
@@ -184,9 +184,9 @@  discard block
 block discarded – undo
184 184
                 }
185 185
                 return $value;
186 186
             case 'int':
187
-                return (int)preg_replace('([^+\-0-9]+)', '', $value);
187
+                return (int) preg_replace('([^+\-0-9]+)', '', $value);
188 188
             case 'float':
189
-                return (int)preg_replace('([^+\-0-9.]+)', '', str_replace(',', '.', $value));
189
+                return (int) preg_replace('([^+\-0-9.]+)', '', str_replace(',', '.', $value));
190 190
             default:
191 191
                 return $value;
192 192
         }
@@ -201,25 +201,23 @@  discard block
 block discarded – undo
201 201
         }
202 202
         if (is_null($value)) {
203 203
             return $negate ?
204
-                [ $name . ' IS NOT NULL', [] ]:
205
-                [ $name . ' IS NULL', [] ];
204
+                [$name.' IS NOT NULL', []] : [$name.' IS NULL', []];
206 205
         }
207 206
         if (!is_array($value)) {
208 207
             return $negate ?
209 208
                 [
210
-                    $name . ' <> ?',
211
-                    [ $this->normalizeValue($column, $value) ]
212
-                ] :
213
-                [
214
-                    $name . ' = ?',
215
-                    [ $this->normalizeValue($column, $value) ]
209
+                    $name.' <> ?',
210
+                    [$this->normalizeValue($column, $value)]
211
+                ] : [
212
+                    $name.' = ?',
213
+                    [$this->normalizeValue($column, $value)]
216 214
                 ];
217 215
         }
218 216
         if (isset($value['beg']) && strlen($value['beg']) && (!isset($value['end']) || !strlen($value['end']))) {
219
-            $value = [ 'gte' => $value['beg'] ];
217
+            $value = ['gte' => $value['beg']];
220 218
         }
221 219
         if (isset($value['end']) && strlen($value['end']) && (!isset($value['beg']) || !strlen($value['beg']))) {
222
-            $value = [ 'lte' => $value['end'] ];
220
+            $value = ['lte' => $value['end']];
223 221
         }
224 222
         if (isset($value['beg']) && isset($value['end'])) {
225 223
             return $negate ?
@@ -229,8 +227,7 @@  discard block
 block discarded – undo
229 227
                         $this->normalizeValue($column, $value['beg']),
230 228
                         $this->normalizeValue($column, $value['end'])
231 229
                     ]
232
-                ] :
233
-                [
230
+                ] : [
234 231
                     $name.' BETWEEN ? AND ?',
235 232
                     [
236 233
                         $this->normalizeValue($column, $value['beg']),
@@ -242,34 +239,34 @@  discard block
 block discarded – undo
242 239
             $sql = [];
243 240
             $par = [];
244 241
             if (isset($value['gt'])) {
245
-                $sql[] = $name. ' ' . ($negate ? '<=' : '>') . ' ?';
242
+                $sql[] = $name.' '.($negate ? '<=' : '>').' ?';
246 243
                 $par[] = $this->normalizeValue($column, $value['gt']);
247 244
             }
248 245
             if (isset($value['gte'])) {
249
-                $sql[] = $name. ' ' . ($negate ? '<' : '>=') . ' ?';
246
+                $sql[] = $name.' '.($negate ? '<' : '>=').' ?';
250 247
                 $par[] = $this->normalizeValue($column, $value['gte']);
251 248
             }
252 249
             if (isset($value['lt'])) {
253
-                $sql[] = $name. ' ' . ($negate ? '>=' : '<') . ' ?';
250
+                $sql[] = $name.' '.($negate ? '>=' : '<').' ?';
254 251
                 $par[] = $this->normalizeValue($column, $value['lt']);
255 252
             }
256 253
             if (isset($value['lte'])) {
257
-                $sql[] = $name. ' ' . ($negate ? '>' : '<=') . ' ?';
254
+                $sql[] = $name.' '.($negate ? '>' : '<=').' ?';
258 255
                 $par[] = $this->normalizeValue($column, $value['lte']);
259 256
             }
260 257
             return [
261
-                '(' . implode(' AND ', $sql) . ')',
258
+                '('.implode(' AND ', $sql).')',
262 259
                 $par
263 260
             ];
264 261
         }
265 262
         return $negate ?
266 263
             [
267
-                $name . ' NOT IN (??)',
268
-                [ array_map(function ($v) use ($column) { return $this->normalizeValue($column, $v); }, $value) ]
264
+                $name.' NOT IN (??)',
265
+                [array_map(function($v) use ($column) { return $this->normalizeValue($column, $v); }, $value)]
269 266
             ] :
270 267
             [
271
-                $name . ' IN (??)',
272
-                [ array_map(function ($v) use ($column) { return $this->normalizeValue($column, $v); }, $value) ]
268
+                $name.' IN (??)',
269
+                [array_map(function($v) use ($column) { return $this->normalizeValue($column, $v); }, $value)]
273 270
             ];
274 271
     }
275 272
     /**
@@ -300,7 +297,7 @@  discard block
 block discarded – undo
300 297
                 $par = array_merge($par, $temp[1]);
301 298
             }
302 299
         }
303
-        return $this->where('(' . implode(' OR ', $sql) . ')', $par);
300
+        return $this->where('('.implode(' OR ', $sql).')', $par);
304 301
     }
305 302
     /**
306 303
      * Filter the results matching all of the criteria
@@ -318,7 +315,7 @@  discard block
 block discarded – undo
318 315
                 $par = array_merge($par, $temp[1]);
319 316
             }
320 317
         }
321
-        return $this->where('(' . implode(' AND ', $sql) . ')', $par);
318
+        return $this->where('('.implode(' AND ', $sql).')', $par);
322 319
     }
323 320
     /**
324 321
      * Sort by a column
@@ -328,7 +325,7 @@  discard block
 block discarded – undo
328 325
      */
329 326
     public function sort(string $column, bool $desc = false) : TableQuery
330 327
     {
331
-        return $this->order($this->getColumn($column)['name'] . ' ' . ($desc ? 'DESC' : 'ASC'));
328
+        return $this->order($this->getColumn($column)['name'].' '.($desc ? 'DESC' : 'ASC'));
332 329
     }
333 330
     /**
334 331
      * Group by a column (or columns)
@@ -338,7 +335,7 @@  discard block
 block discarded – undo
338 335
     public function group($column) : TableQuery
339 336
     {
340 337
         if (!is_array($column)) {
341
-            $column = [ $column ];
338
+            $column = [$column];
342 339
         }
343 340
         foreach ($column as $k => $v) {
344 341
             $column[$k] = $this->getColumn($v)['name'];
@@ -380,7 +377,7 @@  discard block
 block discarded – undo
380 377
         $this->order = [];
381 378
         $this->having = [];
382 379
         $this->aliases = [];
383
-        $this->li_of = [0,0,0];
380
+        $this->li_of = [0, 0, 0];
384 381
         $this->qiterator = null;
385 382
         return $this;
386 383
     }
@@ -393,7 +390,7 @@  discard block
 block discarded – undo
393 390
     public function groupBy(string $sql, array $params = []) : TableQuery
394 391
     {
395 392
         $this->qiterator = null;
396
-        $this->group = [ $sql, $params ];
393
+        $this->group = [$sql, $params];
397 394
         return $this;
398 395
     }
399 396
     /**
@@ -406,7 +403,7 @@  discard block
 block discarded – undo
406 403
      */
407 404
     public function join($table, array $fields, string $name = null, bool $multiple = true)
408 405
     {
409
-        $table = $table instanceof Table ? $table : $this->db->definition((string)$table);
406
+        $table = $table instanceof Table ? $table : $this->db->definition((string) $table);
410 407
         $name = $name ?? $table->getName();
411 408
         if (isset($this->joins[$name]) || $this->definition->hasRelation($name)) {
412 409
             throw new DBException('Alias / table name already in use');
@@ -415,7 +412,7 @@  discard block
 block discarded – undo
415 412
         foreach ($fields as $k => $v) {
416 413
             $k = explode('.', $k, 2);
417 414
             $k = count($k) == 2 ? $k[1] : $k[0];
418
-            $this->joins[$name]->keymap[$this->getColumn($name . '.' . $k)['name']] = $this->getColumn($v)['name'];
415
+            $this->joins[$name]->keymap[$this->getColumn($name.'.'.$k)['name']] = $this->getColumn($v)['name'];
419 416
         }
420 417
         return $this;
421 418
     }
@@ -428,7 +425,7 @@  discard block
 block discarded – undo
428 425
     public function where(string $sql, array $params = []) : TableQuery
429 426
     {
430 427
         $this->qiterator = null;
431
-        $this->where[] = [ $sql, $params ];
428
+        $this->where[] = [$sql, $params];
432 429
         return $this;
433 430
     }
434 431
     /**
@@ -440,7 +437,7 @@  discard block
 block discarded – undo
440 437
     public function having(string $sql, array $params = []) : TableQuery
441 438
     {
442 439
         $this->qiterator = null;
443
-        $this->having[] = [ $sql, $params ];
440
+        $this->having[] = [$sql, $params];
444 441
         return $this;
445 442
     }
446 443
     /**
@@ -452,7 +449,7 @@  discard block
 block discarded – undo
452 449
     public function order(string $sql, array $params = []) : TableQuery
453 450
     {
454 451
         $this->qiterator = null;
455
-        $this->order = [ $sql, $params ];
452
+        $this->order = [$sql, $params];
456 453
         return $this;
457 454
     }
458 455
     /**
@@ -464,7 +461,7 @@  discard block
 block discarded – undo
464 461
     public function limit(int $limit, int $offset = 0, bool $limitOnMainTable = false) : TableQuery
465 462
     {
466 463
         $this->qiterator = null;
467
-        $this->li_of = [ $limit, $offset, $limitOnMainTable ? 1 : 0 ];
464
+        $this->li_of = [$limit, $offset, $limitOnMainTable ? 1 : 0];
468 465
         return $this;
469 466
     }
470 467
     /**
@@ -474,9 +471,9 @@  discard block
 block discarded – undo
474 471
     public function count() : int
475 472
     {
476 473
         $aliases = [];
477
-        $getAlias = function ($name) use (&$aliases) {
474
+        $getAlias = function($name) use (&$aliases) {
478 475
             // to bypass use: return $name;
479
-            return $aliases[$name] = $aliases[$name] ?? 'alias' . static::SEP . count($aliases);
476
+            return $aliases[$name] = $aliases[$name] ?? 'alias'.static::SEP.count($aliases);
480 477
         };
481 478
         $table = $this->definition->getName();
482 479
         $sql = 'SELECT COUNT(DISTINCT '.$table.'.'.implode(', '.$table.'.', $this->pkey).') FROM '.$table.' ';
@@ -491,44 +488,44 @@  discard block
 block discarded – undo
491 488
         $h = $this->having;
492 489
         $o = $this->order;
493 490
         $g = $this->group;
494
-        $j = array_map(function ($v) { return clone $v; }, $this->joins);
491
+        $j = array_map(function($v) { return clone $v; }, $this->joins);
495 492
         foreach ($this->definition->getRelations() as $k => $v) {
496 493
             foreach ($w as $kk => $vv) {
497
-                if (preg_match('(\b'.preg_quote($k . '.'). ')i', $vv[0])) {
498
-                    $relations[$k] = [ $v, $table ];
499
-                    $w[$kk][0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $vv[0]);
494
+                if (preg_match('(\b'.preg_quote($k.'.').')i', $vv[0])) {
495
+                    $relations[$k] = [$v, $table];
496
+                    $w[$kk][0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $vv[0]);
500 497
                 }
501 498
             }
502
-            if (isset($o[0]) && preg_match('(\b'.preg_quote($k . '.'). ')i', $o[0])) {
503
-                $relations[$k] = [ $v, $table ];
499
+            if (isset($o[0]) && preg_match('(\b'.preg_quote($k.'.').')i', $o[0])) {
500
+                $relations[$k] = [$v, $table];
504 501
             }
505 502
             foreach ($h as $kk => $vv) {
506
-                if (preg_match('(\b'.preg_quote($k . '.'). ')i', $vv[0])) {
507
-                    $relations[$k] = [ $relation, $table ];
508
-                    $h[$kk][0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $vv[0]);
503
+                if (preg_match('(\b'.preg_quote($k.'.').')i', $vv[0])) {
504
+                    $relations[$k] = [$relation, $table];
505
+                    $h[$kk][0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $vv[0]);
509 506
                 }
510 507
             }
511
-            if (isset($g[0]) && preg_match('(\b'.preg_quote($k . '.'). ')i', $g[0])) {
512
-                $relations[$k] = [ $relation, $table ];
513
-                $g[0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $g[0]);
508
+            if (isset($g[0]) && preg_match('(\b'.preg_quote($k.'.').')i', $g[0])) {
509
+                $relations[$k] = [$relation, $table];
510
+                $g[0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $g[0]);
514 511
             }
515 512
             foreach ($j as $kk => $v) {
516 513
                 foreach ($v->keymap as $kkk => $vv) {
517
-                    if (preg_match('(\b'.preg_quote($k . '.'). ')i', $vv)) {
518
-                        $relations[$k] = [ $relation, $table ];
519
-                        $j[$k]->keymap[$kkk] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $vv);
514
+                    if (preg_match('(\b'.preg_quote($k.'.').')i', $vv)) {
515
+                        $relations[$k] = [$relation, $table];
516
+                        $j[$k]->keymap[$kkk] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $vv);
520 517
                     }
521 518
                 }
522 519
             }
523 520
         }
524 521
 
525 522
         foreach ($j as $k => $v) {
526
-            $sql .= ($v->many ? 'LEFT ' : '' ) . 'JOIN '.$v->table->getName().' '.$k.' ON ';
523
+            $sql .= ($v->many ? 'LEFT ' : '').'JOIN '.$v->table->getName().' '.$k.' ON ';
527 524
             $tmp = [];
528 525
             foreach ($v->keymap as $kk => $vv) {
529 526
                 $tmp[] = $kk.' = '.$vv;
530 527
             }
531
-            $sql .= implode(' AND ', $tmp) . ' ';
528
+            $sql .= implode(' AND ', $tmp).' ';
532 529
         }
533 530
         foreach ($relations as $k => $v) {
534 531
             $table = $v[1] !== $this->definition->getName() ? $getAlias($v[1]) : $v[1];
@@ -540,13 +537,13 @@  discard block
 block discarded – undo
540 537
                 foreach ($v->keymap as $kk => $vv) {
541 538
                     $tmp[] = $table.'.'.$kk.' = '.$alias.'.'.$vv.' ';
542 539
                 }
543
-                $sql .= implode(' AND ', $tmp) . ' ';
540
+                $sql .= implode(' AND ', $tmp).' ';
544 541
                 $sql .= 'LEFT JOIN '.$v->table->getName().' '.$getAlias($k).' ON ';
545 542
                 $tmp = [];
546 543
                 foreach ($v->pivot_keymap as $kk => $vv) {
547 544
                     $tmp[] = $getAlias($k).'.'.$vv.' = '.$alias.'.'.$kk.' ';
548 545
                 }
549
-                $sql .= implode(' AND ', $tmp) . ' ';
546
+                $sql .= implode(' AND ', $tmp).' ';
550 547
             } else {
551 548
                 $alias = $getAlias($k);
552 549
                 $sql .= 'LEFT JOIN '.$v->table->getName().' '.$alias.' ON ';
@@ -555,30 +552,30 @@  discard block
 block discarded – undo
555 552
                     $tmp[] = $table.'.'.$kk.' = '.$alias.'.'.$vv.' ';
556 553
                 }
557 554
                 if ($v->sql) {
558
-                    $tmp[] = $v->sql . ' ';
555
+                    $tmp[] = $v->sql.' ';
559 556
                     $par = array_merge($par, $v->par ?? []);
560 557
                 }
561
-                $sql .= implode(' AND ', $tmp) . ' ';
558
+                $sql .= implode(' AND ', $tmp).' ';
562 559
             }
563 560
         }
564 561
         if (count($w)) {
565 562
             $sql .= 'WHERE ';
566 563
             $tmp = [];
567 564
             foreach ($w as $v) {
568
-                $tmp[] = '(' . $v[0] . ')';
565
+                $tmp[] = '('.$v[0].')';
569 566
                 $par = array_merge($par, $v[1]);
570 567
             }
571 568
             $sql .= implode(' AND ', $tmp).' ';
572 569
         }
573 570
         if (count($g)) {
574
-            $sql .= 'GROUP BY ' . $g[0] . ' ';
571
+            $sql .= 'GROUP BY '.$g[0].' ';
575 572
             $par = array_merge($par, $g[1]);
576 573
         }
577 574
         if (count($h)) {
578 575
             $sql .= 'HAVING ';
579 576
             $tmp = [];
580 577
             foreach ($h as $v) {
581
-                $tmp[] = '(' . $v[0] . ')';
578
+                $tmp[] = '('.$v[0].')';
582 579
                 $par = array_merge($par, $v[1]);
583 580
             }
584 581
             $sql .= implode(' AND ', $tmp).' ';
@@ -612,7 +609,7 @@  discard block
 block discarded – undo
612 609
                     $this->with(implode('.', $temp));
613 610
                     $table = array_reduce(
614 611
                         $temp,
615
-                        function ($carry, $item) use (&$table) {
612
+                        function($carry, $item) use (&$table) {
616 613
                             return $table->getRelation($item)->table;
617 614
                         }
618 615
                     );
@@ -621,7 +618,7 @@  discard block
 block discarded – undo
621 618
                 }
622 619
                 unset($fields[$k]);
623 620
                 foreach ($cols as $col) {
624
-                    $fields[] = $table . '.' . $col;
621
+                    $fields[] = $table.'.'.$col;
625 622
                 }
626 623
             }
627 624
         }
@@ -653,9 +650,9 @@  discard block
 block discarded – undo
653 650
             return $this->qiterator;
654 651
         }
655 652
         $aliases = [];
656
-        $getAlias = function ($name) use (&$aliases) {
653
+        $getAlias = function($name) use (&$aliases) {
657 654
             // to bypass use: return $name;
658
-            return $aliases[$name] = $aliases[$name] ?? 'alias' . static::SEP . count($aliases);
655
+            return $aliases[$name] = $aliases[$name] ?? 'alias'.static::SEP.count($aliases);
659 656
         };
660 657
         $table = $this->definition->getName();
661 658
         if ($fields !== null) {
@@ -671,7 +668,7 @@  discard block
 block discarded – undo
671 668
         $h = $this->having;
672 669
         $o = $this->order;
673 670
         $g = $this->group;
674
-        $j = array_map(function ($v) { return clone $v; }, $this->joins);
671
+        $j = array_map(function($v) { return clone $v; }, $this->joins);
675 672
 
676 673
         $porder = [];
677 674
         foreach ($this->definition->getPrimaryKey() as $field) {
@@ -684,9 +681,9 @@  discard block
 block discarded – undo
684 681
                 if (count($porder) > 1) {
685 682
                     $pkw = [];
686 683
                     foreach ($porder as $name) {
687
-                        $pkw[] = $name . ' = ?';
684
+                        $pkw[] = $name.' = ?';
688 685
                     }
689
-                    $pkw = '(' . implode(' AND ', $pkw) . ')';
686
+                    $pkw = '('.implode(' AND ', $pkw).')';
690 687
                     $pkp = [];
691 688
                     foreach ($ids as $id) {
692 689
                         foreach ($id as $p) {
@@ -698,67 +695,67 @@  discard block
 block discarded – undo
698 695
                         $pkp
699 696
                     ];
700 697
                 } else {
701
-                    $w[] = [ $porder[0] . ' IN ('.implode(',', array_fill(0, count($ids), '?')).')', $ids ];
698
+                    $w[] = [$porder[0].' IN ('.implode(',', array_fill(0, count($ids), '?')).')', $ids];
702 699
                 }
703 700
             } else {
704
-                $w[] = [ '1=0', [] ];
701
+                $w[] = ['1=0', []];
705 702
             }
706 703
         }
707 704
 
708 705
         foreach ($this->definition->getRelations() as $k => $relation) {
709 706
             foreach ($f as $kk => $field) {
710
-                if (strpos($field, $k . '.') === 0) {
711
-                    $relations[$k] = [ $relation, $table ];
712
-                    $f[$kk] = str_replace($k . '.', $getAlias($k) . '.', $field);
707
+                if (strpos($field, $k.'.') === 0) {
708
+                    $relations[$k] = [$relation, $table];
709
+                    $f[$kk] = str_replace($k.'.', $getAlias($k).'.', $field);
713 710
                 }
714 711
             }
715 712
             foreach ($w as $kk => $v) {
716
-                if (preg_match('(\b'.preg_quote($k . '.'). ')i', $v[0])) {
717
-                    $relations[$k] = [ $relation, $table ];
718
-                    $w[$kk][0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $v[0]);
713
+                if (preg_match('(\b'.preg_quote($k.'.').')i', $v[0])) {
714
+                    $relations[$k] = [$relation, $table];
715
+                    $w[$kk][0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $v[0]);
719 716
                 }
720 717
             }
721 718
             foreach ($h as $kk => $v) {
722
-                if (preg_match('(\b'.preg_quote($k . '.'). ')i', $v[0])) {
723
-                    $relations[$k] = [ $relation, $table ];
724
-                    $h[$kk][0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $v[0]);
719
+                if (preg_match('(\b'.preg_quote($k.'.').')i', $v[0])) {
720
+                    $relations[$k] = [$relation, $table];
721
+                    $h[$kk][0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $v[0]);
725 722
                 }
726 723
             }
727
-            if (isset($o[0]) && preg_match('(\b'.preg_quote($k . '.'). ')i', $o[0])) {
728
-                $relations[$k] = [ $relation, $table ];
729
-                $o[0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $o[0]);
724
+            if (isset($o[0]) && preg_match('(\b'.preg_quote($k.'.').')i', $o[0])) {
725
+                $relations[$k] = [$relation, $table];
726
+                $o[0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $o[0]);
730 727
             }
731
-            if (isset($g[0]) && preg_match('(\b'.preg_quote($k . '.'). ')i', $g[0])) {
732
-                $relations[$k] = [ $relation, $table ];
733
-                $g[0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $g[0]);
728
+            if (isset($g[0]) && preg_match('(\b'.preg_quote($k.'.').')i', $g[0])) {
729
+                $relations[$k] = [$relation, $table];
730
+                $g[0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $g[0]);
734 731
             }
735 732
             foreach ($j as $kk => $v) {
736 733
                 foreach ($v->keymap as $kkk => $vv) {
737
-                    if (preg_match('(\b'.preg_quote($k . '.'). ')i', $vv)) {
738
-                        $relations[$k] = [ $relation, $table ];
739
-                        $j[$k]->keymap[$kkk] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $vv);
734
+                    if (preg_match('(\b'.preg_quote($k.'.').')i', $vv)) {
735
+                        $relations[$k] = [$relation, $table];
736
+                        $j[$k]->keymap[$kkk] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $vv);
740 737
                     }
741 738
                 }
742 739
             }
743 740
         }
744 741
         $select = [];
745 742
         foreach ($f as $k => $field) {
746
-            $select[] = $field . (!is_numeric($k) ? ' ' . $k : '');
743
+            $select[] = $field.(!is_numeric($k) ? ' '.$k : '');
747 744
         }
748 745
         foreach ($this->withr as $name => $relation) {
749 746
             foreach ($relation[0]->table->getColumns() as $column) {
750
-                $select[] = $getAlias($name) . '.' . $column . ' ' . $getAlias($name . static::SEP . $column);
747
+                $select[] = $getAlias($name).'.'.$column.' '.$getAlias($name.static::SEP.$column);
751 748
             }
752 749
         }
753 750
         $sql = 'SELECT '.implode(', ', $select).' FROM '.$table.' ';
754 751
         $par = [];
755 752
         foreach ($j as $k => $v) {
756
-            $sql .= ($v->many ? 'LEFT ' : '' ) . 'JOIN '.$v->table->getName().' '.$k.' ON ';
753
+            $sql .= ($v->many ? 'LEFT ' : '').'JOIN '.$v->table->getName().' '.$k.' ON ';
757 754
             $tmp = [];
758 755
             foreach ($v->keymap as $kk => $vv) {
759 756
                 $tmp[] = $kk.' = '.$vv;
760 757
             }
761
-            $sql .= implode(' AND ', $tmp) . ' ';
758
+            $sql .= implode(' AND ', $tmp).' ';
762 759
         }
763 760
         foreach ($relations as $relation => $v) {
764 761
             $table = $v[1] !== $this->definition->getName() ? $getAlias($v[1]) : $v[1];
@@ -770,13 +767,13 @@  discard block
 block discarded – undo
770 767
                 foreach ($v->keymap as $kk => $vv) {
771 768
                     $tmp[] = $table.'.'.$kk.' = '.$alias.'.'.$vv.' ';
772 769
                 }
773
-                $sql .= implode(' AND ', $tmp) . ' ';
770
+                $sql .= implode(' AND ', $tmp).' ';
774 771
                 $sql .= 'LEFT JOIN '.$v->table->getName().' '.$getAlias($relation).' ON ';
775 772
                 $tmp = [];
776 773
                 foreach ($v->pivot_keymap as $kk => $vv) {
777 774
                     $tmp[] = $getAlias($relation).'.'.$vv.' = '.$alias.'.'.$kk.' ';
778 775
                 }
779
-                $sql .= implode(' AND ', $tmp) . ' ';
776
+                $sql .= implode(' AND ', $tmp).' ';
780 777
             } else {
781 778
                 $alias = $getAlias($relation);
782 779
 
@@ -786,62 +783,62 @@  discard block
 block discarded – undo
786 783
                     $tmp[] = $table.'.'.$kk.' = '.$alias.'.'.$vv.' ';
787 784
                 }
788 785
                 if ($v->sql) {
789
-                    $tmp[] = $v->sql . ' ';
786
+                    $tmp[] = $v->sql.' ';
790 787
                     $par = array_merge($par, $v->par ?? []);
791 788
                 }
792
-                $sql .= implode(' AND ', $tmp) . ' ';
789
+                $sql .= implode(' AND ', $tmp).' ';
793 790
             }
794 791
         }
795 792
         if (count($w)) {
796 793
             $sql .= 'WHERE ';
797 794
             $tmp = [];
798 795
             foreach ($w as $v) {
799
-                $tmp[] = '(' . $v[0] . ')';
796
+                $tmp[] = '('.$v[0].')';
800 797
                 $par = array_merge($par, $v[1]);
801 798
             }
802 799
             $sql .= implode(' AND ', $tmp).' ';
803 800
         }
804 801
         if (count($g)) {
805
-            $sql .= 'GROUP BY ' . $g[0] . ' ';
802
+            $sql .= 'GROUP BY '.$g[0].' ';
806 803
             $par = array_merge($par, $g[1]);
807 804
         }
808 805
         if (count($h)) {
809 806
             $sql .= 'HAVING ';
810 807
             $tmp = [];
811 808
             foreach ($h as $v) {
812
-                $tmp[] = '(' . $v[0] . ')';
809
+                $tmp[] = '('.$v[0].')';
813 810
                 $par = array_merge($par, $v[1]);
814 811
             }
815 812
             $sql .= implode(' AND ', $tmp).' ';
816 813
         }
817 814
         if (count($o)) {
818
-            $sql .= 'ORDER BY ' . $o[0] . ' ';
815
+            $sql .= 'ORDER BY '.$o[0].' ';
819 816
             $par = array_merge($par, $o[1]);
820 817
         }
821 818
         if (count($porder)) {
822
-            $sql .= (count($o) ? ', ' : 'ORDER BY ') . implode(', ', $porder) . ' ';
819
+            $sql .= (count($o) ? ', ' : 'ORDER BY ').implode(', ', $porder).' ';
823 820
         }
824 821
         if (($this->li_of[2] === 0 || !count($porder)) && $this->li_of[0]) {
825 822
             if ($this->db->driverName() === 'oracle') {
826
-                if ((int)$this->db->driverOption('version', 0) >= 12) {
827
-                    $sql .= 'OFFSET ' . $this->li_of[1] . ' ROWS FETCH NEXT ' . $this->li_of[0] . ' ROWS ONLY';
823
+                if ((int) $this->db->driverOption('version', 0) >= 12) {
824
+                    $sql .= 'OFFSET '.$this->li_of[1].' ROWS FETCH NEXT '.$this->li_of[0].' ROWS ONLY';
828 825
                 } else {
829
-                    $f = array_map(function ($v) {
826
+                    $f = array_map(function($v) {
830 827
                         $v = explode(' ', trim($v), 2);
831 828
                         if (count($v) === 2) { return $v[1]; }
832 829
                         $v = explode('.', $v[0], 2);
833 830
                         return count($v) === 2 ? $v[1] : $v[0];
834 831
                     }, $select);
835
-                    $sql = "SELECT " . implode(', ', $f) . " 
832
+                    $sql = "SELECT ".implode(', ', $f)." 
836 833
                             FROM (
837 834
                                 SELECT tbl__.*, rownum rnum__ FROM (
838
-                                    " . $sql . "
835
+                                    " . $sql."
839 836
                                 ) tbl__ 
840
-                                WHERE rownum <= " . ($this->li_of[0] + $this->li_of[1]) . "
837
+                                WHERE rownum <= " . ($this->li_of[0] + $this->li_of[1])."
841 838
                             ) WHERE rnum__ > " . $this->li_of[1];
842 839
                 }
843 840
             } else {
844
-                $sql .= 'LIMIT ' . $this->li_of[0] . ' OFFSET ' . $this->li_of[1];
841
+                $sql .= 'LIMIT '.$this->li_of[0].' OFFSET '.$this->li_of[1];
845 842
             }
846 843
         }
847 844
         return $this->qiterator = new TableQueryIterator(
@@ -891,7 +888,7 @@  discard block
 block discarded – undo
891 888
                 $ret[$k] = str_repeat(' ', 255);
892 889
                 $par[] = &$ret[$k];
893 890
             }
894
-            $sql .= ' RETURNING ' . implode(',', $primary) . ' INTO ' . implode(',', array_fill(0, count($primary), '?'));
891
+            $sql .= ' RETURNING '.implode(',', $primary).' INTO '.implode(',', array_fill(0, count($primary), '?'));
895 892
             $this->db->query($sql, $par);
896 893
             return $ret;
897 894
         } else {
@@ -923,7 +920,7 @@  discard block
 block discarded – undo
923 920
         }
924 921
         $sql = 'UPDATE '.$table.' SET ';
925 922
         $par = [];
926
-        $sql .= implode(', ', array_map(function ($v) { return $v . ' = ?'; }, array_keys($update))) . ' ';
923
+        $sql .= implode(', ', array_map(function($v) { return $v.' = ?'; }, array_keys($update))).' ';
927 924
         $par = array_merge($par, array_values($update));
928 925
         if (count($this->where)) {
929 926
             $sql .= 'WHERE ';
@@ -932,7 +929,7 @@  discard block
 block discarded – undo
932 929
                 $tmp[] = $v[0];
933 930
                 $par = array_merge($par, $v[1]);
934 931
             }
935
-            $sql .= implode(' AND ', $tmp) . ' ';
932
+            $sql .= implode(' AND ', $tmp).' ';
936 933
         }
937 934
         if (count($this->order)) {
938 935
             $sql .= $this->order[0];
@@ -956,7 +953,7 @@  discard block
 block discarded – undo
956 953
                 $tmp[] = $v[0];
957 954
                 $par = array_merge($par, $v[1]);
958 955
             }
959
-            $sql .= implode(' AND ', $tmp) . ' ';
956
+            $sql .= implode(' AND ', $tmp).' ';
960 957
         }
961 958
         if (count($this->order)) {
962 959
             $sql .= $this->order[0];
@@ -976,13 +973,13 @@  discard block
 block discarded – undo
976 973
         $table = $this->definition;
977 974
         array_reduce(
978 975
             $parts,
979
-            function ($carry, $item) use (&$table) {
976
+            function($carry, $item) use (&$table) {
980 977
                 $relation = $table->getRelation($item);
981 978
                 if (!$relation) {
982 979
                     throw new DBException('Invalid relation name');
983 980
                 }
984
-                $name = $carry ? $carry . static::SEP . $item : $item;
985
-                $this->withr[$name] = [ $relation, $carry ?? $table->getName() ];
981
+                $name = $carry ? $carry.static::SEP.$item : $item;
982
+                $this->withr[$name] = [$relation, $carry ?? $table->getName()];
986 983
                 $table = $relation->table;
987 984
                 return $name;
988 985
             }
@@ -1020,9 +1017,9 @@  discard block
 block discarded – undo
1020 1017
     public function ids()
1021 1018
     {
1022 1019
         $aliases = [];
1023
-        $getAlias = function ($name) use (&$aliases) {
1020
+        $getAlias = function($name) use (&$aliases) {
1024 1021
             // to bypass use: return $name;
1025
-            return $aliases[$name] = $aliases[$name] ?? 'alias' . static::SEP . count($aliases);
1022
+            return $aliases[$name] = $aliases[$name] ?? 'alias'.static::SEP.count($aliases);
1026 1023
         };
1027 1024
         $table = $this->definition->getName();
1028 1025
         $sql = 'SELECT DISTINCT '.$table.'.'.implode(', '.$table.'.', $this->pkey).' FROM '.$table.' ';
@@ -1037,45 +1034,45 @@  discard block
 block discarded – undo
1037 1034
         $h = $this->having;
1038 1035
         $o = $this->order;
1039 1036
         $g = $this->group;
1040
-        $j = array_map(function ($v) { return clone $v; }, $this->joins);
1037
+        $j = array_map(function($v) { return clone $v; }, $this->joins);
1041 1038
         foreach ($this->definition->getRelations() as $k => $v) {
1042 1039
             foreach ($w as $kk => $vv) {
1043
-                if (preg_match('(\b'.preg_quote($k . '.'). ')i', $vv[0])) {
1044
-                    $relations[$k] = [ $v, $table ];
1045
-                    $w[$kk][0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $vv[0]);
1040
+                if (preg_match('(\b'.preg_quote($k.'.').')i', $vv[0])) {
1041
+                    $relations[$k] = [$v, $table];
1042
+                    $w[$kk][0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $vv[0]);
1046 1043
                 }
1047 1044
             }
1048
-            if (isset($o[0]) && preg_match('(\b'.preg_quote($k . '.'). ')i', $o[0])) {
1049
-                $relations[$k] = [ $v, $table ];
1050
-                $o[0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $o[0]);
1045
+            if (isset($o[0]) && preg_match('(\b'.preg_quote($k.'.').')i', $o[0])) {
1046
+                $relations[$k] = [$v, $table];
1047
+                $o[0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $o[0]);
1051 1048
             }
1052 1049
             foreach ($h as $kk => $vv) {
1053
-                if (preg_match('(\b'.preg_quote($k . '.'). ')i', $vv[0])) {
1054
-                    $relations[$k] = [ $relation, $table ];
1055
-                    $h[$kk][0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $vv[0]);
1050
+                if (preg_match('(\b'.preg_quote($k.'.').')i', $vv[0])) {
1051
+                    $relations[$k] = [$relation, $table];
1052
+                    $h[$kk][0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $vv[0]);
1056 1053
                 }
1057 1054
             }
1058
-            if (isset($g[0]) && preg_match('(\b'.preg_quote($k . '.'). ')i', $g[0])) {
1059
-                $relations[$k] = [ $relation, $table ];
1060
-                $g[0] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $g[0]);
1055
+            if (isset($g[0]) && preg_match('(\b'.preg_quote($k.'.').')i', $g[0])) {
1056
+                $relations[$k] = [$relation, $table];
1057
+                $g[0] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $g[0]);
1061 1058
             }
1062 1059
             foreach ($j as $kk => $v) {
1063 1060
                 foreach ($v->keymap as $kkk => $vv) {
1064
-                    if (preg_match('(\b'.preg_quote($k . '.'). ')i', $vv)) {
1065
-                        $relations[$k] = [ $relation, $table ];
1066
-                        $j[$k]->keymap[$kkk] = preg_replace('(\b'.preg_quote($k . '.'). ')i', $getAlias($k) . '.', $vv);
1061
+                    if (preg_match('(\b'.preg_quote($k.'.').')i', $vv)) {
1062
+                        $relations[$k] = [$relation, $table];
1063
+                        $j[$k]->keymap[$kkk] = preg_replace('(\b'.preg_quote($k.'.').')i', $getAlias($k).'.', $vv);
1067 1064
                     }
1068 1065
                 }
1069 1066
             }
1070 1067
         }
1071 1068
 
1072 1069
         foreach ($j as $k => $v) {
1073
-            $sql .= ($v->many ? 'LEFT ' : '' ) . 'JOIN '.$v->table->getName().' '.$k.' ON ';
1070
+            $sql .= ($v->many ? 'LEFT ' : '').'JOIN '.$v->table->getName().' '.$k.' ON ';
1074 1071
             $tmp = [];
1075 1072
             foreach ($v->keymap as $kk => $vv) {
1076 1073
                 $tmp[] = $kk.' = '.$vv;
1077 1074
             }
1078
-            $sql .= implode(' AND ', $tmp) . ' ';
1075
+            $sql .= implode(' AND ', $tmp).' ';
1079 1076
         }
1080 1077
         foreach ($relations as $k => $v) {
1081 1078
             $table = $v[1] !== $this->definition->getName() ? $getAlias($v[1]) : $v[1];
@@ -1087,13 +1084,13 @@  discard block
 block discarded – undo
1087 1084
                 foreach ($v->keymap as $kk => $vv) {
1088 1085
                     $tmp[] = $table.'.'.$kk.' = '.$alias.'.'.$vv.' ';
1089 1086
                 }
1090
-                $sql .= implode(' AND ', $tmp) . ' ';
1087
+                $sql .= implode(' AND ', $tmp).' ';
1091 1088
                 $sql .= 'LEFT JOIN '.$v->table->getName().' '.$getAlias($k).' ON ';
1092 1089
                 $tmp = [];
1093 1090
                 foreach ($v->pivot_keymap as $kk => $vv) {
1094 1091
                     $tmp[] = $getAlias($k).'.'.$vv.' = '.$alias.'.'.$kk.' ';
1095 1092
                 }
1096
-                $sql .= implode(' AND ', $tmp) . ' ';
1093
+                $sql .= implode(' AND ', $tmp).' ';
1097 1094
             } else {
1098 1095
                 $alias = $getAlias($k);
1099 1096
                 $sql .= 'LEFT JOIN '.$v->table->getName().' '.$alias.' ON ';
@@ -1102,36 +1099,36 @@  discard block
 block discarded – undo
1102 1099
                     $tmp[] = $table.'.'.$kk.' = '.$alias.'.'.$vv.' ';
1103 1100
                 }
1104 1101
                 if ($v->sql) {
1105
-                    $tmp[] = $v->sql . ' ';
1102
+                    $tmp[] = $v->sql.' ';
1106 1103
                     $par = array_merge($par, $v->par ?? []);
1107 1104
                 }
1108
-                $sql .= implode(' AND ', $tmp) . ' ';
1105
+                $sql .= implode(' AND ', $tmp).' ';
1109 1106
             }
1110 1107
         }
1111 1108
         if (count($w)) {
1112 1109
             $sql .= 'WHERE ';
1113 1110
             $tmp = [];
1114 1111
             foreach ($w as $v) {
1115
-                $tmp[] = '(' . $v[0] . ')';
1112
+                $tmp[] = '('.$v[0].')';
1116 1113
                 $par = array_merge($par, $v[1]);
1117 1114
             }
1118 1115
             $sql .= implode(' AND ', $tmp).' ';
1119 1116
         }
1120 1117
         if (count($g)) {
1121
-            $sql .= 'GROUP BY ' . $g[0] . ' ';
1118
+            $sql .= 'GROUP BY '.$g[0].' ';
1122 1119
             $par = array_merge($par, $g[1]);
1123 1120
         }
1124 1121
         if (count($h)) {
1125 1122
             $sql .= 'HAVING ';
1126 1123
             $tmp = [];
1127 1124
             foreach ($h as $v) {
1128
-                $tmp[] = '(' . $v[0] . ')';
1125
+                $tmp[] = '('.$v[0].')';
1129 1126
                 $par = array_merge($par, $v[1]);
1130 1127
             }
1131 1128
             $sql .= implode(' AND ', $tmp).' ';
1132 1129
         }
1133 1130
         if (count($o)) {
1134
-            $sql .= 'ORDER BY ' . $o[0] . ' ';
1131
+            $sql .= 'ORDER BY '.$o[0].' ';
1135 1132
             $par = array_merge($par, $o[1]);
1136 1133
         }
1137 1134
         $porder = [];
@@ -1139,30 +1136,30 @@  discard block
 block discarded – undo
1139 1136
             $porder[] = $this->getColumn($field)['name'];
1140 1137
         }
1141 1138
         if (count($porder)) {
1142
-            $sql .= (count($o) ? ', ' : 'ORDER BY ') . implode(', ', $porder) . ' ';
1139
+            $sql .= (count($o) ? ', ' : 'ORDER BY ').implode(', ', $porder).' ';
1143 1140
         }
1144 1141
 
1145 1142
         if ($this->li_of[0]) {
1146 1143
             if ($this->db->driverName() === 'oracle') {
1147
-                if ((int)$this->db->driverOption('version', 0) >= 12) {
1148
-                    $sql .= 'OFFSET ' . $this->li_of[1] . ' ROWS FETCH NEXT ' . $this->li_of[0] . ' ROWS ONLY';
1144
+                if ((int) $this->db->driverOption('version', 0) >= 12) {
1145
+                    $sql .= 'OFFSET '.$this->li_of[1].' ROWS FETCH NEXT '.$this->li_of[0].' ROWS ONLY';
1149 1146
                 } else {
1150
-                    $f = array_map(function ($v) {
1147
+                    $f = array_map(function($v) {
1151 1148
                         $v = explode(' ', trim($v), 2);
1152 1149
                         if (count($v) === 2) { return $v[1]; }
1153 1150
                         $v = explode('.', $v[0], 2);
1154 1151
                         return count($v) === 2 ? $v[1] : $v[0];
1155 1152
                     }, $select);
1156
-                    $sql = "SELECT " . implode(', ', $f) . " 
1153
+                    $sql = "SELECT ".implode(', ', $f)." 
1157 1154
                             FROM (
1158 1155
                                 SELECT tbl__.*, rownum rnum__ FROM (
1159
-                                    " . $sql . "
1156
+                                    " . $sql."
1160 1157
                                 ) tbl__ 
1161
-                                WHERE rownum <= " . ($this->li_of[0] + $this->li_of[1]) . "
1158
+                                WHERE rownum <= " . ($this->li_of[0] + $this->li_of[1])."
1162 1159
                             ) WHERE rnum__ > " . $this->li_of[1];
1163 1160
                 }
1164 1161
             } else {
1165
-                $sql .= 'LIMIT ' . $this->li_of[0] . ' OFFSET ' . $this->li_of[1];
1162
+                $sql .= 'LIMIT '.$this->li_of[0].' OFFSET '.$this->li_of[1];
1166 1163
             }
1167 1164
         }
1168 1165
         return $this->db->all($sql, $par);
Please login to merge, or discard this patch.