pgLatLon
view latlon--0.7.sql @ 34:d2e34c0150af
Added update script to version 0.7 and make version 0.7 default
| author | jbe |
|---|---|
| date | Mon Sep 26 09:56:29 2016 +0200 (2016-09-26) |
| parents | 868220477afb |
| children |
line source
2 ----------------------------------------
3 -- forward declarations (shell types) --
4 ----------------------------------------
6 CREATE TYPE epoint;
7 CREATE TYPE ebox;
8 CREATE TYPE ecircle;
9 CREATE TYPE ecluster;
12 ------------------------------------------------------------
13 -- dummy input/output functions for dummy index key types --
14 ------------------------------------------------------------
16 CREATE FUNCTION ekey_point_in_dummy(cstring)
17 RETURNS ekey_point
18 LANGUAGE C IMMUTABLE STRICT
19 AS '$libdir/latlon-v0007', 'pgl_notimpl';
21 CREATE FUNCTION ekey_point_out_dummy(ekey_point)
22 RETURNS cstring
23 LANGUAGE C IMMUTABLE STRICT
24 AS '$libdir/latlon-v0007', 'pgl_notimpl';
26 CREATE FUNCTION ekey_area_in_dummy(cstring)
27 RETURNS ekey_area
28 LANGUAGE C IMMUTABLE STRICT
29 AS '$libdir/latlon-v0007', 'pgl_notimpl';
31 CREATE FUNCTION ekey_area_out_dummy(ekey_area)
32 RETURNS cstring
33 LANGUAGE C IMMUTABLE STRICT
34 AS '$libdir/latlon-v0007', 'pgl_notimpl';
37 --------------------------
38 -- text input functions --
39 --------------------------
41 CREATE FUNCTION epoint_in(cstring)
42 RETURNS epoint
43 LANGUAGE C IMMUTABLE STRICT
44 AS '$libdir/latlon-v0007', 'pgl_epoint_in';
46 CREATE FUNCTION ebox_in(cstring)
47 RETURNS ebox
48 LANGUAGE C IMMUTABLE STRICT
49 AS '$libdir/latlon-v0007', 'pgl_ebox_in';
51 CREATE FUNCTION ecircle_in(cstring)
52 RETURNS ecircle
53 LANGUAGE C IMMUTABLE STRICT
54 AS '$libdir/latlon-v0007', 'pgl_ecircle_in';
56 CREATE FUNCTION ecluster_in(cstring)
57 RETURNS ecluster
58 LANGUAGE C IMMUTABLE STRICT
59 AS '$libdir/latlon-v0007', 'pgl_ecluster_in';
62 ---------------------------
63 -- text output functions --
64 ---------------------------
66 CREATE FUNCTION epoint_out(epoint)
67 RETURNS cstring
68 LANGUAGE C IMMUTABLE STRICT
69 AS '$libdir/latlon-v0007', 'pgl_epoint_out';
71 CREATE FUNCTION ebox_out(ebox)
72 RETURNS cstring
73 LANGUAGE C IMMUTABLE STRICT
74 AS '$libdir/latlon-v0007', 'pgl_ebox_out';
76 CREATE FUNCTION ecircle_out(ecircle)
77 RETURNS cstring
78 LANGUAGE C IMMUTABLE STRICT
79 AS '$libdir/latlon-v0007', 'pgl_ecircle_out';
81 CREATE FUNCTION ecluster_out(ecluster)
82 RETURNS cstring
83 LANGUAGE C IMMUTABLE STRICT
84 AS '$libdir/latlon-v0007', 'pgl_ecluster_out';
87 --------------------------
88 -- binary I/O functions --
89 --------------------------
91 CREATE FUNCTION epoint_recv(internal)
92 RETURNS epoint
93 LANGUAGE C IMMUTABLE STRICT
94 AS '$libdir/latlon-v0007', 'pgl_epoint_recv';
96 CREATE FUNCTION ebox_recv(internal)
97 RETURNS ebox
98 LANGUAGE C IMMUTABLE STRICT
99 AS '$libdir/latlon-v0007', 'pgl_ebox_recv';
101 CREATE FUNCTION ecircle_recv(internal)
102 RETURNS ecircle
103 LANGUAGE C IMMUTABLE STRICT
104 AS '$libdir/latlon-v0007', 'pgl_ecircle_recv';
106 CREATE FUNCTION epoint_send(epoint)
107 RETURNS bytea
108 LANGUAGE C IMMUTABLE STRICT
109 AS '$libdir/latlon-v0007', 'pgl_epoint_send';
111 CREATE FUNCTION ebox_send(ebox)
112 RETURNS bytea
113 LANGUAGE C IMMUTABLE STRICT
114 AS '$libdir/latlon-v0007', 'pgl_ebox_send';
116 CREATE FUNCTION ecircle_send(ecircle)
117 RETURNS bytea
118 LANGUAGE C IMMUTABLE STRICT
119 AS '$libdir/latlon-v0007', 'pgl_ecircle_send';
122 -----------------------------------------------
123 -- type definitions of dummy index key types --
124 -----------------------------------------------
126 CREATE TYPE ekey_point (
127 internallength = 8,
128 input = ekey_point_in_dummy,
129 output = ekey_point_out_dummy,
130 alignment = char );
132 CREATE TYPE ekey_area (
133 internallength = 9,
134 input = ekey_area_in_dummy,
135 output = ekey_area_out_dummy,
136 alignment = char );
139 ------------------------------------------
140 -- definitions of geographic data types --
141 ------------------------------------------
143 CREATE TYPE epoint (
144 internallength = 16,
145 input = epoint_in,
146 output = epoint_out,
147 receive = epoint_recv,
148 send = epoint_send,
149 alignment = double );
151 CREATE TYPE ebox (
152 internallength = 32,
153 input = ebox_in,
154 output = ebox_out,
155 receive = ebox_recv,
156 send = ebox_send,
157 alignment = double );
159 CREATE TYPE ecircle (
160 internallength = 24,
161 input = ecircle_in,
162 output = ecircle_out,
163 receive = ecircle_recv,
164 send = ecircle_send,
165 alignment = double );
167 CREATE TYPE ecluster (
168 internallength = VARIABLE,
169 input = ecluster_in,
170 output = ecluster_out,
171 alignment = double,
172 storage = external );
175 --------------------
176 -- B-tree support --
177 --------------------
179 -- begin of B-tree support for epoint
181 CREATE FUNCTION epoint_btree_lt(epoint, epoint)
182 RETURNS boolean
183 LANGUAGE C IMMUTABLE STRICT
184 AS '$libdir/latlon-v0007', 'pgl_btree_epoint_lt';
186 CREATE FUNCTION epoint_btree_le(epoint, epoint)
187 RETURNS boolean
188 LANGUAGE C IMMUTABLE STRICT
189 AS '$libdir/latlon-v0007', 'pgl_btree_epoint_le';
191 CREATE FUNCTION epoint_btree_eq(epoint, epoint)
192 RETURNS boolean
193 LANGUAGE C IMMUTABLE STRICT
194 AS '$libdir/latlon-v0007', 'pgl_btree_epoint_eq';
196 CREATE FUNCTION epoint_btree_ne(epoint, epoint)
197 RETURNS boolean
198 LANGUAGE C IMMUTABLE STRICT
199 AS '$libdir/latlon-v0007', 'pgl_btree_epoint_ne';
201 CREATE FUNCTION epoint_btree_ge(epoint, epoint)
202 RETURNS boolean
203 LANGUAGE C IMMUTABLE STRICT
204 AS '$libdir/latlon-v0007', 'pgl_btree_epoint_ge';
206 CREATE FUNCTION epoint_btree_gt(epoint, epoint)
207 RETURNS boolean
208 LANGUAGE C IMMUTABLE STRICT
209 AS '$libdir/latlon-v0007', 'pgl_btree_epoint_gt';
211 CREATE OPERATOR <<< (
212 leftarg = epoint,
213 rightarg = epoint,
214 procedure = epoint_btree_lt,
215 commutator = >>>,
216 negator = >>>=,
217 restrict = scalarltsel,
218 join = scalarltjoinsel
219 );
221 CREATE OPERATOR <<<= (
222 leftarg = epoint,
223 rightarg = epoint,
224 procedure = epoint_btree_le,
225 commutator = >>>=,
226 negator = >>>,
227 restrict = scalarltsel,
228 join = scalarltjoinsel
229 );
231 CREATE OPERATOR = (
232 leftarg = epoint,
233 rightarg = epoint,
234 procedure = epoint_btree_eq,
235 commutator = =,
236 negator = <>,
237 restrict = eqsel,
238 join = eqjoinsel,
239 merges
240 );
242 CREATE OPERATOR <> (
243 leftarg = epoint,
244 rightarg = epoint,
245 procedure = epoint_btree_eq,
246 commutator = <>,
247 negator = =,
248 restrict = neqsel,
249 join = neqjoinsel
250 );
252 CREATE OPERATOR >>>= (
253 leftarg = epoint,
254 rightarg = epoint,
255 procedure = epoint_btree_ge,
256 commutator = <<<=,
257 negator = <<<,
258 restrict = scalargtsel,
259 join = scalargtjoinsel
260 );
262 CREATE OPERATOR >>> (
263 leftarg = epoint,
264 rightarg = epoint,
265 procedure = epoint_btree_gt,
266 commutator = <<<,
267 negator = <<<=,
268 restrict = scalargtsel,
269 join = scalargtjoinsel
270 );
272 CREATE FUNCTION epoint_btree_cmp(epoint, epoint)
273 RETURNS int4
274 LANGUAGE C IMMUTABLE STRICT
275 AS '$libdir/latlon-v0007', 'pgl_btree_epoint_cmp';
277 CREATE OPERATOR CLASS epoint_btree_ops
278 DEFAULT FOR TYPE epoint USING btree AS
279 OPERATOR 1 <<< ,
280 OPERATOR 2 <<<= ,
281 OPERATOR 3 = ,
282 OPERATOR 4 >>>= ,
283 OPERATOR 5 >>> ,
284 FUNCTION 1 epoint_btree_cmp(epoint, epoint);
286 -- end of B-tree support for epoint
288 -- begin of B-tree support for ebox
290 CREATE FUNCTION ebox_btree_lt(ebox, ebox)
291 RETURNS boolean
292 LANGUAGE C IMMUTABLE STRICT
293 AS '$libdir/latlon-v0007', 'pgl_btree_ebox_lt';
295 CREATE FUNCTION ebox_btree_le(ebox, ebox)
296 RETURNS boolean
297 LANGUAGE C IMMUTABLE STRICT
298 AS '$libdir/latlon-v0007', 'pgl_btree_ebox_le';
300 CREATE FUNCTION ebox_btree_eq(ebox, ebox)
301 RETURNS boolean
302 LANGUAGE C IMMUTABLE STRICT
303 AS '$libdir/latlon-v0007', 'pgl_btree_ebox_eq';
305 CREATE FUNCTION ebox_btree_ne(ebox, ebox)
306 RETURNS boolean
307 LANGUAGE C IMMUTABLE STRICT
308 AS '$libdir/latlon-v0007', 'pgl_btree_ebox_ne';
310 CREATE FUNCTION ebox_btree_ge(ebox, ebox)
311 RETURNS boolean
312 LANGUAGE C IMMUTABLE STRICT
313 AS '$libdir/latlon-v0007', 'pgl_btree_ebox_ge';
315 CREATE FUNCTION ebox_btree_gt(ebox, ebox)
316 RETURNS boolean
317 LANGUAGE C IMMUTABLE STRICT
318 AS '$libdir/latlon-v0007', 'pgl_btree_ebox_gt';
320 CREATE OPERATOR <<< (
321 leftarg = ebox,
322 rightarg = ebox,
323 procedure = ebox_btree_lt,
324 commutator = >>>,
325 negator = >>>=,
326 restrict = scalarltsel,
327 join = scalarltjoinsel
328 );
330 CREATE OPERATOR <<<= (
331 leftarg = ebox,
332 rightarg = ebox,
333 procedure = ebox_btree_le,
334 commutator = >>>=,
335 negator = >>>,
336 restrict = scalarltsel,
337 join = scalarltjoinsel
338 );
340 CREATE OPERATOR = (
341 leftarg = ebox,
342 rightarg = ebox,
343 procedure = ebox_btree_eq,
344 commutator = =,
345 negator = <>,
346 restrict = eqsel,
347 join = eqjoinsel,
348 merges
349 );
351 CREATE OPERATOR <> (
352 leftarg = ebox,
353 rightarg = ebox,
354 procedure = ebox_btree_eq,
355 commutator = <>,
356 negator = =,
357 restrict = neqsel,
358 join = neqjoinsel
359 );
361 CREATE OPERATOR >>>= (
362 leftarg = ebox,
363 rightarg = ebox,
364 procedure = ebox_btree_ge,
365 commutator = <<<=,
366 negator = <<<,
367 restrict = scalargtsel,
368 join = scalargtjoinsel
369 );
371 CREATE OPERATOR >>> (
372 leftarg = ebox,
373 rightarg = ebox,
374 procedure = ebox_btree_gt,
375 commutator = <<<,
376 negator = <<<=,
377 restrict = scalargtsel,
378 join = scalargtjoinsel
379 );
381 CREATE FUNCTION ebox_btree_cmp(ebox, ebox)
382 RETURNS int4
383 LANGUAGE C IMMUTABLE STRICT
384 AS '$libdir/latlon-v0007', 'pgl_btree_ebox_cmp';
386 CREATE OPERATOR CLASS ebox_btree_ops
387 DEFAULT FOR TYPE ebox USING btree AS
388 OPERATOR 1 <<< ,
389 OPERATOR 2 <<<= ,
390 OPERATOR 3 = ,
391 OPERATOR 4 >>>= ,
392 OPERATOR 5 >>> ,
393 FUNCTION 1 ebox_btree_cmp(ebox, ebox);
395 -- end of B-tree support for ebox
397 -- begin of B-tree support for ecircle
399 CREATE FUNCTION ecircle_btree_lt(ecircle, ecircle)
400 RETURNS boolean
401 LANGUAGE C IMMUTABLE STRICT
402 AS '$libdir/latlon-v0007', 'pgl_btree_ecircle_lt';
404 CREATE FUNCTION ecircle_btree_le(ecircle, ecircle)
405 RETURNS boolean
406 LANGUAGE C IMMUTABLE STRICT
407 AS '$libdir/latlon-v0007', 'pgl_btree_ecircle_le';
409 CREATE FUNCTION ecircle_btree_eq(ecircle, ecircle)
410 RETURNS boolean
411 LANGUAGE C IMMUTABLE STRICT
412 AS '$libdir/latlon-v0007', 'pgl_btree_ecircle_eq';
414 CREATE FUNCTION ecircle_btree_ne(ecircle, ecircle)
415 RETURNS boolean
416 LANGUAGE C IMMUTABLE STRICT
417 AS '$libdir/latlon-v0007', 'pgl_btree_ecircle_ne';
419 CREATE FUNCTION ecircle_btree_ge(ecircle, ecircle)
420 RETURNS boolean
421 LANGUAGE C IMMUTABLE STRICT
422 AS '$libdir/latlon-v0007', 'pgl_btree_ecircle_ge';
424 CREATE FUNCTION ecircle_btree_gt(ecircle, ecircle)
425 RETURNS boolean
426 LANGUAGE C IMMUTABLE STRICT
427 AS '$libdir/latlon-v0007', 'pgl_btree_ecircle_gt';
429 CREATE OPERATOR <<< (
430 leftarg = ecircle,
431 rightarg = ecircle,
432 procedure = ecircle_btree_lt,
433 commutator = >>>,
434 negator = >>>=,
435 restrict = scalarltsel,
436 join = scalarltjoinsel
437 );
439 CREATE OPERATOR <<<= (
440 leftarg = ecircle,
441 rightarg = ecircle,
442 procedure = ecircle_btree_le,
443 commutator = >>>=,
444 negator = >>>,
445 restrict = scalarltsel,
446 join = scalarltjoinsel
447 );
449 CREATE OPERATOR = (
450 leftarg = ecircle,
451 rightarg = ecircle,
452 procedure = ecircle_btree_eq,
453 commutator = =,
454 negator = <>,
455 restrict = eqsel,
456 join = eqjoinsel,
457 merges
458 );
460 CREATE OPERATOR <> (
461 leftarg = ecircle,
462 rightarg = ecircle,
463 procedure = ecircle_btree_eq,
464 commutator = <>,
465 negator = =,
466 restrict = neqsel,
467 join = neqjoinsel
468 );
470 CREATE OPERATOR >>>= (
471 leftarg = ecircle,
472 rightarg = ecircle,
473 procedure = ecircle_btree_ge,
474 commutator = <<<=,
475 negator = <<<,
476 restrict = scalargtsel,
477 join = scalargtjoinsel
478 );
480 CREATE OPERATOR >>> (
481 leftarg = ecircle,
482 rightarg = ecircle,
483 procedure = ecircle_btree_gt,
484 commutator = <<<,
485 negator = <<<=,
486 restrict = scalargtsel,
487 join = scalargtjoinsel
488 );
490 CREATE FUNCTION ecircle_btree_cmp(ecircle, ecircle)
491 RETURNS int4
492 LANGUAGE C IMMUTABLE STRICT
493 AS '$libdir/latlon-v0007', 'pgl_btree_ecircle_cmp';
495 CREATE OPERATOR CLASS ecircle_btree_ops
496 DEFAULT FOR TYPE ecircle USING btree AS
497 OPERATOR 1 <<< ,
498 OPERATOR 2 <<<= ,
499 OPERATOR 3 = ,
500 OPERATOR 4 >>>= ,
501 OPERATOR 5 >>> ,
502 FUNCTION 1 ecircle_btree_cmp(ecircle, ecircle);
504 -- end of B-tree support for ecircle
507 ----------------
508 -- type casts --
509 ----------------
511 CREATE FUNCTION cast_epoint_to_ebox(epoint)
512 RETURNS ebox
513 LANGUAGE C IMMUTABLE STRICT
514 AS '$libdir/latlon-v0007', 'pgl_epoint_to_ebox';
516 CREATE CAST (epoint AS ebox) WITH FUNCTION cast_epoint_to_ebox(epoint);
518 CREATE FUNCTION cast_epoint_to_ecircle(epoint)
519 RETURNS ecircle
520 LANGUAGE C IMMUTABLE STRICT
521 AS '$libdir/latlon-v0007', 'pgl_epoint_to_ecircle';
523 CREATE CAST (epoint AS ecircle) WITH FUNCTION cast_epoint_to_ecircle(epoint);
525 CREATE FUNCTION cast_epoint_to_ecluster(epoint)
526 RETURNS ecluster
527 LANGUAGE C IMMUTABLE STRICT
528 AS '$libdir/latlon-v0007', 'pgl_epoint_to_ecluster';
530 CREATE CAST (epoint AS ecluster) WITH FUNCTION cast_epoint_to_ecluster(epoint);
532 CREATE FUNCTION cast_ebox_to_ecluster(ebox)
533 RETURNS ecluster
534 LANGUAGE C IMMUTABLE STRICT
535 AS '$libdir/latlon-v0007', 'pgl_ebox_to_ecluster';
537 CREATE CAST (ebox AS ecluster) WITH FUNCTION cast_ebox_to_ecluster(ebox);
540 ---------------------------
541 -- constructor functions --
542 ---------------------------
544 CREATE FUNCTION epoint(float8, float8)
545 RETURNS epoint
546 LANGUAGE C IMMUTABLE STRICT
547 AS '$libdir/latlon-v0007', 'pgl_create_epoint';
549 CREATE FUNCTION epoint_latlon(float8, float8)
550 RETURNS epoint
551 LANGUAGE SQL IMMUTABLE STRICT AS $$
552 SELECT epoint($1, $2)
553 $$;
555 CREATE FUNCTION epoint_lonlat(float8, float8)
556 RETURNS epoint
557 LANGUAGE SQL IMMUTABLE STRICT AS $$
558 SELECT epoint($2, $1)
559 $$;
561 CREATE FUNCTION empty_ebox()
562 RETURNS ebox
563 LANGUAGE C IMMUTABLE STRICT
564 AS '$libdir/latlon-v0007', 'pgl_create_empty_ebox';
566 CREATE FUNCTION ebox(float8, float8, float8, float8)
567 RETURNS ebox
568 LANGUAGE C IMMUTABLE STRICT
569 AS '$libdir/latlon-v0007', 'pgl_create_ebox';
571 CREATE FUNCTION ebox(epoint, epoint)
572 RETURNS ebox
573 LANGUAGE C IMMUTABLE STRICT
574 AS '$libdir/latlon-v0007', 'pgl_create_ebox_from_epoints';
576 CREATE FUNCTION ecircle(float8, float8, float8)
577 RETURNS ecircle
578 LANGUAGE C IMMUTABLE STRICT
579 AS '$libdir/latlon-v0007', 'pgl_create_ecircle';
581 CREATE FUNCTION ecircle(epoint, float8)
582 RETURNS ecircle
583 LANGUAGE C IMMUTABLE STRICT
584 AS '$libdir/latlon-v0007', 'pgl_create_ecircle_from_epoint';
586 CREATE FUNCTION ecluster_concat(ecluster[])
587 RETURNS ecluster
588 LANGUAGE sql IMMUTABLE STRICT AS $$
589 SELECT array_to_string($1, ' ')::ecluster
590 $$;
592 CREATE FUNCTION ecluster_concat(ecluster, ecluster)
593 RETURNS ecluster
594 LANGUAGE sql IMMUTABLE STRICT AS $$
595 SELECT ($1::text || ' ' || $2::text)::ecluster
596 $$;
598 CREATE FUNCTION ecluster_create_multipoint(epoint[])
599 RETURNS ecluster
600 LANGUAGE sql IMMUTABLE STRICT AS $$
601 SELECT
602 array_to_string(array_agg('point (' || unnest || ')'), ' ')::ecluster
603 FROM unnest($1)
604 $$;
606 CREATE FUNCTION ecluster_create_path(epoint[])
607 RETURNS ecluster
608 LANGUAGE sql IMMUTABLE STRICT AS $$
609 SELECT CASE WHEN "str" = '' THEN 'empty'::ecluster ELSE
610 ('path (' || array_to_string($1, ' ') || ')')::ecluster
611 END
612 FROM array_to_string($1, ' ') AS "str"
613 $$;
615 CREATE FUNCTION ecluster_create_outline(epoint[])
616 RETURNS ecluster
617 LANGUAGE sql IMMUTABLE STRICT AS $$
618 SELECT CASE WHEN "str" = '' THEN 'empty'::ecluster ELSE
619 ('outline (' || array_to_string($1, ' ') || ')')::ecluster
620 END
621 FROM array_to_string($1, ' ') AS "str"
622 $$;
624 CREATE FUNCTION ecluster_create_polygon(epoint[])
625 RETURNS ecluster
626 LANGUAGE sql IMMUTABLE STRICT AS $$
627 SELECT CASE WHEN "str" = '' THEN 'empty'::ecluster ELSE
628 ('polygon (' || array_to_string($1, ' ') || ')')::ecluster
629 END
630 FROM array_to_string($1, ' ') AS "str"
631 $$;
634 ----------------------
635 -- getter functions --
636 ----------------------
638 CREATE FUNCTION latitude(epoint)
639 RETURNS float8
640 LANGUAGE C IMMUTABLE STRICT
641 AS '$libdir/latlon-v0007', 'pgl_epoint_lat';
643 CREATE FUNCTION longitude(epoint)
644 RETURNS float8
645 LANGUAGE C IMMUTABLE STRICT
646 AS '$libdir/latlon-v0007', 'pgl_epoint_lon';
648 CREATE FUNCTION min_latitude(ebox)
649 RETURNS float8
650 LANGUAGE C IMMUTABLE STRICT
651 AS '$libdir/latlon-v0007', 'pgl_ebox_lat_min';
653 CREATE FUNCTION max_latitude(ebox)
654 RETURNS float8
655 LANGUAGE C IMMUTABLE STRICT
656 AS '$libdir/latlon-v0007', 'pgl_ebox_lat_max';
658 CREATE FUNCTION min_longitude(ebox)
659 RETURNS float8
660 LANGUAGE C IMMUTABLE STRICT
661 AS '$libdir/latlon-v0007', 'pgl_ebox_lon_min';
663 CREATE FUNCTION max_longitude(ebox)
664 RETURNS float8
665 LANGUAGE C IMMUTABLE STRICT
666 AS '$libdir/latlon-v0007', 'pgl_ebox_lon_max';
668 CREATE FUNCTION center(ecircle)
669 RETURNS epoint
670 LANGUAGE C IMMUTABLE STRICT
671 AS '$libdir/latlon-v0007', 'pgl_ecircle_center';
673 CREATE FUNCTION radius(ecircle)
674 RETURNS float8
675 LANGUAGE C IMMUTABLE STRICT
676 AS '$libdir/latlon-v0007', 'pgl_ecircle_radius';
678 CREATE FUNCTION ecluster_extract_points(ecluster)
679 RETURNS SETOF epoint
680 LANGUAGE sql IMMUTABLE STRICT AS $$
681 SELECT "match"[2]::epoint
682 FROM regexp_matches($1::text, e'(^| )point \\(([^)]+)\\)', 'g') AS "match"
683 $$;
685 CREATE FUNCTION ecluster_extract_paths(ecluster)
686 RETURNS SETOF epoint[]
687 LANGUAGE sql IMMUTABLE STRICT AS $$
688 SELECT (
689 SELECT array_agg("m2"[1]::epoint)
690 FROM regexp_matches("m1"[2], e'[^ ]+ [^ ]+', 'g') AS "m2"
691 )
692 FROM regexp_matches($1::text, e'(^| )path \\(([^)]+)\\)', 'g') AS "m1"
693 $$;
695 CREATE FUNCTION ecluster_extract_outlines(ecluster)
696 RETURNS SETOF epoint[]
697 LANGUAGE sql IMMUTABLE STRICT AS $$
698 SELECT (
699 SELECT array_agg("m2"[1]::epoint)
700 FROM regexp_matches("m1"[2], e'[^ ]+ [^ ]+', 'g') AS "m2"
701 )
702 FROM regexp_matches($1::text, e'(^| )outline \\(([^)]+)\\)', 'g') AS "m1"
703 $$;
705 CREATE FUNCTION ecluster_extract_polygons(ecluster)
706 RETURNS SETOF epoint[]
707 LANGUAGE sql IMMUTABLE STRICT AS $$
708 SELECT (
709 SELECT array_agg("m2"[1]::epoint)
710 FROM regexp_matches("m1"[2], e'[^ ]+ [^ ]+', 'g') AS "m2"
711 )
712 FROM regexp_matches($1::text, e'(^| )polygon \\(([^)]+)\\)', 'g') AS "m1"
713 $$;
716 ---------------
717 -- operators --
718 ---------------
720 CREATE FUNCTION epoint_ebox_overlap_proc(epoint, ebox)
721 RETURNS boolean
722 LANGUAGE C IMMUTABLE STRICT
723 AS '$libdir/latlon-v0007', 'pgl_epoint_ebox_overlap';
725 CREATE FUNCTION epoint_ecircle_overlap_proc(epoint, ecircle)
726 RETURNS boolean
727 LANGUAGE C IMMUTABLE STRICT
728 AS '$libdir/latlon-v0007', 'pgl_epoint_ecircle_overlap';
730 CREATE FUNCTION epoint_ecluster_overlap_proc(epoint, ecluster)
731 RETURNS boolean
732 LANGUAGE C IMMUTABLE STRICT
733 AS '$libdir/latlon-v0007', 'pgl_epoint_ecluster_overlap';
735 CREATE FUNCTION epoint_ecluster_may_overlap_proc(epoint, ecluster)
736 RETURNS boolean
737 LANGUAGE C IMMUTABLE STRICT
738 AS '$libdir/latlon-v0007', 'pgl_epoint_ecluster_may_overlap';
740 CREATE FUNCTION ebox_overlap_proc(ebox, ebox)
741 RETURNS boolean
742 LANGUAGE C IMMUTABLE STRICT
743 AS '$libdir/latlon-v0007', 'pgl_ebox_overlap';
745 CREATE FUNCTION ebox_ecircle_may_overlap_proc(ebox, ecircle)
746 RETURNS boolean
747 LANGUAGE C IMMUTABLE STRICT
748 AS '$libdir/latlon-v0007', 'pgl_ebox_ecircle_may_overlap';
750 CREATE FUNCTION ebox_ecluster_may_overlap_proc(ebox, ecluster)
751 RETURNS boolean
752 LANGUAGE C IMMUTABLE STRICT
753 AS '$libdir/latlon-v0007', 'pgl_ebox_ecluster_may_overlap';
755 CREATE FUNCTION ecircle_overlap_proc(ecircle, ecircle)
756 RETURNS boolean
757 LANGUAGE C IMMUTABLE STRICT
758 AS '$libdir/latlon-v0007', 'pgl_ecircle_overlap';
760 CREATE FUNCTION ecircle_ecluster_overlap_proc(ecircle, ecluster)
761 RETURNS boolean
762 LANGUAGE C IMMUTABLE STRICT
763 AS '$libdir/latlon-v0007', 'pgl_ecircle_ecluster_overlap';
765 CREATE FUNCTION ecircle_ecluster_may_overlap_proc(ecircle, ecluster)
766 RETURNS boolean
767 LANGUAGE C IMMUTABLE STRICT
768 AS '$libdir/latlon-v0007', 'pgl_ecircle_ecluster_may_overlap';
770 CREATE FUNCTION ecluster_overlap_proc(ecluster, ecluster)
771 RETURNS boolean
772 LANGUAGE C IMMUTABLE STRICT
773 AS '$libdir/latlon-v0007', 'pgl_ecluster_overlap';
775 CREATE FUNCTION ecluster_may_overlap_proc(ecluster, ecluster)
776 RETURNS boolean
777 LANGUAGE C IMMUTABLE STRICT
778 AS '$libdir/latlon-v0007', 'pgl_ecluster_may_overlap';
780 CREATE FUNCTION ecluster_contains_proc(ecluster, ecluster)
781 RETURNS boolean
782 LANGUAGE C IMMUTABLE STRICT
783 AS '$libdir/latlon-v0007', 'pgl_ecluster_contains';
785 CREATE FUNCTION epoint_distance_proc(epoint, epoint)
786 RETURNS float8
787 LANGUAGE C IMMUTABLE STRICT
788 AS '$libdir/latlon-v0007', 'pgl_epoint_distance';
790 CREATE FUNCTION epoint_ecircle_distance_proc(epoint, ecircle)
791 RETURNS float8
792 LANGUAGE C IMMUTABLE STRICT
793 AS '$libdir/latlon-v0007', 'pgl_epoint_ecircle_distance';
795 CREATE FUNCTION epoint_ecluster_distance_proc(epoint, ecluster)
796 RETURNS float8
797 LANGUAGE C IMMUTABLE STRICT
798 AS '$libdir/latlon-v0007', 'pgl_epoint_ecluster_distance';
800 CREATE FUNCTION ecircle_distance_proc(ecircle, ecircle)
801 RETURNS float8
802 LANGUAGE C IMMUTABLE STRICT
803 AS '$libdir/latlon-v0007', 'pgl_ecircle_distance';
805 CREATE FUNCTION ecircle_ecluster_distance_proc(ecircle, ecluster)
806 RETURNS float8
807 LANGUAGE C IMMUTABLE STRICT
808 AS '$libdir/latlon-v0007', 'pgl_ecircle_ecluster_distance';
810 CREATE FUNCTION ecluster_distance_proc(ecluster, ecluster)
811 RETURNS float8
812 LANGUAGE C IMMUTABLE STRICT
813 AS '$libdir/latlon-v0007', 'pgl_ecluster_distance';
815 CREATE OPERATOR && (
816 leftarg = epoint,
817 rightarg = ebox,
818 procedure = epoint_ebox_overlap_proc,
819 commutator = &&,
820 restrict = areasel,
821 join = areajoinsel
822 );
824 CREATE FUNCTION epoint_ebox_overlap_commutator(ebox, epoint)
825 RETURNS boolean
826 LANGUAGE sql IMMUTABLE AS 'SELECT $2 && $1';
828 CREATE OPERATOR && (
829 leftarg = ebox,
830 rightarg = epoint,
831 procedure = epoint_ebox_overlap_commutator,
832 commutator = &&,
833 restrict = areasel,
834 join = areajoinsel
835 );
837 CREATE OPERATOR && (
838 leftarg = epoint,
839 rightarg = ecircle,
840 procedure = epoint_ecircle_overlap_proc,
841 commutator = &&,
842 restrict = areasel,
843 join = areajoinsel
844 );
846 CREATE FUNCTION epoint_ecircle_overlap_commutator(ecircle, epoint)
847 RETURNS boolean
848 LANGUAGE sql IMMUTABLE AS 'SELECT $2 && $1';
850 CREATE OPERATOR && (
851 leftarg = ecircle,
852 rightarg = epoint,
853 procedure = epoint_ecircle_overlap_commutator,
854 commutator = &&,
855 restrict = areasel,
856 join = areajoinsel
857 );
859 CREATE OPERATOR && (
860 leftarg = epoint,
861 rightarg = ecluster,
862 procedure = epoint_ecluster_overlap_proc,
863 commutator = &&,
864 restrict = areasel,
865 join = areajoinsel
866 );
868 CREATE FUNCTION epoint_ecluster_overlap_commutator(ecluster, epoint)
869 RETURNS boolean
870 LANGUAGE sql IMMUTABLE AS 'SELECT $2 && $1';
872 CREATE OPERATOR && (
873 leftarg = ecluster,
874 rightarg = epoint,
875 procedure = epoint_ecluster_overlap_commutator,
876 commutator = &&,
877 restrict = areasel,
878 join = areajoinsel
879 );
881 CREATE OPERATOR && (
882 leftarg = ebox,
883 rightarg = ebox,
884 procedure = ebox_overlap_proc,
885 commutator = &&,
886 restrict = areasel,
887 join = areajoinsel
888 );
890 CREATE OPERATOR && (
891 leftarg = ecircle,
892 rightarg = ecircle,
893 procedure = ecircle_overlap_proc,
894 commutator = &&,
895 restrict = areasel,
896 join = areajoinsel
897 );
899 CREATE OPERATOR && (
900 leftarg = ecircle,
901 rightarg = ecluster,
902 procedure = ecircle_ecluster_overlap_proc,
903 commutator = &&,
904 restrict = areasel,
905 join = areajoinsel
906 );
908 CREATE FUNCTION ecircle_ecluster_overlap_commutator(ecluster, ecircle)
909 RETURNS boolean
910 LANGUAGE sql IMMUTABLE AS 'SELECT $2 && $1';
912 CREATE OPERATOR && (
913 leftarg = ecluster,
914 rightarg = ecircle,
915 procedure = ecircle_ecluster_overlap_commutator,
916 commutator = &&,
917 restrict = areasel,
918 join = areajoinsel
919 );
921 CREATE OPERATOR && (
922 leftarg = ecluster,
923 rightarg = ecluster,
924 procedure = ecluster_overlap_proc,
925 commutator = &&,
926 restrict = areasel,
927 join = areajoinsel
928 );
930 CREATE FUNCTION ebox_ecircle_overlap_castwrap(ebox, ecircle)
931 RETURNS boolean
932 LANGUAGE sql IMMUTABLE AS 'SELECT $1::ecluster && $2';
934 CREATE OPERATOR && (
935 leftarg = ebox,
936 rightarg = ecircle,
937 procedure = ebox_ecircle_overlap_castwrap,
938 commutator = &&,
939 restrict = areasel,
940 join = areajoinsel
941 );
943 CREATE FUNCTION ebox_ecircle_overlap_castwrap(ecircle, ebox)
944 RETURNS boolean
945 LANGUAGE sql IMMUTABLE AS 'SELECT $1 && $2::ecluster';
947 CREATE OPERATOR && (
948 leftarg = ecircle,
949 rightarg = ebox,
950 procedure = ebox_ecircle_overlap_castwrap,
951 commutator = &&,
952 restrict = areasel,
953 join = areajoinsel
954 );
956 CREATE FUNCTION ebox_ecluster_overlap_castwrap(ebox, ecluster)
957 RETURNS boolean
958 LANGUAGE sql IMMUTABLE AS 'SELECT $1::ecluster && $2';
960 CREATE OPERATOR && (
961 leftarg = ebox,
962 rightarg = ecluster,
963 procedure = ebox_ecluster_overlap_castwrap,
964 commutator = &&,
965 restrict = areasel,
966 join = areajoinsel
967 );
969 CREATE FUNCTION ebox_ecluster_overlap_castwrap(ecluster, ebox)
970 RETURNS boolean
971 LANGUAGE sql IMMUTABLE AS 'SELECT $1 && $2::ecluster';
973 CREATE OPERATOR && (
974 leftarg = ecluster,
975 rightarg = ebox,
976 procedure = ebox_ecluster_overlap_castwrap,
977 commutator = &&,
978 restrict = areasel,
979 join = areajoinsel
980 );
982 CREATE OPERATOR &&+ (
983 leftarg = epoint,
984 rightarg = ecluster,
985 procedure = epoint_ecluster_may_overlap_proc,
986 commutator = &&+,
987 restrict = areasel,
988 join = areajoinsel
989 );
991 CREATE FUNCTION epoint_ecluster_may_overlap_commutator(ecluster, epoint)
992 RETURNS boolean
993 LANGUAGE sql IMMUTABLE AS 'SELECT $2 &&+ $1';
995 CREATE OPERATOR &&+ (
996 leftarg = ecluster,
997 rightarg = epoint,
998 procedure = epoint_ecluster_may_overlap_commutator,
999 commutator = &&+,
1000 restrict = areasel,
1001 join = areajoinsel
1002 );
1004 CREATE OPERATOR &&+ (
1005 leftarg = ebox,
1006 rightarg = ecircle,
1007 procedure = ebox_ecircle_may_overlap_proc,
1008 commutator = &&+,
1009 restrict = areasel,
1010 join = areajoinsel
1011 );
1013 CREATE FUNCTION ebox_ecircle_may_overlap_commutator(ecircle, ebox)
1014 RETURNS boolean
1015 LANGUAGE sql IMMUTABLE AS 'SELECT $2 &&+ $1';
1017 CREATE OPERATOR &&+ (
1018 leftarg = ecircle,
1019 rightarg = ebox,
1020 procedure = ebox_ecircle_may_overlap_commutator,
1021 commutator = &&+,
1022 restrict = areasel,
1023 join = areajoinsel
1024 );
1026 CREATE OPERATOR &&+ (
1027 leftarg = ebox,
1028 rightarg = ecluster,
1029 procedure = ebox_ecluster_may_overlap_proc,
1030 commutator = &&+,
1031 restrict = areasel,
1032 join = areajoinsel
1033 );
1035 CREATE FUNCTION ebox_ecluster_may_overlap_commutator(ecluster, ebox)
1036 RETURNS boolean
1037 LANGUAGE sql IMMUTABLE AS 'SELECT $2 &&+ $1';
1039 CREATE OPERATOR &&+ (
1040 leftarg = ecluster,
1041 rightarg = ebox,
1042 procedure = ebox_ecluster_may_overlap_commutator,
1043 commutator = &&+,
1044 restrict = areasel,
1045 join = areajoinsel
1046 );
1048 CREATE OPERATOR &&+ (
1049 leftarg = ecircle,
1050 rightarg = ecluster,
1051 procedure = ecircle_ecluster_may_overlap_proc,
1052 commutator = &&+,
1053 restrict = areasel,
1054 join = areajoinsel
1055 );
1057 CREATE FUNCTION ecircle_ecluster_may_overlap_commutator(ecluster, ecircle)
1058 RETURNS boolean
1059 LANGUAGE sql IMMUTABLE AS 'SELECT $2 &&+ $1';
1061 CREATE OPERATOR &&+ (
1062 leftarg = ecluster,
1063 rightarg = ecircle,
1064 procedure = ecircle_ecluster_may_overlap_commutator,
1065 commutator = &&+,
1066 restrict = areasel,
1067 join = areajoinsel
1068 );
1070 CREATE OPERATOR &&+ (
1071 leftarg = ecluster,
1072 rightarg = ecluster,
1073 procedure = ecluster_may_overlap_proc,
1074 commutator = &&+,
1075 restrict = areasel,
1076 join = areajoinsel
1077 );
1079 CREATE OPERATOR @> (
1080 leftarg = ebox,
1081 rightarg = epoint,
1082 procedure = epoint_ebox_overlap_commutator,
1083 commutator = <@,
1084 restrict = areasel,
1085 join = areajoinsel
1086 );
1088 CREATE OPERATOR <@ (
1089 leftarg = epoint,
1090 rightarg = ebox,
1091 procedure = epoint_ebox_overlap_proc,
1092 commutator = @>,
1093 restrict = areasel,
1094 join = areajoinsel
1095 );
1097 CREATE OPERATOR @> (
1098 leftarg = ecluster,
1099 rightarg = epoint,
1100 procedure = epoint_ecluster_overlap_commutator,
1101 commutator = <@,
1102 restrict = areasel,
1103 join = areajoinsel
1104 );
1106 CREATE OPERATOR <@ (
1107 leftarg = epoint,
1108 rightarg = ecluster,
1109 procedure = epoint_ecluster_overlap_proc,
1110 commutator = <@,
1111 restrict = areasel,
1112 join = areajoinsel
1113 );
1115 CREATE OPERATOR @> (
1116 leftarg = ecluster,
1117 rightarg = ecluster,
1118 procedure = ecluster_contains_proc,
1119 commutator = <@,
1120 restrict = areasel,
1121 join = areajoinsel
1122 );
1124 CREATE FUNCTION ecluster_contains_commutator(ecluster, ecluster)
1125 RETURNS boolean
1126 LANGUAGE sql IMMUTABLE AS 'SELECT $2 @> $1';
1128 CREATE OPERATOR <@ (
1129 leftarg = ecluster,
1130 rightarg = ecluster,
1131 procedure = ecluster_contains_commutator,
1132 commutator = @>,
1133 restrict = areasel,
1134 join = areajoinsel
1135 );
1137 CREATE FUNCTION ebox_contains_castwrap(ebox, ebox)
1138 RETURNS boolean
1139 LANGUAGE sql IMMUTABLE AS 'SELECT $1::ecluster @> $2::ecluster';
1141 CREATE OPERATOR @> (
1142 leftarg = ebox,
1143 rightarg = ebox,
1144 procedure = ebox_contains_castwrap,
1145 commutator = <@,
1146 restrict = areasel,
1147 join = areajoinsel
1148 );
1150 CREATE FUNCTION ebox_contains_swapped_castwrap(ebox, ebox)
1151 RETURNS boolean
1152 LANGUAGE sql IMMUTABLE AS 'SELECT $2::ecluster @> $1::ecluster';
1154 CREATE OPERATOR <@ (
1155 leftarg = ebox,
1156 rightarg = ebox,
1157 procedure = ebox_contains_swapped_castwrap,
1158 commutator = @>,
1159 restrict = areasel,
1160 join = areajoinsel
1161 );
1163 CREATE FUNCTION ebox_ecluster_contains_castwrap(ebox, ecluster)
1164 RETURNS boolean
1165 LANGUAGE sql IMMUTABLE AS 'SELECT $1::ecluster @> $2';
1167 CREATE OPERATOR @> (
1168 leftarg = ebox,
1169 rightarg = ecluster,
1170 procedure = ebox_ecluster_contains_castwrap,
1171 commutator = <@,
1172 restrict = areasel,
1173 join = areajoinsel
1174 );
1176 CREATE FUNCTION ebox_ecluster_contains_castwrap(ecluster, ebox)
1177 RETURNS boolean
1178 LANGUAGE sql IMMUTABLE AS 'SELECT $2::ecluster @> $1';
1180 CREATE OPERATOR <@ (
1181 leftarg = ecluster,
1182 rightarg = ebox,
1183 procedure = ebox_ecluster_contains_castwrap,
1184 commutator = @>,
1185 restrict = areasel,
1186 join = areajoinsel
1187 );
1189 CREATE FUNCTION ecluster_ebox_contains_castwrap(ecluster, ebox)
1190 RETURNS boolean
1191 LANGUAGE sql IMMUTABLE AS 'SELECT $1 @> $2::ecluster';
1193 CREATE OPERATOR @> (
1194 leftarg = ecluster,
1195 rightarg = ebox,
1196 procedure = ecluster_ebox_contains_castwrap,
1197 commutator = <@,
1198 restrict = areasel,
1199 join = areajoinsel
1200 );
1202 CREATE FUNCTION ecluster_ebox_contains_castwrap(ebox, ecluster)
1203 RETURNS boolean
1204 LANGUAGE sql IMMUTABLE AS 'SELECT $2 @> $1::ecluster';
1206 CREATE OPERATOR <@ (
1207 leftarg = ebox,
1208 rightarg = ecluster,
1209 procedure = ecluster_ebox_contains_castwrap,
1210 commutator = @>,
1211 restrict = areasel,
1212 join = areajoinsel
1213 );
1215 CREATE OPERATOR <-> (
1216 leftarg = epoint,
1217 rightarg = epoint,
1218 procedure = epoint_distance_proc,
1219 commutator = <->
1220 );
1222 CREATE OPERATOR <-> (
1223 leftarg = epoint,
1224 rightarg = ecircle,
1225 procedure = epoint_ecircle_distance_proc,
1226 commutator = <->
1227 );
1229 CREATE FUNCTION epoint_ecircle_distance_commutator(ecircle, epoint)
1230 RETURNS float8
1231 LANGUAGE sql IMMUTABLE AS 'SELECT $2 <-> $1';
1233 CREATE OPERATOR <-> (
1234 leftarg = ecircle,
1235 rightarg = epoint,
1236 procedure = epoint_ecircle_distance_commutator,
1237 commutator = <->
1238 );
1240 CREATE OPERATOR <-> (
1241 leftarg = epoint,
1242 rightarg = ecluster,
1243 procedure = epoint_ecluster_distance_proc,
1244 commutator = <->
1245 );
1247 CREATE FUNCTION epoint_ecluster_distance_commutator(ecluster, epoint)
1248 RETURNS float8
1249 LANGUAGE sql IMMUTABLE AS 'SELECT $2 <-> $1';
1251 CREATE OPERATOR <-> (
1252 leftarg = ecluster,
1253 rightarg = epoint,
1254 procedure = epoint_ecluster_distance_commutator,
1255 commutator = <->
1256 );
1258 CREATE OPERATOR <-> (
1259 leftarg = ecircle,
1260 rightarg = ecircle,
1261 procedure = ecircle_distance_proc,
1262 commutator = <->
1263 );
1265 CREATE OPERATOR <-> (
1266 leftarg = ecircle,
1267 rightarg = ecluster,
1268 procedure = ecircle_ecluster_distance_proc,
1269 commutator = <->
1270 );
1272 CREATE FUNCTION ecircle_ecluster_distance_commutator(ecluster, ecircle)
1273 RETURNS float8
1274 LANGUAGE sql IMMUTABLE AS 'SELECT $2 <-> $1';
1276 CREATE OPERATOR <-> (
1277 leftarg = ecluster,
1278 rightarg = ecircle,
1279 procedure = ecircle_ecluster_distance_commutator,
1280 commutator = <->
1281 );
1283 CREATE OPERATOR <-> (
1284 leftarg = ecluster,
1285 rightarg = ecluster,
1286 procedure = ecluster_distance_proc,
1287 commutator = <->
1288 );
1290 CREATE FUNCTION epoint_ebox_distance_castwrap(epoint, ebox)
1291 RETURNS float8
1292 LANGUAGE sql IMMUTABLE AS 'SELECT $1 <-> $2::ecluster';
1294 CREATE OPERATOR <-> (
1295 leftarg = epoint,
1296 rightarg = ebox,
1297 procedure = epoint_ebox_distance_castwrap,
1298 commutator = <->
1299 );
1301 CREATE FUNCTION epoint_ebox_distance_castwrap(ebox, epoint)
1302 RETURNS float8
1303 LANGUAGE sql IMMUTABLE AS 'SELECT $1::ecluster <-> $2';
1305 CREATE OPERATOR <-> (
1306 leftarg = ebox,
1307 rightarg = epoint,
1308 procedure = epoint_ebox_distance_castwrap,
1309 commutator = <->
1310 );
1312 CREATE FUNCTION ebox_distance_castwrap(ebox, ebox)
1313 RETURNS float8
1314 LANGUAGE sql IMMUTABLE AS 'SELECT $1::ecluster <-> $2::ecluster';
1316 CREATE OPERATOR <-> (
1317 leftarg = ebox,
1318 rightarg = ebox,
1319 procedure = ebox_distance_castwrap,
1320 commutator = <->
1321 );
1323 CREATE FUNCTION ebox_ecircle_distance_castwrap(ebox, ecircle)
1324 RETURNS float8
1325 LANGUAGE sql IMMUTABLE AS 'SELECT $1::ecluster <-> $2';
1327 CREATE OPERATOR <-> (
1328 leftarg = ebox,
1329 rightarg = ecircle,
1330 procedure = ebox_ecircle_distance_castwrap,
1331 commutator = <->
1332 );
1334 CREATE FUNCTION ebox_ecircle_distance_castwrap(ecircle, ebox)
1335 RETURNS float8
1336 LANGUAGE sql IMMUTABLE AS 'SELECT $1 <-> $2::ecluster';
1338 CREATE OPERATOR <-> (
1339 leftarg = ecircle,
1340 rightarg = ebox,
1341 procedure = ebox_ecircle_distance_castwrap,
1342 commutator = <->
1343 );
1345 CREATE FUNCTION ebox_ecluster_distance_castwrap(ebox, ecluster)
1346 RETURNS float8
1347 LANGUAGE sql IMMUTABLE AS 'SELECT $1::ecluster <-> $2';
1349 CREATE OPERATOR <-> (
1350 leftarg = ebox,
1351 rightarg = ecluster,
1352 procedure = ebox_ecluster_distance_castwrap,
1353 commutator = <->
1354 );
1356 CREATE FUNCTION ebox_ecluster_distance_castwrap(ecluster, ebox)
1357 RETURNS float8
1358 LANGUAGE sql IMMUTABLE AS 'SELECT $1 <-> $2::ecluster';
1360 CREATE OPERATOR <-> (
1361 leftarg = ecluster,
1362 rightarg = ebox,
1363 procedure = ebox_ecluster_distance_castwrap,
1364 commutator = <->
1365 );
1368 ----------------
1369 -- GiST index --
1370 ----------------
1372 CREATE FUNCTION pgl_gist_consistent(internal, internal, smallint, oid, internal)
1373 RETURNS boolean
1374 LANGUAGE C STRICT
1375 AS '$libdir/latlon-v0007', 'pgl_gist_consistent';
1377 CREATE FUNCTION pgl_gist_union(internal, internal)
1378 RETURNS internal
1379 LANGUAGE C STRICT
1380 AS '$libdir/latlon-v0007', 'pgl_gist_union';
1382 CREATE FUNCTION pgl_gist_compress_epoint(internal)
1383 RETURNS internal
1384 LANGUAGE C STRICT
1385 AS '$libdir/latlon-v0007', 'pgl_gist_compress_epoint';
1387 CREATE FUNCTION pgl_gist_compress_ecircle(internal)
1388 RETURNS internal
1389 LANGUAGE C STRICT
1390 AS '$libdir/latlon-v0007', 'pgl_gist_compress_ecircle';
1392 CREATE FUNCTION pgl_gist_compress_ecluster(internal)
1393 RETURNS internal
1394 LANGUAGE C STRICT
1395 AS '$libdir/latlon-v0007', 'pgl_gist_compress_ecluster';
1397 CREATE FUNCTION pgl_gist_decompress(internal)
1398 RETURNS internal
1399 LANGUAGE C STRICT
1400 AS '$libdir/latlon-v0007', 'pgl_gist_decompress';
1402 CREATE FUNCTION pgl_gist_penalty(internal, internal, internal)
1403 RETURNS internal
1404 LANGUAGE C STRICT
1405 AS '$libdir/latlon-v0007', 'pgl_gist_penalty';
1407 CREATE FUNCTION pgl_gist_picksplit(internal, internal)
1408 RETURNS internal
1409 LANGUAGE C STRICT
1410 AS '$libdir/latlon-v0007', 'pgl_gist_picksplit';
1412 CREATE FUNCTION pgl_gist_same(internal, internal, internal)
1413 RETURNS internal
1414 LANGUAGE C STRICT
1415 AS '$libdir/latlon-v0007', 'pgl_gist_same';
1417 CREATE FUNCTION pgl_gist_distance(internal, internal, smallint, oid)
1418 RETURNS internal
1419 LANGUAGE C STRICT
1420 AS '$libdir/latlon-v0007', 'pgl_gist_distance';
1422 CREATE OPERATOR CLASS epoint_ops
1423 DEFAULT FOR TYPE epoint USING gist AS
1424 OPERATOR 11 = ,
1425 OPERATOR 22 && (epoint, ebox),
1426 OPERATOR 222 <@ (epoint, ebox),
1427 OPERATOR 23 && (epoint, ecircle),
1428 OPERATOR 24 && (epoint, ecluster),
1429 OPERATOR 124 &&+ (epoint, ecluster),
1430 OPERATOR 224 <@ (epoint, ecluster),
1431 OPERATOR 31 <-> (epoint, epoint) FOR ORDER BY float_ops,
1432 OPERATOR 32 <-> (epoint, ebox) FOR ORDER BY float_ops,
1433 OPERATOR 33 <-> (epoint, ecircle) FOR ORDER BY float_ops,
1434 OPERATOR 34 <-> (epoint, ecluster) FOR ORDER BY float_ops,
1435 FUNCTION 1 pgl_gist_consistent(internal, internal, smallint, oid, internal),
1436 FUNCTION 2 pgl_gist_union(internal, internal),
1437 FUNCTION 3 pgl_gist_compress_epoint(internal),
1438 FUNCTION 4 pgl_gist_decompress(internal),
1439 FUNCTION 5 pgl_gist_penalty(internal, internal, internal),
1440 FUNCTION 6 pgl_gist_picksplit(internal, internal),
1441 FUNCTION 7 pgl_gist_same(internal, internal, internal),
1442 FUNCTION 8 pgl_gist_distance(internal, internal, smallint, oid),
1443 STORAGE ekey_point;
1445 CREATE OPERATOR CLASS ecircle_ops
1446 DEFAULT FOR TYPE ecircle USING gist AS
1447 OPERATOR 13 = ,
1448 OPERATOR 21 && (ecircle, epoint),
1449 OPERATOR 22 && (ecircle, ebox),
1450 OPERATOR 122 &&+ (ecircle, ebox),
1451 OPERATOR 23 && (ecircle, ecircle),
1452 OPERATOR 24 && (ecircle, ecluster),
1453 OPERATOR 124 &&+ (ecircle, ecluster),
1454 OPERATOR 31 <-> (ecircle, epoint) FOR ORDER BY float_ops,
1455 OPERATOR 32 <-> (ecircle, ebox) FOR ORDER BY float_ops,
1456 OPERATOR 33 <-> (ecircle, ecircle) FOR ORDER BY float_ops,
1457 OPERATOR 34 <-> (ecircle, ecluster) FOR ORDER BY float_ops,
1458 FUNCTION 1 pgl_gist_consistent(internal, internal, smallint, oid, internal),
1459 FUNCTION 2 pgl_gist_union(internal, internal),
1460 FUNCTION 3 pgl_gist_compress_ecircle(internal),
1461 FUNCTION 4 pgl_gist_decompress(internal),
1462 FUNCTION 5 pgl_gist_penalty(internal, internal, internal),
1463 FUNCTION 6 pgl_gist_picksplit(internal, internal),
1464 FUNCTION 7 pgl_gist_same(internal, internal, internal),
1465 FUNCTION 8 pgl_gist_distance(internal, internal, smallint, oid),
1466 STORAGE ekey_area;
1468 CREATE OPERATOR CLASS ecluster_ops
1469 DEFAULT FOR TYPE ecluster USING gist AS
1470 OPERATOR 21 && (ecluster, epoint),
1471 OPERATOR 121 &&+ (ecluster, epoint),
1472 OPERATOR 221 @> (ecluster, epoint),
1473 OPERATOR 22 && (ecluster, ebox),
1474 OPERATOR 122 &&+ (ecluster, ebox),
1475 OPERATOR 222 @> (ecluster, ebox),
1476 OPERATOR 322 <@ (ecluster, ebox),
1477 OPERATOR 23 && (ecluster, ecircle),
1478 OPERATOR 123 &&+ (ecluster, ecircle),
1479 OPERATOR 24 && (ecluster, ecluster),
1480 OPERATOR 124 &&+ (ecluster, ecluster),
1481 OPERATOR 224 @> (ecluster, ecluster),
1482 OPERATOR 324 <@ (ecluster, ecluster),
1483 OPERATOR 31 <-> (ecluster, epoint) FOR ORDER BY float_ops,
1484 OPERATOR 32 <-> (ecluster, ebox) FOR ORDER BY float_ops,
1485 OPERATOR 33 <-> (ecluster, ecircle) FOR ORDER BY float_ops,
1486 OPERATOR 34 <-> (ecluster, ecluster) FOR ORDER BY float_ops,
1487 FUNCTION 1 pgl_gist_consistent(internal, internal, smallint, oid, internal),
1488 FUNCTION 2 pgl_gist_union(internal, internal),
1489 FUNCTION 3 pgl_gist_compress_ecluster(internal),
1490 FUNCTION 4 pgl_gist_decompress(internal),
1491 FUNCTION 5 pgl_gist_penalty(internal, internal, internal),
1492 FUNCTION 6 pgl_gist_picksplit(internal, internal),
1493 FUNCTION 7 pgl_gist_same(internal, internal, internal),
1494 FUNCTION 8 pgl_gist_distance(internal, internal, smallint, oid),
1495 STORAGE ekey_area;
1498 ---------------------
1499 -- alias functions --
1500 ---------------------
1502 CREATE FUNCTION distance(epoint, epoint)
1503 RETURNS float8
1504 LANGUAGE sql IMMUTABLE AS 'SELECT $1 <-> $2';
1506 CREATE FUNCTION distance(ecluster, epoint)
1507 RETURNS float8
1508 LANGUAGE sql IMMUTABLE AS 'SELECT $1 <-> $2';
1510 CREATE FUNCTION distance_within(epoint, epoint, float8)
1511 RETURNS boolean
1512 LANGUAGE sql IMMUTABLE AS 'SELECT $1 && ecircle($2, $3)';
1514 CREATE FUNCTION distance_within(ecluster, epoint, float8)
1515 RETURNS boolean
1516 LANGUAGE sql IMMUTABLE AS 'SELECT $1 && ecircle($2, $3)';
1519 --------------------------------
1520 -- other data storage formats --
1521 --------------------------------
1523 CREATE FUNCTION coords_to_epoint(float8, float8, text = 'epoint_lonlat')
1524 RETURNS epoint
1525 LANGUAGE plpgsql IMMUTABLE STRICT AS $$
1526 DECLARE
1527 "result" epoint;
1528 BEGIN
1529 IF $3 = 'epoint_lonlat' THEN
1530 -- avoid dynamic command execution for better performance
1531 RETURN epoint($2, $1);
1532 END IF;
1533 IF $3 = 'epoint' OR $3 = 'epoint_latlon' THEN
1534 -- avoid dynamic command execution for better performance
1535 RETURN epoint($1, $2);
1536 END IF;
1537 EXECUTE 'SELECT ' || $3 || '($1, $2)' INTO STRICT "result" USING $1, $2;
1538 RETURN "result";
1539 END;
1540 $$;
1542 CREATE FUNCTION GeoJSON_to_epoint(jsonb, text = 'epoint_lonlat')
1543 RETURNS epoint
1544 LANGUAGE sql IMMUTABLE STRICT AS $$
1545 SELECT CASE
1546 WHEN $1->>'type' = 'Point' THEN
1547 coords_to_epoint(
1548 ($1->'coordinates'->>1)::float8,
1549 ($1->'coordinates'->>0)::float8,
1550 $2
1551 )
1552 WHEN $1->>'type' = 'Feature' THEN
1553 GeoJSON_to_epoint($1->'geometry', $2)
1554 ELSE
1555 NULL
1556 END
1557 $$;
1559 CREATE FUNCTION GeoJSON_to_ecluster(jsonb, text = 'epoint_lonlat')
1560 RETURNS ecluster
1561 LANGUAGE sql IMMUTABLE STRICT AS $$
1562 SELECT CASE $1->>'type'
1563 WHEN 'Point' THEN
1564 coords_to_epoint(
1565 ($1->'coordinates'->>1)::float8,
1566 ($1->'coordinates'->>0)::float8,
1567 $2
1568 )::ecluster
1569 WHEN 'MultiPoint' THEN
1570 ( SELECT ecluster_create_multipoint(array_agg(
1571 coords_to_epoint(
1572 ("coord"->>1)::float8,
1573 ("coord"->>0)::float8,
1574 $2
1575 )
1576 ))
1577 FROM jsonb_array_elements($1->'coordinates') AS "coord"
1578 )
1579 WHEN 'LineString' THEN
1580 ( SELECT ecluster_create_path(array_agg(
1581 coords_to_epoint(
1582 ("coord"->>1)::float8,
1583 ("coord"->>0)::float8,
1584 $2
1585 )
1586 ))
1587 FROM jsonb_array_elements($1->'coordinates') AS "coord"
1588 )
1589 WHEN 'MultiLineString' THEN
1590 ( SELECT ecluster_concat(array_agg(
1591 ( SELECT ecluster_create_path(array_agg(
1592 coords_to_epoint(
1593 ("coord"->>1)::float8,
1594 ("coord"->>0)::float8,
1595 $2
1596 )
1597 ))
1598 FROM jsonb_array_elements("coord_array") AS "coord"
1599 )
1600 ))
1601 FROM jsonb_array_elements($1->'coordinates') AS "coord_array"
1602 )
1603 WHEN 'Polygon' THEN
1604 ( SELECT ecluster_concat(array_agg(
1605 ( SELECT ecluster_create_polygon(array_agg(
1606 coords_to_epoint(
1607 ("coord"->>1)::float8,
1608 ("coord"->>0)::float8,
1609 $2
1610 )
1611 ))
1612 FROM jsonb_array_elements("coord_array") AS "coord"
1613 )
1614 ))
1615 FROM jsonb_array_elements($1->'coordinates') AS "coord_array"
1616 )
1617 WHEN 'MultiPolygon' THEN
1618 ( SELECT ecluster_concat(array_agg(
1619 ( SELECT ecluster_concat(array_agg(
1620 ( SELECT ecluster_create_polygon(array_agg(
1621 coords_to_epoint(
1622 ("coord"->>1)::float8,
1623 ("coord"->>0)::float8,
1624 $2
1625 )
1626 ))
1627 FROM jsonb_array_elements("coord_array") AS "coord"
1628 )
1629 ))
1630 FROM jsonb_array_elements("coord_array_array") AS "coord_array"
1631 )
1632 ))
1633 FROM jsonb_array_elements($1->'coordinates') AS "coord_array_array"
1634 )
1635 WHEN 'Feature' THEN
1636 GeoJSON_to_ecluster($1->'geometry', $2)
1637 WHEN 'FeatureCollection' THEN
1638 ( SELECT ecluster_concat(array_agg(
1639 GeoJSON_to_ecluster("feature", $2)
1640 ))
1641 FROM jsonb_array_elements($1->'features') AS "feature"
1642 )
1643 ELSE
1644 NULL
1645 END
1646 $$;