bdf-prime/src/Query/Expression/Aggregate.php at 2.1 · b2pweb/bdf-prime · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
<?php

namespace Bdf\Prime\Query\Expression;

use Bdf\Prime\Query\CompilableClause;
use Bdf\Prime\Query\Compiler\CompilerInterface;
use Bdf\Prime\Query\Compiler\QuoteCompilerInterface;
use Doctrine\DBAL\Platforms\AbstractPlatform;

/**
 * Aggregation expressions
 * Can be use on Query::select() method
 *
 * Usage:
 * <code>
 * User::select([
 *     'firstId' => Aggregate::min(id),
 *     'lastId' => Aggregate::max(id),
 *     'count' => Aggregate::count(id),
 * ]);
 * </code>
 *
 * @implements ExpressionInterface<CompilableClause&\Bdf\Prime\Query\Contract\Compilable, CompilerInterface&QuoteCompilerInterface>
 */
abstract class Aggregate implements ExpressionInterface
{
    /**
     * @var string
     */
    private $attribute;

    /**
     * Max constructor.
     *
     * @param string $attribute The attribute name
     */
    public function __construct(string $attribute)
    {
        $this->attribute = $attribute;
    }

    /**
     * {@inheritdoc}
     *
     * @param CompilerInterface&QuoteCompilerInterface $compiler
     */
    final public function build(CompilableClause $query, object $compiler)
    {
        $attribute = $this->attribute;

        if ($attribute !== '*') {
            $attribute = $compiler->quoteIdentifier($query, $query->preprocessor()->field($attribute));
        }

        return $this->expression($compiler->platform()->grammar(), $attribute);
    }

    /**
     * Get the aggregate expression
     *
     * @param AbstractPlatform $platform The database platform
     * @param string $attribute The attribute to aggregate
     *
     * @return string
     */
    abstract protected function expression(AbstractPlatform $platform, string $attribute): string;

    /**
     * Perform MIN() aggregation function
     *
     * @param string $attribute The attribute to aggregate
     *
     * @return self
     */
    public static function min(string $attribute): self
    {
        return new class ($attribute) extends Aggregate {
            protected function expression(AbstractPlatform $platform, string $attribute): string
            {
                return $platform->getMinExpression($attribute);
            }
        };
    }

    /**
     * Perform MAX() aggregation function
     *
     * @param string $attribute The attribute to aggregate
     *
     * @return self
     */
    public static function max(string $attribute): self
    {
        return new class ($attribute) extends Aggregate {
            protected function expression(AbstractPlatform $platform, string $attribute): string
            {
                return $platform->getMaxExpression($attribute);
            }
        };
    }

    /**
     * Perform AVG() aggregation function
     *
     * @param string $attribute The attribute to aggregate
     *
     * @return self
     */
    public static function avg(string $attribute): self
    {
        return new class ($attribute) extends Aggregate {
            protected function expression(AbstractPlatform $platform, string $attribute): string
            {
                return $platform->getAvgExpression($attribute);
            }
        };
    }

    /**
     * Perform COUNT() aggregation function
     *
     * @param string $attribute The attribute to aggregate
     *
     * @return self
     */
    public static function count(string $attribute = '*'): self
    {
        return new class ($attribute) extends Aggregate {
            protected function expression(AbstractPlatform $platform, string $attribute): string
            {
                return $platform->getCountExpression($attribute);
            }
        };
    }

    /**
     * Perform SUM() aggregation function
     *
     * @param string $attribute The attribute to aggregate
     *
     * @return self
     */
    public static function sum(string $attribute): self
    {
        return new class ($attribute) extends Aggregate {
            protected function expression(AbstractPlatform $platform, string $attribute): string
            {
                return $platform->getSumExpression($attribute);
            }
        };
    }
}