14062713921

Committed 25 Mar 2025 02:49PM UTC coverage: 62.13% (+0.2%) from 61.936%

Build # 14062713921

Build Type

push

github

Committed by

BenMorel

Commit Message

Implement PgsqlDriver (pgsql extension)

Run Details

0 of 52 new or added lines in 1 file covered. (0.0%)

59 existing lines in 8 files now uncovered.

1890 of 3042 relevant lines covered (62.13%)

1687.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/Engine/Database/Internal/AbstractDatabaseEngine.php

<?php

declare(strict_types=1);

namespace Brick\Geo\Engine\Database\Internal;

use Brick\Geo\Curve;
use Brick\Geo\Engine\GeometryEngine;
use Brick\Geo\Engine\Internal\TypeChecker;
use Brick\Geo\Exception\GeometryEngineException;
use Brick\Geo\Geometry;
use Brick\Geo\LineString;
use Brick\Geo\MultiCurve;
use Brick\Geo\MultiPoint;
use Brick\Geo\MultiSurface;
use Brick\Geo\Point;
use Brick\Geo\Surface;
use Override;

/**
 * Base class for database engines.
 *
 * This class provides standard implementations for most GIS functions, by requiring only 3 abstract methods to be
 * implemented by the concrete database engine.
 *
 * Some methods may be overridden in the concrete database engine when non-standard implementations are required.
 *
 * @internal
 */
