[5.x] Ability to log fake queries

config/system.php

@@ -165,4 +165,17 @@
 
     'row_id_handle' => 'id',
 
+    /*
+    |--------------------------------------------------------------------------
+    | Fake SQL Queries
+    |--------------------------------------------------------------------------
+    |
+    | When enabled, Statamic's query builders will emit events that appear
+    | the same way as any other query. This can be useful for debugging.
+    | The generated SQL statements are approximations and not exact.
+    |
+    */
+
+    'fake_sql_queries' => config('app.debug'),
+
 ];

src/Assets/QueryBuilder.php

@@ -7,6 +7,7 @@
 use Statamic\Contracts\Assets\QueryBuilder as Contract;
 use Statamic\Facades;
 use Statamic\Stache\Query\Builder as BaseQueryBuilder;
+use Statamic\Support\Arr;
 
 class QueryBuilder extends BaseQueryBuilder implements Contract
 {
@@ -119,4 +120,24 @@ protected function getWhereColumnKeyValuesByIndex($column)
 
         return $items;
     }
+
+    public function getTableNameForFakeQuery(): string
+    {
+        return 'assets';
+    }
+
+    public function prepareForFakeQuery(): array
+    {
+        $data = parent::prepareForFakeQuery();
+
+        $data['wheres'] = Arr::prepend($data['wheres'], [
+            'type' => 'Basic',
+            'column' => 'container',
+            'operator' => '=',
+            'value' => $this->getContainer()->handle(),
+            'boolean' => 'and',
+        ]);
+
+        return $data;
+    }
 }

src/Query/Builder.php

@@ -12,9 +12,12 @@
 use Statamic\Contracts\Query\Builder as Contract;
 use Statamic\Extensions\Pagination\LengthAwarePaginator;
 use Statamic\Facades\Pattern;
+use Statamic\Query\Concerns\FakesQueries;
 
 abstract class Builder implements Contract
 {
+    use FakesQueries;
+
     protected $columns;
     protected $limit;
     protected $offset = 0;
@@ -570,6 +573,21 @@ abstract public function count();
 
     abstract public function get($columns = ['*']);
 
+    protected function onceWithColumns($columns, $callback)
+    {
+        $original = $this->columns;
+
+        if (is_null($original)) {
+            $this->columns = $columns;
+        }
+
+        $result = $callback();
+
+        $this->columns = $original;
+
+        return $result;
+    }
+
     abstract public function pluck($column, $key = null);
 
     public function when($value, $callback, $default = null)

src/Query/Concerns/FakesQueries.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Statamic\Query\Concerns;
+
+use Illuminate\Database\Events\QueryExecuted;
+use Statamic\Query\Dumper\Dumper;
+
+trait FakesQueries
+{
+    protected function withFakeQueryLogging(\Closure $callback)
+    {
+        if (! config('statamic.system.fake_sql_queries', false)) {
+            return $callback();
+        }
+
+        $startTime = microtime(true);
+
+        $value = $callback();
+
+        $time = round((microtime(true) - $startTime) * 1000, 2);
+
+        event(new QueryExecuted(
+            ($sql = new Dumper($this))->dump(),
+            $sql->bindings()->all(),
+            $time,
+            $sql->connection()
+        ));
+
+        return $value;
+    }
+
+    public function prepareForFakeQuery(): array
+    {
+        return [
+            'wheres' => $this->wheres,
+            'columns' => $this->columns,
+            'orderBys' => $this->orderBys,
+            'limit' => $this->limit,
+            'offset' => $this->offset,
+        ];
+    }
+}

src/Query/Dumper/Concerns/DumpsQueryParts.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Statamic\Query\Dumper\Concerns;
+
+trait DumpsQueryParts
+{
+    protected function dumpColumns(): string
+    {
+        return implode(', ', $this->columns);
+    }
+
+    protected function dumpLimits(): string
+    {
+        if (! $this->limit) {
+            return '';
+        }
+
+        $limit = ' limit '.$this->limit;
+
+        if ($this->offset) {
+            $limit .= ' offset '.$this->offset;
+        }
+
+        return $limit;
+    }
+
+    protected function dumpOrderBys(): string
+    {
+        if (count($this->orderBys) === 0) {
+            return '';
+        }
+
+        $orders = [];
+
+        foreach ($this->orderBys as $orderBy) {
+            if (! $orderBy->sort) {
+                continue;
+            }
+
+            $orders[] = $orderBy->sort.' '.$orderBy->direction;
+        }
+
+        return ' order by '.implode(', ', $orders);
+    }
+}

src/Query/Dumper/Concerns/DumpsQueryValues.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Statamic\Query\Dumper\Concerns;
+
+trait DumpsQueryValues
+{
+    protected function dumpQueryArrayValues($array): string
+    {
+        if (count($array) === 0) {
+            return '[]';
+        }
+
+        return collect($array)->map(function ($value) {
+            return $this->dumpQueryValue($value);
+        })->implode(', ');
+    }
+
+    protected function dumpQueryValue($value): string
+    {
+        $this->bindings[] = $value;
+
+        return '?';
+    }
+}

src/Query/Dumper/Concerns/DumpsWheres.php

@@ -0,0 +1,160 @@
+<?php
+
+namespace Statamic\Query\Dumper\Concerns;
+
+use Illuminate\Support\Str;
+use Statamic\Query\Dumper\Dumper;
+
+trait DumpsWheres
+{
+    protected function dumpBasic($where): string
+    {
+        return $where['column'].' '.$where['operator'].' '.$this->dumpQueryValue($where['value'] ?? null);
+    }
+
+    protected function dumpArrayWhere($keyword, $where): string
+    {
+        return $where['column'].' '.$keyword.' ('.$this->dumpQueryArrayValues($where['values'] ?? []).')';
+    }
+
+    protected function dumpSimpleOperatorWhere($where): string
+    {
+        return $where['column'].' '.$where['operator'].$this->dumpQueryValue($where['value'] ?? null);
+    }
+
+    protected function dumpIn($where): string
+    {
+        return $this->dumpArrayWhere('in', $where);
+    }
+
+    protected function dumpNotIn($where): string
+    {
+        return $this->dumpArrayWhere('not in', $where);
+    }
+
+    protected function dumpNull($where): string
+    {
+        return $where['column'].' is null';
+    }
+
+    protected function dumpNotNull($where): string
+    {
+        return $where['column'].' is not null';
+    }
+
+    protected function dumpDatePartMethod($datePart, $where): string
+    {
+        return 'DATEPART('.$datePart.', '.$where['column'].') = '.$this->dumpQueryValue($where['value'] ?? null);
+    }
+
+    protected function dumpMonth($where): string
+    {
+        return $this->dumpDatePartMethod('MONTH', $where);
+    }
+
+    protected function dumpDay($where): string
+    {
+        return $this->dumpDatePartMethod('DAY', $where);
+    }
+
+    protected function dumpYear($where): string
+    {
+        return $this->dumpDatePartMethod('YEAR', $where);
+    }
+
+    protected function dumpTime($where): string
+    {
+        return $this->dumpDatePartMethod('TIMESTAMP', $where);
+    }
+
+    protected function dumpBetween($where): string
+    {
+        $valueOne = $this->dumpQueryValue($where['values'][0] ?? null);
+        $valueTwo = $this->dumpQueryValue($where['values'][1] ?? null);
+        $column = $where['column'];
+
+        return $column.' between '.$valueOne.' and '.$valueTwo;
+    }
+
+    protected function dumpNotBetween($where): string
+    {
+        $valueOne = $this->dumpQueryValue($where['values'][0] ?? null);
+        $valueTwo = $this->dumpQueryValue($where['values'][1] ?? null);
+        $column = $where['column'];
+
+        return $column.' not between '.$valueOne.' and '.$valueTwo;
+    }
+
+    protected function dumpColumn($where): string
+    {
+        return $where['column'].' = '.$where['value'];
+    }
+
+    protected function dumpNested($where): string
+    {
+        $query = $where['query'] ?? null;
+
+        $sql = (new Dumper($query))->withBindings($this->bindings)->dumpWheres();
+
+        return "($sql)";
+    }
+
+    protected function dumpDate($where)
+    {
+        return $this->dumpSimpleOperatorWhere($where);
+    }
+
+    protected function dumpJsonMethod($where): string
+    {
+        $jsonMethod = strtoupper(Str::snake($where['type']));
+
+        if (isset($where['values'])) {
+            $valueString = $this->dumpQueryArrayValues($where['values']);
+        } else {
+            $valueString = $this->dumpQueryValue($where['value'] ?? null);
+        }
+
+        return $jsonMethod.'('.$where['column'].', '.$valueString.')';
+    }
+
+    protected function dumpWhere($isFirst, $where): string
+    {
+        $dumpedWhere = '';
+
+        if (! $isFirst) {
+            $dumpedWhere = $where['boolean'].' ';
+        }
+
+        $type = $where['type'];
+
+        if (Str::startsWith($type, 'Json')) {
+            $dumpedWhere .= $this->dumpJsonMethod($where);
+        } else {
+            $whereMethod = 'dump'.ucfirst($type);
+
+            if (method_exists($this, $whereMethod)) {
+                $dumpedWhere .= $this->{$whereMethod}($where);
+            } else {
+                // Fail-safe to dump "something".
+                $dumpedWhere .= strtoupper($type);
+            }
+        }
+
+        return $dumpedWhere;
+    }
+
+    protected function dumpWheres(): string
+    {
+        if (count($this->wheres) === 0) {
+            return '';
+        }
+
+        $parts = [];
+
+        for ($i = 0; $i < count($this->wheres); $i++) {
+            $parts[] = $this->dumpWhere($i === 0, $this->wheres[$i]);
+        }
+
+        return implode(' ', $parts);
+    }
+}