abstract readonly class AbstractDatabaseEngine implements GeometryEngine
{
    /**
     * Queries a GIS function returning a boolean value.
     *
     * @param string          $function      The SQL GIS function to execute.
     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
     *
     * @throws GeometryEngineException
     */
    abstract protected function queryBool(string $function, Geometry|string|float|int|bool ...$parameters) : bool;

    /**
     * Queries a GIS function returning a floating point value.
     *
     * @param string          $function      The SQL GIS function to execute.
     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
     *
     * @throws GeometryEngineException
     */
    abstract protected function queryFloat(string $function, Geometry|string|float|int|bool ...$parameters) : float;

    /**
     * Queries a GIS function returning a Geometry object.
     *
     * @param string             $function   The SQL GIS function to execute.
     * @param Geometry|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
     *
     * @throws GeometryEngineException
     */
    abstract protected function queryGeometry(string $function, Geometry|string|float|int|bool ...$parameters) : Geometry;

    #[Override]
    public function contains(Geometry $a, Geometry $b) : bool
    {
        return $this->queryBool('ST_Contains', $a, $b);
    }

    #[Override]
    public function intersects(Geometry $a, Geometry $b) : bool
    {
        return $this->queryBool('ST_Intersects', $a, $b);
    }

    #[Override]
    public function union(Geometry $a, Geometry $b) : Geometry
    {
        return $this->queryGeometry('ST_Union', $a, $b);
    }

    #[Override]
    public function intersection(Geometry $a, Geometry $b) : Geometry
    {
        return $this->queryGeometry('ST_Intersection', $a, $b);
    }

    #[Override]
    public function difference(Geometry $a, Geometry $b) : Geometry
    {
        return $this->queryGeometry('ST_Difference', $a, $b);
    }

    #[Override]
    public function envelope(Geometry $g) : Geometry
    {
        return $this->queryGeometry('ST_Envelope', $g);
    }

    #[Override]
    public function centroid(Geometry $g) : Point
    {
        $centroid = $this->queryGeometry('ST_Centroid', $g);
        TypeChecker::check($centroid, Point::class);

        return $centroid;
    }

    #[Override]
    public function pointOnSurface(Surface|MultiSurface $g) : Point
    {
        $pointOnSurface = $this->queryGeometry('ST_PointOnSurface', $g);
        TypeChecker::check($pointOnSurface, Point::class);

        return $pointOnSurface;
    }

    #[Override]
    public function length(Curve|MultiCurve $g) : float
    {
        return $this->queryFloat('ST_Length', $g);
    }

    #[Override]
    public function area(Surface|MultiSurface $g) : float
    {
        return $this->queryFloat('ST_Area', $g);
    }

    #[Override]
    public function azimuth(Point $observer, Point $subject) : float
    {
        return $this->queryFloat('ST_Azimuth', $observer, $subject);
    }

    #[Override]
    public function boundary(Geometry $g) : Geometry
    {
        return $this->queryGeometry('ST_Boundary', $g);
    }

    #[Override]
    public function isValid(Geometry $g) : bool
    {
        return $this->queryBool('ST_IsValid', $g);
    }

    #[Override]
    public function isClosed(Geometry $g) : bool
    {
        return $this->queryBool('ST_IsClosed', $g);
    }

    #[Override]
    public function isSimple(Geometry $g) : bool
    {
        return $this->queryBool('ST_IsSimple', $g);
    }

    #[Override]
    public function isRing(Curve $curve) : bool
    {
        return $this->queryBool('ST_IsRing', $curve);
    }

    #[Override]
    public function makeValid(Geometry $g) : Geometry
    {
        return $this->queryGeometry('ST_MakeValid', $g);
    }

    #[Override]
    public function equals(Geometry $a, Geometry $b) : bool
    {
        return $this->queryBool('ST_Equals', $a, $b);
    }

    #[Override]
    public function disjoint(Geometry $a, Geometry $b) : bool
    {
        return $this->queryBool('ST_Disjoint', $a, $b);
    }

    #[Override]
    public function touches(Geometry $a, Geometry $b) : bool
    {
        return $this->queryBool('ST_Touches', $a, $b);
    }

    #[Override]
    public function crosses(Geometry $a, Geometry $b) : bool
    {
        return $this->queryBool('ST_Crosses', $a, $b);
    }

    #[Override]
    public function within(Geometry $a, Geometry $b) : bool
    {
        return $this->queryBool('ST_Within', $a, $b);
    }

    #[Override]
    public function overlaps(Geometry $a, Geometry $b) : bool
    {
        return $this->queryBool('ST_Overlaps', $a, $b);
    }

    #[Override]
    public function relate(Geometry $a, Geometry $b, string $matrix) : bool
    {
        return $this->queryBool('ST_Relate', $a, $b, $matrix);
    }

    #[Override]
    public function locateAlong(Geometry $g, float $mValue) : Geometry
    {
        return $this->queryGeometry('ST_LocateAlong', $g, $mValue);
    }

    #[Override]
    public function locateBetween(Geometry $g, float $mStart, float $mEnd) : Geometry
    {
        return $this->queryGeometry('ST_LocateBetween', $g, $mStart, $mEnd);
    }

    #[Override]
    public function distance(Geometry $a, Geometry $b) : float
    {
        return $this->queryFloat('ST_Distance', $a, $b);
    }

    #[Override]
    public function buffer(Geometry $g, float $distance) : Geometry
    {
        return $this->queryGeometry('ST_Buffer', $g, $distance);
    }

    #[Override]
    public function convexHull(Geometry $g) : Geometry
    {
        return $this->queryGeometry('ST_ConvexHull', $g);
    }

    #[Override]
    public function concaveHull(Geometry $g, float $convexity, bool $allowHoles) : Geometry
    {
        return $this->queryGeometry('ST_ConcaveHull', $g, $convexity, $allowHoles);
    }

    #[Override]
    public function symDifference(Geometry $a, Geometry $b) : Geometry
    {
        return $this->queryGeometry('ST_SymDifference', $a, $b);
    }

    #[Override]
    public function snapToGrid(Geometry $g, float $size) : Geometry
    {
        return $this->queryGeometry('ST_SnapToGrid', $g, $size);
    }

    #[Override]
    public function simplify(Geometry $g, float $tolerance) : Geometry
    {
        return $this->queryGeometry('ST_Simplify', $g, $tolerance);
    }

    #[Override]
    public function maxDistance(Geometry $a, Geometry $b) : float
    {
        return $this->queryFloat('ST_MaxDistance', $a, $b);
    }

    #[Override]
    public function transform(Geometry $g, int $srid) : Geometry
    {
        return $this->queryGeometry('ST_Transform', $g, $srid);
    }

    #[Override]
    public function split(Geometry $g, Geometry $blade) : Geometry
    {
        return $this->queryGeometry('ST_Split', $g, $blade);
    }

    #[Override]
    public function lineInterpolatePoint(LineString $lineString, float $fraction) : Point
    {
        $result = $this->queryGeometry('ST_LineInterpolatePoint', $lineString, $fraction);
        TypeChecker::check($result, Point::class);

        return $result;
    }

    #[Override]
    public function lineInterpolatePoints(LineString $lineString, float $fraction) : MultiPoint
    {
        $result = $this->queryGeometry('ST_LineInterpolatePoints', $lineString, $fraction);

        if ($result instanceof MultiPoint) {
            return $result;
        }

        TypeChecker::check($result, Point::class);

        // POINT EMPTY
        if ($result->isEmpty()) {
            return new MultiPoint($result->coordinateSystem());
        }

        // POINT
        return MultiPoint::of($result);
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Brick\Geo\Engine\Database\Internal;
6
7	use Brick\Geo\Curve;
8	use Brick\Geo\Engine\GeometryEngine;
9	use Brick\Geo\Engine\Internal\TypeChecker;
10	use Brick\Geo\Exception\GeometryEngineException;
11	use Brick\Geo\Geometry;
12	use Brick\Geo\LineString;
13	use Brick\Geo\MultiCurve;
14	use Brick\Geo\MultiPoint;
15	use Brick\Geo\MultiSurface;
16	use Brick\Geo\Point;
17	use Brick\Geo\Surface;
18	use Override;
19
20	/**
21	* Base class for database engines.
22	*
23	* This class provides standard implementations for most GIS functions, by requiring only 3 abstract methods to be
24	* implemented by the concrete database engine.
25	*
26	* Some methods may be overridden in the concrete database engine when non-standard implementations are required.
27	*
28	* @internal
29	*/
30	abstract readonly class AbstractDatabaseEngine implements GeometryEngine
31	{
32	/**
33	* Queries a GIS function returning a boolean value.
34	*
35	* @param string $function The SQL GIS function to execute.
36	* @param Geometry\|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
37	*
38	* @throws GeometryEngineException
39	*/
40	abstract protected function queryBool(string $function, Geometry\|string\|float\|int\|bool ...$parameters) : bool;
41
42	/**
43	* Queries a GIS function returning a floating point value.
44	*
45	* @param string $function The SQL GIS function to execute.
46	* @param Geometry\|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
47	*
48	* @throws GeometryEngineException
49	*/
50	abstract protected function queryFloat(string $function, Geometry\|string\|float\|int\|bool ...$parameters) : float;
51
52	/**
53	* Queries a GIS function returning a Geometry object.
54	*
55	* @param string $function The SQL GIS function to execute.
56	* @param Geometry\|scalar ...$parameters The Geometry objects or scalar values to pass as parameters.
57	*
58	* @throws GeometryEngineException
59	*/
60	abstract protected function queryGeometry(string $function, Geometry\|string\|float\|int\|bool ...$parameters) : Geometry;
61
62	#[Override]
63	public function contains(Geometry $a, Geometry $b) : bool
64	{
65	return $this->queryBool('ST_Contains', $a, $b);	76✔
66	}
67
68	#[Override]
69	public function intersects(Geometry $a, Geometry $b) : bool
70	{
71	return $this->queryBool('ST_Intersects', $a, $b);	36✔
72	}
73
74	#[Override]
75	public function union(Geometry $a, Geometry $b) : Geometry
76	{
77	return $this->queryGeometry('ST_Union', $a, $b);	22✔
78	}
79
80	#[Override]
81	public function intersection(Geometry $a, Geometry $b) : Geometry
82	{
83	return $this->queryGeometry('ST_Intersection', $a, $b);	12✔
84	}
85
86	#[Override]
87	public function difference(Geometry $a, Geometry $b) : Geometry
88	{
89	return $this->queryGeometry('ST_Difference', $a, $b);	12✔
90	}
91
92	#[Override]
93	public function envelope(Geometry $g) : Geometry
94	{
95	return $this->queryGeometry('ST_Envelope', $g);	18✔
96	}
97
98	#[Override]
99	public function centroid(Geometry $g) : Point
100	{
101	$centroid = $this->queryGeometry('ST_Centroid', $g);	45✔
102	TypeChecker::check($centroid, Point::class);	45✔
103
104	return $centroid;	45✔
105	}
106
107	#[Override]
108	public function pointOnSurface(Surface\|MultiSurface $g) : Point
109	{
110	$pointOnSurface = $this->queryGeometry('ST_PointOnSurface', $g);	42✔
111	TypeChecker::check($pointOnSurface, Point::class);	28✔
112
113	return $pointOnSurface;	28✔
114	}
115
116	#[Override]
117	public function length(Curve\|MultiCurve $g) : float
118	{
119	return $this->queryFloat('ST_Length', $g);	95✔
120	}
121
122	#[Override]
123	public function area(Surface\|MultiSurface $g) : float
124	{
125	return $this->queryFloat('ST_Area', $g);	66✔
126	}
127
128	#[Override]
129	public function azimuth(Point $observer, Point $subject) : float
130	{
131	return $this->queryFloat('ST_Azimuth', $observer, $subject);	36✔
132	}
133
134	#[Override]
135	public function boundary(Geometry $g) : Geometry
136	{
137	return $this->queryGeometry('ST_Boundary', $g);	36✔
138	}
139
140	#[Override]
141	public function isValid(Geometry $g) : bool
142	{
143	return $this->queryBool('ST_IsValid', $g);	46✔
144	}
145
146	#[Override]
147	public function isClosed(Geometry $g) : bool
148	{
149	return $this->queryBool('ST_IsClosed', $g);	276✔
150	}
151
152	#[Override]
153	public function isSimple(Geometry $g) : bool
154	{
155	return $this->queryBool('ST_IsSimple', $g);	102✔
156	}
157
158	#[Override]
159	public function isRing(Curve $curve) : bool
160	{
161	return $this->queryBool('ST_IsRing', $curve);	48✔
162	}
163
164	#[Override]
165	public function makeValid(Geometry $g) : Geometry
166	{
167	return $this->queryGeometry('ST_MakeValid', $g);	36✔
168	}
169
170	#[Override]
171	public function equals(Geometry $a, Geometry $b) : bool
172	{
173	return $this->queryBool('ST_Equals', $a, $b);	192✔
174	}
175
176	#[Override]
177	public function disjoint(Geometry $a, Geometry $b) : bool
178	{
179	return $this->queryBool('ST_Disjoint', $a, $b);	36✔
180	}
181
182	#[Override]
183	public function touches(Geometry $a, Geometry $b) : bool
184	{
185	return $this->queryBool('ST_Touches', $a, $b);	48✔
186	}
187
188	#[Override]
189	public function crosses(Geometry $a, Geometry $b) : bool
190	{
191	return $this->queryBool('ST_Crosses', $a, $b);	48✔
192	}
193
194	#[Override]
195	public function within(Geometry $a, Geometry $b) : bool
196	{
197	return $this->queryBool('ST_Within', $a, $b);	30✔
198	}
199
200	#[Override]
201	public function overlaps(Geometry $a, Geometry $b) : bool
202	{
203	return $this->queryBool('ST_Overlaps', $a, $b);	12✔
204	}
205
206	#[Override]
207	public function relate(Geometry $a, Geometry $b, string $matrix) : bool
208	{
209	return $this->queryBool('ST_Relate', $a, $b, $matrix);	24✔
210	}
211
212	#[Override]
213	public function locateAlong(Geometry $g, float $mValue) : Geometry
214	{
215	return $this->queryGeometry('ST_LocateAlong', $g, $mValue);	12✔
216	}
217
218	#[Override]
219	public function locateBetween(Geometry $g, float $mStart, float $mEnd) : Geometry
220	{
221	return $this->queryGeometry('ST_LocateBetween', $g, $mStart, $mEnd);	12✔
222	}
223
224	#[Override]
225	public function distance(Geometry $a, Geometry $b) : float
226	{
227	return $this->queryFloat('ST_Distance', $a, $b);	30✔
228	}
229
230	#[Override]
231	public function buffer(Geometry $g, float $distance) : Geometry
232	{
233	return $this->queryGeometry('ST_Buffer', $g, $distance);	18✔
234	}
235
236	#[Override]
237	public function convexHull(Geometry $g) : Geometry
238	{
239	return $this->queryGeometry('ST_ConvexHull', $g);	18✔
240	}
241
242	#[Override]
243	public function concaveHull(Geometry $g, float $convexity, bool $allowHoles) : Geometry
244	{
245	return $this->queryGeometry('ST_ConcaveHull', $g, $convexity, $allowHoles);	30✔
246	}
247
248	#[Override]
249	public function symDifference(Geometry $a, Geometry $b) : Geometry
250	{
251	return $this->queryGeometry('ST_SymDifference', $a, $b);	6✔
252	}
253
254	#[Override]
255	public function snapToGrid(Geometry $g, float $size) : Geometry
256	{
257	return $this->queryGeometry('ST_SnapToGrid', $g, $size);	24✔
258	}
259
260	#[Override]
261	public function simplify(Geometry $g, float $tolerance) : Geometry
262	{
263	return $this->queryGeometry('ST_Simplify', $g, $tolerance);	12✔
264	}
265
266	#[Override]
267	public function maxDistance(Geometry $a, Geometry $b) : float
268	{
269	return $this->queryFloat('ST_MaxDistance', $a, $b);	18✔
270	}
271
272	#[Override]
273	public function transform(Geometry $g, int $srid) : Geometry
274	{
275	return $this->queryGeometry('ST_Transform', $g, $srid);	42✔
276	}
277
278	#[Override]
279	public function split(Geometry $g, Geometry $blade) : Geometry
280	{
281	return $this->queryGeometry('ST_Split', $g, $blade);	24✔
282	}
283
284	#[Override]
285	public function lineInterpolatePoint(LineString $lineString, float $fraction) : Point
286	{
287	$result = $this->queryGeometry('ST_LineInterpolatePoint', $lineString, $fraction);	105✔
UNCOV 288	TypeChecker::check($result, Point::class);	63✔
289
UNCOV 290	return $result;	63✔
291	}
292
293	#[Override]
294	public function lineInterpolatePoints(LineString $lineString, float $fraction) : MultiPoint
295	{
296	$result = $this->queryGeometry('ST_LineInterpolatePoints', $lineString, $fraction);	179✔
297
UNCOV 298	if ($result instanceof MultiPoint) {	88✔
UNCOV 299	return $result;	70✔
300	}
301
302	TypeChecker::check($result, Point::class);	18✔
303
304	// POINT EMPTY
305	if ($result->isEmpty()) {	18✔
306	return new MultiPoint($result->coordinateSystem());	1✔
307	}
308
309	// POINT
310	return MultiPoint::of($result);	17✔
311	}
312	}

brick / geo / 14062713921

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous