diff --git a/Makefile b/Makefile
index a98cccd..ad44804 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-PGSPHERE_VERSION = 1.2.1
+PGSPHERE_VERSION = 1.2.2
 
 # the base dir name may be changed depending on git clone command
 SRC_DIR = $(shell basename $(shell pwd))
@@ -19,7 +19,8 @@ DATA_built  = $(RELEASE_SQL) \
 			  pg_sphere--1.1.5beta0gavo--1.1.5beta2gavo.sql \
 			  pg_sphere--1.1.5beta2gavo--1.1.5beta4gavo.sql \
 			  pg_sphere--1.1.5beta4gavo--1.2.0.sql \
-			  pg_sphere--1.2.0--1.2.1.sql
+			  pg_sphere--1.2.0--1.2.1.sql \
+			  pg_sphere--1.2.1--1.2.2.sql
 
 DOCS        = README.pg_sphere COPYRIGHT.pg_sphere
 REGRESS     = init tables points euler circle line ellipse poly path box index \
@@ -82,7 +83,6 @@ healpix_bare/healpix_bare.o : healpix_bare/healpix_bare.c
 # experimental for spoint3
 pg_version := $(word 2,$(shell $(PG_CONFIG) --version))
 pg_version_9_5_plus = $(if $(filter-out 9.1% 9.2% 9.3% 9.4%,$(pg_version)),y,n)
-has_parallel = $(if $(filter-out 9.1% 9.2% 9.3% 9.4% 9.5%,$(pg_version)),y,n)
 has_explain_summary = $(if $(filter-out 9.%,$(pg_version)),y,n)
 #
 
@@ -115,9 +115,6 @@ pg_sphere.test.sql: $(RELEASE_SQL) $(shlib)
 
 $(RELEASE_SQL): $(addsuffix .in, $(RELEASE_SQL) $(PGS_SQL))
 	cat $^ > $@
-ifeq ($(has_parallel), n)
-	sed -i -e '/PARALLEL/d' $@ # version $(pg_version) does not have support for PARALLEL
-endif
 
 # for "create extension from unpacked*":
 
@@ -199,15 +196,12 @@ pg_sphere--1.1.5beta2gavo--1.1.5beta4gavo.sql: pgs_moc_compat.sql.in
 
 pg_sphere--1.1.5beta4gavo--1.2.0.sql: pgs_moc_ops.sql.in
 	cat $^ > $@
-ifeq ($(has_parallel), n)
-	sed -i -e '/PARALLEL/d' $@ # version $(pg_version) does not have support for PARALLEL
-endif
 
 pg_sphere--1.2.0--1.2.1.sql: pgs_moc_geo_casts.sql.in pgs_epochprop.sql.in
 	cat $^ > $@
-ifeq ($(has_parallel), n)
-	sed -i -e '/PARALLEL/d' $@ # version $(pg_version) does not have support for PARALLEL
-endif
+
+pg_sphere--1.2.1--1.2.2.sql: upgrade_scripts/pg_sphere--1.2.1--1.2.2.sql.in
+	cat $^ > $@
 
 # end of local stuff
 
diff --git a/expected/init.out b/expected/init.out
index 375eeaf..5bce07c 100644
--- a/expected/init.out
+++ b/expected/init.out
@@ -6,6 +6,6 @@ CREATE EXTENSION pg_sphere;
 select pg_sphere_version();
  pg_sphere_version 
 -------------------
- 1.2.1
+ 1.2.2
 (1 row)
 
diff --git a/gnomo.sql.in b/gnomo.sql.in
index a57f509..3564e04 100644
--- a/gnomo.sql.in
+++ b/gnomo.sql.in
@@ -3,7 +3,7 @@
 CREATE OR REPLACE FUNCTION gnomonic_proj(spoint, spoint)
 RETURNS point
 AS 'MODULE_PATHNAME'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION gnomonic_proj(spoint, spoint) IS
 'gnomonic projection, the second argument is the tangential point';
@@ -11,7 +11,7 @@ COMMENT ON FUNCTION gnomonic_proj(spoint, spoint) IS
 CREATE OR REPLACE FUNCTION gnomonic_inv(point, spoint)
 RETURNS spoint
 AS 'MODULE_PATHNAME'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION gnomonic_inv(point, spoint) IS
 'inverse of gnomonic projection, the second argument is the tangential point';
diff --git a/healpix.sql.in b/healpix.sql.in
index 7f8943a..a754b19 100644
--- a/healpix.sql.in
+++ b/healpix.sql.in
@@ -3,97 +3,97 @@
 CREATE OR REPLACE FUNCTION nest2ring(integer, bigint)
 RETURNS bigint
 AS 'MODULE_PATHNAME', 'pg_nest2ring'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION nest2ring(integer, bigint) IS
 'converts nested Healpix index to a ring Healpix index for the specified integer level (first argument)';
 
 CREATE OR REPLACE FUNCTION ring2nest(integer, bigint)
 RETURNS bigint
 AS 'MODULE_PATHNAME', 'pg_ring2nest'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION ring2nest(integer, bigint) IS
 'converts ringe Healpix index to a nested Healpix index for the specified integer level (first argument)';
 
 CREATE OR REPLACE FUNCTION healpix_convert_nest(integer, integer, bigint)
 RETURNS bigint
 AS 'MODULE_PATHNAME'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION healpix_convert_nest(integer, integer, bigint) IS
 'converts nested Healpix index (last argument) from level of second argument to level of first argument';
 
 CREATE OR REPLACE FUNCTION healpix_convert_ring(integer, integer, bigint)
 RETURNS bigint
 AS 'MODULE_PATHNAME'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION healpix_convert_ring(integer, integer, bigint) IS
 'converts ring Healpix index (last argument) from level of second argument to level of first argument';
 
 CREATE OR REPLACE FUNCTION nside2order(bigint)
 RETURNS integer
 AS 'MODULE_PATHNAME', 'pg_nside2order'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION nside2order(bigint) IS
 'returns integer part of base-two logarithm of argument for powers of two up to 29';
 
 CREATE OR REPLACE FUNCTION order2nside(integer)
 RETURNS bigint
 AS 'MODULE_PATHNAME', 'pg_order2nside'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION order2nside(integer) IS
 'returns power of two for non-negative values up to 29';
 
 CREATE OR REPLACE FUNCTION nside2npix(bigint)
 RETURNS bigint
 AS 'MODULE_PATHNAME', 'pg_nside2npix'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION nside2npix(bigint) IS
 'returns 12 * nside ^ 2, the number of Healpix elements for the nside parameter';
 
 CREATE OR REPLACE FUNCTION npix2nside(bigint)
 RETURNS bigint
 AS 'MODULE_PATHNAME', 'pg_npix2nside'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION npix2nside(bigint) IS
 'returns the nside parameter correspondig to the number of Healpix elements';
 
 CREATE OR REPLACE FUNCTION healpix_nest(integer, spoint)
 RETURNS bigint
 AS 'MODULE_PATHNAME'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION healpix_nest(integer, spoint) IS
 'nested Healpix index of a spherical point for the specified integer level (first argument)';
 
 CREATE OR REPLACE FUNCTION healpix_ring(integer, spoint)
 RETURNS bigint
 AS 'MODULE_PATHNAME'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION healpix_ring(integer, spoint) IS
 'Healpix ring index of a spherical point for the specified integer level (first argument)';
 
 CREATE OR REPLACE FUNCTION centre_of_healpix_nest(integer, bigint)
 RETURNS spoint
 AS 'MODULE_PATHNAME', 'inv_healpix_nest'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION centre_of_healpix_nest(integer, bigint) IS
 'spherical point designating the centre of a nested Healpix element for the specified integer level (first argument)';
 
 CREATE OR REPLACE FUNCTION centre_of_healpix_ring(integer, bigint)
 RETURNS spoint
 AS 'MODULE_PATHNAME', 'inv_healpix_ring'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION centre_of_healpix_ring(integer, bigint) IS
 'spherical point designating the centre of a ring Healpix element for the specified integer level (first argument)';
 
 CREATE OR REPLACE FUNCTION center_of_healpix_nest(integer, bigint)
 RETURNS spoint
 AS 'MODULE_PATHNAME', 'inv_healpix_nest'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION center_of_healpix_nest(integer, bigint) IS
 'spherical point designating the center of a nested Healpix element for the specified integer level (first argument)';
 
 CREATE OR REPLACE FUNCTION center_of_healpix_ring(integer, bigint)
 RETURNS spoint
 AS 'MODULE_PATHNAME', 'inv_healpix_ring'
-LANGUAGE C IMMUTABLE STRICT;
+LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 COMMENT ON FUNCTION center_of_healpix_ring(integer, bigint) IS
 'spherical point designating the center of a ring Healpix element for the specified integer level (first argument)';
diff --git a/pg_sphere--1.2.2.sql.in b/pg_sphere--1.2.2.sql.in
new file mode 100644
index 0000000..b83d02a
--- /dev/null
+++ b/pg_sphere--1.2.2.sql.in
@@ -0,0 +1,2 @@
+-- complain if this script is run via psql
+\echo Use "CREATE EXTENSION pg_sphere" to load this file. \quit
diff --git a/pg_sphere.control b/pg_sphere.control
index 2b64f2f..a995012 100644
--- a/pg_sphere.control
+++ b/pg_sphere.control
@@ -1,5 +1,5 @@
 # pg_sphere extension
 comment = 'spherical objects with useful functions, operators and index support'
-default_version = '1.2.1'
+default_version = '1.2.2'
 module_pathname = '$libdir/pg_sphere'
 relocatable = true
diff --git a/pgs_box.sql.in b/pgs_box.sql.in
index 38b206e..1456b86 100644
--- a/pgs_box.sql.in
+++ b/pgs_box.sql.in
@@ -8,7 +8,7 @@ CREATE FUNCTION sbox(spoint, spoint)
    RETURNS sbox
    AS 'MODULE_PATHNAME', 'spherebox_in_from_points'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox(spoint, spoint) IS
   'returns a spherical box from south-west corner(arg1) and north-east corner(arg2)';
@@ -17,7 +17,7 @@ CREATE FUNCTION sw(sbox)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'spherebox_sw'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sw(sbox) IS
   'south-west corner of spherical box';
@@ -26,7 +26,7 @@ CREATE FUNCTION se(sbox)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'spherebox_se'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION se(sbox) IS
   'south-east corner of spherical box';
@@ -36,7 +36,7 @@ CREATE FUNCTION nw(sbox)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'spherebox_nw'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION nw(sbox) IS
   'north-west corner of spherical box';
@@ -45,7 +45,7 @@ CREATE FUNCTION ne(sbox)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'spherebox_ne'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION ne(sbox) IS
   'north-east corner of spherical box';
@@ -55,7 +55,7 @@ CREATE FUNCTION area(sbox)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherebox_area'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION area(sbox) IS
   'area of a spherical box';
@@ -69,7 +69,7 @@ CREATE FUNCTION circum(sbox)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherebox_circ'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION circum(sbox) IS
   'circumference of spherical box';
@@ -91,7 +91,7 @@ CREATE FUNCTION sbox_equal(sbox, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_equal'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_equal(sbox, sbox) IS
   'returns true, if spherical boxes are equal';
@@ -117,7 +117,7 @@ CREATE FUNCTION sbox_equal_neg (sbox, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_equal_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_equal_neg (sbox, sbox) IS
   'returns true, if spherical boxes are not equal';
@@ -144,7 +144,7 @@ CREATE FUNCTION sbox_contains_box(sbox, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_box'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_box(sbox, sbox) IS
   'true if spherical box contains spherical box';
@@ -158,7 +158,7 @@ CREATE FUNCTION sbox_contains_box_com(sbox, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_box_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_box_com(sbox, sbox) IS
   'true if spherical box contains spherical box';
@@ -172,7 +172,7 @@ CREATE FUNCTION sbox_contains_box_neg(sbox, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_box_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_box_neg(sbox, sbox) IS
   'true if spherical box does not contain spherical box';
@@ -186,7 +186,7 @@ CREATE FUNCTION sbox_contains_box_com_neg(sbox, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_box_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_box_com_neg(sbox, sbox) IS
   'true if spherical box does not contain spherical box';
@@ -200,7 +200,7 @@ CREATE FUNCTION sbox_overlap_box(sbox, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_box'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_overlap_box(sbox, sbox) IS
   'true if spherical box overlap spherical box';
@@ -227,7 +227,7 @@ CREATE FUNCTION sbox_overlap_box_neg(sbox, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_box_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_box_neg(sbox, sbox) IS
   'true if spherical box does not overlap spherical box';
@@ -254,7 +254,7 @@ CREATE FUNCTION sbox_cont_point_com(spoint, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_point_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_cont_point_com(spoint, sbox) IS
   'true if spherical point is contained by spherical box';
@@ -268,7 +268,7 @@ CREATE FUNCTION sbox_cont_point_com_neg(spoint, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_point_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_cont_point_com_neg (spoint, sbox) IS
   'true if spherical point is not contained by spherical box';
@@ -282,7 +282,7 @@ CREATE FUNCTION sbox_cont_point(sbox, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_point'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_cont_point (sbox, spoint) IS
   'true if spherical box contains spherical point';
@@ -296,7 +296,7 @@ CREATE FUNCTION sbox_cont_point_neg(sbox, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_point_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_cont_point_neg (sbox, spoint) IS
   'true if spherical box does not contain spherical point';
@@ -310,7 +310,7 @@ CREATE FUNCTION sbox_contains_circle(sbox, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_circle(sbox, scircle) IS
   'true if spherical box contains spherical circle';
@@ -324,7 +324,7 @@ CREATE FUNCTION sbox_contains_circle_com(scircle, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_circle_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_circle_com(scircle, sbox) IS
   'true if spherical box contains spherical circle';
@@ -338,7 +338,7 @@ CREATE FUNCTION sbox_contains_circle_neg(sbox, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_circle_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_circle_neg(sbox, scircle) IS
   'true if spherical box does not contain spherical circle';
@@ -352,7 +352,7 @@ CREATE FUNCTION sbox_contains_circle_com_neg(scircle, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_circle_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_circle_com_neg(scircle, sbox) IS
   'true if spherical box does not contain spherical circle';
@@ -366,7 +366,7 @@ CREATE FUNCTION scircle_contains_box(scircle, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_box'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_box(scircle, sbox) IS
   'true if spherical circle contains spherical box';
@@ -380,7 +380,7 @@ CREATE FUNCTION scircle_contains_box_com(sbox, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_box_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_box_com(sbox, scircle) IS
   'true if spherical circle contains spherical box';
@@ -394,7 +394,7 @@ CREATE FUNCTION scircle_contains_box_neg(scircle, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_box_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_box_neg(scircle, sbox) IS
   'true if spherical circle does not contain spherical box';
@@ -408,7 +408,7 @@ CREATE FUNCTION scircle_contains_box_com_neg(sbox, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_box_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_box_com_neg(sbox, scircle) IS
   'true if spherical circle does not contain spherical box';
@@ -422,7 +422,7 @@ CREATE FUNCTION sbox_overlap_circle(sbox, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_overlap_circle(sbox, scircle) IS
   'true if spherical circle overlap spherical box';
@@ -449,7 +449,7 @@ CREATE FUNCTION sbox_overlap_circle_com(scircle, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_circle_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_circle_com(scircle, sbox) IS
   'true if spherical circle overlap spherical box';
@@ -477,7 +477,7 @@ CREATE FUNCTION sbox_overlap_circle_neg(sbox, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_circle_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_circle_neg(sbox, scircle) IS
   'true if spherical circle does not overlap spherical box';
@@ -504,7 +504,7 @@ CREATE FUNCTION sbox_overlap_circle_com_neg(scircle, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_circle_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_circle_com_neg(scircle, sbox) IS
   'true if spherical circle does not overlap spherical box';
@@ -532,7 +532,7 @@ CREATE FUNCTION sbox_contains_line(sbox, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_line(sbox, sline) IS
   'true if spherical box contains spherical line';
@@ -546,7 +546,7 @@ CREATE FUNCTION sbox_contains_line_com(sline, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_line_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_line_com(sline, sbox) IS
   'true if spherical box contains spherical line';
@@ -560,7 +560,7 @@ CREATE FUNCTION sbox_contains_line_neg(sbox, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_line_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_line_neg(sbox, sline) IS
   'true if spherical box does not contain spherical line';
@@ -574,7 +574,7 @@ CREATE FUNCTION sbox_contains_line_com_neg(sline, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_line_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_line_com_neg(sline, sbox) IS
   'true if spherical box does not contain spherical line';
@@ -588,7 +588,7 @@ CREATE FUNCTION sbox_overlap_line(sbox, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_overlap_line(sbox, sline) IS
   'true if spherical line overlap spherical box';
@@ -615,7 +615,7 @@ CREATE FUNCTION sbox_overlap_line_com(sline, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_line_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_line_com(sline, sbox) IS
   'true if spherical line overlap spherical box';
@@ -643,7 +643,7 @@ CREATE FUNCTION sbox_overlap_line_neg(sbox, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_line_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_line_neg(sbox, sline) IS
   'true if spherical line does not overlap spherical box';
@@ -670,7 +670,7 @@ CREATE FUNCTION sbox_overlap_line_com_neg(sline, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_line_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_line_com_neg(sline, sbox) IS
   'true if spherical line does not overlap spherical box';
@@ -698,7 +698,7 @@ CREATE FUNCTION sbox_contains_ellipse(sbox, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_ellipse(sbox, sellipse) IS
   'true if spherical box contains spherical ellipse';
@@ -712,7 +712,7 @@ CREATE FUNCTION sbox_contains_ellipse_com(sellipse, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_ellipse_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_ellipse_com(sellipse, sbox) IS
   'true if spherical box contains spherical ellipse';
@@ -726,7 +726,7 @@ CREATE FUNCTION sbox_contains_ellipse_neg(sbox, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_ellipse_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_ellipse_neg(sbox, sellipse) IS
   'true if spherical box does not contain spherical ellipse';
@@ -740,7 +740,7 @@ CREATE FUNCTION sbox_contains_ellipse_com_neg(sellipse, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_ellipse_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_ellipse_com_neg(sellipse, sbox) IS
   'true if spherical box does not contain spherical ellipse';
@@ -754,7 +754,7 @@ CREATE FUNCTION sellipse_contains_box(sellipse, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_box'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_box(sellipse, sbox) IS
   'true if spherical ellipse contains spherical box';
@@ -768,7 +768,7 @@ CREATE FUNCTION sellipse_contains_box_com(sbox, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_box_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_box_com(sbox, sellipse) IS
   'true if spherical ellipse contains spherical box';
@@ -782,7 +782,7 @@ CREATE FUNCTION sellipse_contains_box_neg(sellipse, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_box_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_box_neg(sellipse, sbox) IS
   'true if spherical ellipse does not contain spherical box';
@@ -796,7 +796,7 @@ CREATE FUNCTION sellipse_contains_box_com_neg(sbox, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_box_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_box_com_neg(sbox, sellipse) IS
   'true if spherical ellipse does not contain spherical box';
@@ -810,7 +810,7 @@ CREATE FUNCTION sbox_overlap_ellipse(sbox, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_overlap_ellipse(sbox, sellipse) IS
   'true if spherical ellipse overlap spherical box';
@@ -837,7 +837,7 @@ CREATE FUNCTION sbox_overlap_ellipse_com(sellipse, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_ellipse_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_ellipse_com(sellipse, sbox) IS
   'true if spherical ellipse overlap spherical box';
@@ -865,7 +865,7 @@ CREATE FUNCTION sbox_overlap_ellipse_neg(sbox, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_ellipse_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_ellipse_neg(sbox, sellipse) IS
   'true if spherical ellipse does not overlap spherical box';
@@ -892,7 +892,7 @@ CREATE FUNCTION sbox_overlap_ellipse_com_neg(sellipse, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_ellipse_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_ellipse_com_neg(sellipse, sbox) IS
   'true if spherical ellipse does not overlap spherical box';
@@ -921,7 +921,7 @@ CREATE FUNCTION sbox_contains_poly(sbox, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_poly'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_poly(sbox, spoly) IS
   'true if spherical box contains spherical polygon';
@@ -935,7 +935,7 @@ CREATE FUNCTION sbox_contains_poly_com(spoly, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_poly_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_poly_com(spoly, sbox) IS
   'true if spherical box contains spherical polygon';
@@ -949,7 +949,7 @@ CREATE FUNCTION sbox_contains_poly_neg(sbox, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_poly_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_poly_neg(sbox, spoly) IS
   'true if spherical box does not contain spherical polygon';
@@ -963,7 +963,7 @@ CREATE FUNCTION sbox_contains_poly_com_neg(spoly, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_poly_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_poly_com_neg(spoly, sbox) IS
   'true if spherical box does not contain spherical polygon';
@@ -977,7 +977,7 @@ CREATE FUNCTION spoly_contains_box(spoly, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_box'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_box(spoly, sbox) IS
   'true if spherical polygon contains spherical box';
@@ -991,7 +991,7 @@ CREATE FUNCTION spoly_contains_box_com(sbox, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_box_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_box_com(sbox, spoly) IS
   'true if spherical polygon contains spherical box';
@@ -1005,7 +1005,7 @@ CREATE FUNCTION spoly_contains_box_neg(spoly, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_box_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_box_neg(spoly, sbox) IS
   'true if spherical polygon does not contain spherical box';
@@ -1019,7 +1019,7 @@ CREATE FUNCTION spoly_contains_box_com_neg(sbox, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_box_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_box_com_neg(sbox, spoly) IS
   'true if spherical polygon does not contain spherical box';
@@ -1033,7 +1033,7 @@ CREATE FUNCTION sbox_overlap_poly(sbox, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_poly'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_overlap_poly(sbox, spoly) IS
   'true if spherical polygon overlap spherical box';
@@ -1060,7 +1060,7 @@ CREATE FUNCTION sbox_overlap_poly_com(spoly, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_poly_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_poly_com(spoly, sbox) IS
   'true if spherical polygon overlap spherical box';
@@ -1088,7 +1088,7 @@ CREATE FUNCTION sbox_overlap_poly_neg(sbox, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_poly_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_poly_neg(sbox, spoly) IS
   'true if spherical polygon does not overlap spherical box';
@@ -1115,7 +1115,7 @@ CREATE FUNCTION sbox_overlap_poly_com_neg(spoly, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_poly_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_poly_com_neg(spoly, sbox) IS
   'true if spherical polygon does not overlap spherical box';
@@ -1144,7 +1144,7 @@ CREATE FUNCTION sbox_contains_path(sbox, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_path(sbox, spath) IS
   'true if spherical box contains spherical path';
@@ -1158,7 +1158,7 @@ CREATE FUNCTION sbox_contains_path_com(spath, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_path_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_path_com(spath, sbox) IS
   'true if spherical box contains spherical path';
@@ -1172,7 +1172,7 @@ CREATE FUNCTION sbox_contains_path_neg(sbox, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_path_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_path_neg(sbox, spath) IS
   'true if spherical box does not contain spherical path';
@@ -1186,7 +1186,7 @@ CREATE FUNCTION sbox_contains_path_com_neg(spath, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_cont_path_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_contains_path_com_neg(spath, sbox) IS
   'true if spherical box does not contain spherical path';
@@ -1200,7 +1200,7 @@ CREATE FUNCTION sbox_overlap_path(sbox, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sbox_overlap_path(sbox, spath) IS
   'true if spherical path overlap spherical box';
@@ -1227,7 +1227,7 @@ CREATE FUNCTION sbox_overlap_path_com(spath, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_path_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_path_com(spath, sbox) IS
   'true if spherical path overlap spherical box';
@@ -1255,7 +1255,7 @@ CREATE FUNCTION sbox_overlap_path_neg(sbox, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_path_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_path_neg(sbox, spath) IS
   'true if spherical path does not overlap spherical box';
@@ -1282,7 +1282,7 @@ CREATE FUNCTION sbox_overlap_path_com_neg(spath, sbox)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherebox_overlap_path_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sbox_overlap_path_com_neg(spath, sbox) IS
   'true if spherical path does not overlap spherical box';
diff --git a/pgs_circle.sql.in b/pgs_circle.sql.in
index 99a9ed9..e0c110d 100644
--- a/pgs_circle.sql.in
+++ b/pgs_circle.sql.in
@@ -9,7 +9,7 @@ CREATE FUNCTION area(scircle)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherecircle_area'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION area(scircle) IS
   'area of spherical circle';
@@ -18,7 +18,7 @@ CREATE FUNCTION radius(scircle)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherecircle_radius'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION radius(scircle) IS
   'radius of spherical circle';
@@ -27,7 +27,7 @@ CREATE FUNCTION scircle(spoint, float8)
    RETURNS scircle
    AS 'MODULE_PATHNAME' , 'spherecircle_by_center'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle(spoint, float8) IS
   'spherical circle with spherical point as center and float8 as radius in radians';
@@ -41,7 +41,7 @@ CREATE FUNCTION scircle(spoint)
    RETURNS scircle
    AS 'MODULE_PATHNAME' , 'spherepoint_to_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle(spoint) IS
   'spherical circle with radius 0 and spherical point as center';
@@ -66,7 +66,7 @@ CREATE FUNCTION scircle_equal(scircle, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherecircle_equal'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_equal(scircle, scircle) IS
   'returns true, if spherical circles are equal';
@@ -93,7 +93,7 @@ CREATE FUNCTION scircle_equal_neg(scircle, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherecircle_equal_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_equal_neg(scircle, scircle) IS
   'returns true, if spherical circles are not equal';
@@ -119,7 +119,7 @@ CREATE FUNCTION scircle_overlap(scircle, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherecircle_overlap'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_overlap(scircle, scircle) IS
   'true if spherical circles overlap';
@@ -145,7 +145,7 @@ CREATE FUNCTION scircle_overlap_neg(scircle, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherecircle_overlap_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_overlap_neg(scircle, scircle) IS
   'true if spherical circles do not overlap';
@@ -172,7 +172,7 @@ CREATE FUNCTION center(scircle)
    RETURNS spoint
    AS 'MODULE_PATHNAME' , 'spherecircle_center'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION center(scircle) IS
   'center of spherical circle';
@@ -194,7 +194,7 @@ CREATE FUNCTION circum(scircle)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherecircle_circ'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION circum(scircle) IS
   'circumference of spherical circle';
@@ -216,7 +216,7 @@ CREATE FUNCTION scircle_contained_by_circle(scircle, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherecircle_in_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contained_by_circle(scircle, scircle) IS
   'true if spherical circle is contained by spherical circle';
@@ -229,7 +229,7 @@ CREATE FUNCTION scircle_contained_by_circle_neg (scircle, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherecircle_in_circle_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contained_by_circle_neg (scircle, scircle) IS
   'true if spherical circle is not contained by spherical circle';
@@ -242,7 +242,7 @@ CREATE FUNCTION scircle_contains_circle (scircle, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherecircle_in_circle_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_circle (scircle, scircle) IS
   'true if spherical circle contains spherical circle';
@@ -255,7 +255,7 @@ CREATE FUNCTION scircle_contains_circle_neg (scircle, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherecircle_in_circle_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_circle_neg (scircle, scircle) IS
   'true if spherical circle does not contain spherical circle';
@@ -268,7 +268,7 @@ CREATE FUNCTION spoint_contained_by_circle(spoint, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherepoint_in_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoint_contained_by_circle(spoint, scircle) IS
   'true if spherical point is contained by spherical circle';
@@ -282,7 +282,7 @@ CREATE FUNCTION spoint_contained_by_circle_neg(spoint, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherepoint_in_circle_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoint_contained_by_circle_neg (spoint, scircle) IS
   'true if spherical point is not contained by spherical circle ';
@@ -296,7 +296,7 @@ CREATE FUNCTION spoint_contained_by_circle_com(scircle, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherepoint_in_circle_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoint_contained_by_circle_com (scircle, spoint) IS
   'true if spherical circle contains spherical point ';
@@ -310,7 +310,7 @@ CREATE FUNCTION spoint_contained_by_circle_com_neg(scircle, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME' , 'spherepoint_in_circle_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoint_contained_by_circle_com_neg (scircle, spoint) IS
   'true if spherical circle does not contain spherical point ';
@@ -324,7 +324,7 @@ CREATE FUNCTION dist(scircle, scircle)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherecircle_distance'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION dist(scircle, scircle) IS
   'distance between two spherical circles';
@@ -349,7 +349,7 @@ CREATE FUNCTION dist(scircle, spoint)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherecircle_point_distance'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION dist(scircle, spoint) IS
   'distance between spherical circle and spherical point';
@@ -375,7 +375,7 @@ CREATE FUNCTION dist(spoint, scircle)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherecircle_point_distance_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION dist(spoint, scircle) IS
   'distance between spherical circle and spherical point';
@@ -401,7 +401,7 @@ CREATE FUNCTION strans_circle(scircle, strans)
    RETURNS scircle
    AS 'MODULE_PATHNAME' , 'spheretrans_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_circle (scircle, strans) IS
   'returns a transformated spherical circle';
@@ -420,7 +420,7 @@ CREATE FUNCTION strans_circle_inverse(scircle, strans)
    RETURNS scircle
    AS 'MODULE_PATHNAME' , 'spheretrans_circle_inverse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_circle_inverse (scircle, strans) IS
   'returns a inverse transformated spherical circle';
diff --git a/pgs_ellipse.sql.in b/pgs_ellipse.sql.in
index a29452f..70ab229 100644
--- a/pgs_ellipse.sql.in
+++ b/pgs_ellipse.sql.in
@@ -9,7 +9,7 @@ CREATE FUNCTION sellipse(spoint, float8, float8, float8)
    RETURNS sellipse
    AS 'MODULE_PATHNAME', 'sphereellipse_infunc'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse(spoint, float8, float8, float8) IS
   'returns spherical ellipse from center, radius1, radius2 and inclination';
@@ -18,7 +18,7 @@ CREATE FUNCTION inc(sellipse)
    RETURNS float8
    AS 'MODULE_PATHNAME', 'sphereellipse_incl'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION inc(sellipse) IS
   'inclination of spherical ellipse';
@@ -27,7 +27,7 @@ CREATE FUNCTION lrad(sellipse)
    RETURNS float8
    AS 'MODULE_PATHNAME', 'sphereellipse_rad1'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION lrad(sellipse) IS
   'large radius of spherical ellipse';
@@ -36,7 +36,7 @@ CREATE FUNCTION srad(sellipse)
    RETURNS float8
    AS 'MODULE_PATHNAME', 'sphereellipse_rad2'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION srad(sellipse) IS
   'small radius of spherical ellipse';
@@ -51,7 +51,7 @@ CREATE FUNCTION sellipse(spoint)
    RETURNS sellipse
    AS 'MODULE_PATHNAME', 'spherepoint_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse(spoint) IS
   'returns spherical point as spherical ellipse';
@@ -69,7 +69,7 @@ CREATE FUNCTION scircle(sellipse)
    RETURNS scircle
    AS 'MODULE_PATHNAME', 'sphereellipse_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle(sellipse) IS
   'spherical bounding circle of spherical ellipse';
@@ -86,7 +86,7 @@ CREATE FUNCTION sellipse(scircle)
    RETURNS sellipse
    AS 'MODULE_PATHNAME', 'spherecircle_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse(scircle) IS
   'returns spherical circle as spherical ellipse';
@@ -103,7 +103,7 @@ CREATE FUNCTION strans(sellipse)
    RETURNS strans
    AS 'MODULE_PATHNAME', 'sphereellipse_trans'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans(sellipse) IS
   'returns Euler transformation of spherical ellipse';
@@ -127,7 +127,7 @@ CREATE FUNCTION center(sellipse)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'sphereellipse_center'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION center(sellipse) IS
   'center of spherical ellipse';
@@ -149,7 +149,7 @@ CREATE FUNCTION sellipse_equal(sellipse, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_equal'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_equal(sellipse, sellipse) IS
   'returns true, if spherical ellipses are equal';
@@ -177,7 +177,7 @@ CREATE FUNCTION sellipse_equal_neg(sellipse, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_equal_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_equal_neg(sellipse, sellipse) IS
   'returns true, if spherical ellipses are not equal';
@@ -204,7 +204,7 @@ CREATE FUNCTION sellipse_contains_ellipse(sellipse, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_ellipse(sellipse, sellipse) IS
   'true if spherical ellipse contains spherical ellipse';
@@ -218,7 +218,7 @@ CREATE FUNCTION sellipse_contains_ellipse_com(sellipse, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_ellipse_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_ellipse_com(sellipse, sellipse) IS
   'true if spherical ellipse is contained by spherical ellipse';
@@ -232,7 +232,7 @@ CREATE FUNCTION sellipse_contains_ellipse_neg(sellipse, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_ellipse_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_ellipse_neg(sellipse, sellipse) IS
   'true if spherical ellipse does not contain spherical ellipse';
@@ -246,7 +246,7 @@ CREATE FUNCTION sellipse_contains_ellipse_com_neg(sellipse, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_ellipse_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_ellipse_com_neg(sellipse, sellipse) IS
   'true if spherical ellipse is not contained by spherical ellipse';
@@ -260,7 +260,7 @@ CREATE FUNCTION sellipse_overlap_ellipse(sellipse, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sellipse_overlap_ellipse(sellipse, sellipse) IS
   'true if spherical ellipse overlaps spherical ellipse';
@@ -287,7 +287,7 @@ CREATE FUNCTION sellipse_overlap_ellipse_neg(sellipse, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_ellipse_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sellipse_overlap_ellipse_neg(sellipse, sellipse) IS
   'true if spherical ellipse does not overlap spherical ellipse';
@@ -315,7 +315,7 @@ CREATE FUNCTION sellipse_contains_point(sellipse, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_point'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_point(sellipse, spoint) IS
   'true if spherical ellipse contains spherical point';
@@ -328,7 +328,7 @@ CREATE FUNCTION sellipse_contains_point_com(spoint, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_point_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_point_com(spoint, sellipse) IS
   'true if spherical ellipse contains spherical point';
@@ -342,7 +342,7 @@ CREATE FUNCTION sellipse_contains_point_neg(sellipse, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_point_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_point_neg(sellipse, spoint) IS
   'true if spherical ellipse contains spherical point';
@@ -355,7 +355,7 @@ CREATE FUNCTION sellipse_contains_point_com_neg(spoint, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_point_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_point_com_neg(spoint, sellipse) IS
   'true if spherical ellipse contains spherical point';
@@ -370,7 +370,7 @@ CREATE FUNCTION strans_ellipse(sellipse, strans)
    RETURNS sellipse
    AS 'MODULE_PATHNAME', 'spheretrans_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_ellipse (sellipse, strans) IS
   'returns a transformated spherical ellipse';
@@ -388,7 +388,7 @@ CREATE FUNCTION strans_ellipse_inverse (sellipse, strans)
    RETURNS sellipse
    AS 'MODULE_PATHNAME', 'spheretrans_ellipse_inv'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_ellipse_inverse (sellipse, strans) IS
   'returns a inverse transformated spherical ellipse';
@@ -411,7 +411,7 @@ CREATE FUNCTION sellipse_contains_circle(sellipse, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_circle(sellipse, scircle) IS
   'true if spherical ellipse contains spherical circle';
@@ -425,7 +425,7 @@ CREATE FUNCTION sellipse_contains_circle_com(scircle, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_circle_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_circle_com(scircle, sellipse) IS
   'true if spherical ellipse contains spherical circle';
@@ -439,7 +439,7 @@ CREATE FUNCTION sellipse_contains_circle_neg(sellipse, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_circle_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_circle_neg(sellipse, scircle) IS
   'true if spherical ellipse does not contain spherical circle';
@@ -453,7 +453,7 @@ CREATE FUNCTION sellipse_contains_circle_com_neg(scircle, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_circle_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_circle_com_neg(scircle, sellipse) IS
   'true if spherical ellipse does not contain spherical circle';
@@ -467,7 +467,7 @@ CREATE FUNCTION scircle_contains_ellipse(scircle, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_ellipse(scircle, sellipse) IS
   'true if spherical circle contains spherical ellipse';
@@ -481,7 +481,7 @@ CREATE FUNCTION scircle_contains_ellipse_com(sellipse, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_ellipse_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_ellipse_com(sellipse, scircle) IS
   'true if spherical circle contains spherical ellipse';
@@ -495,7 +495,7 @@ CREATE FUNCTION scircle_contains_ellipse_neg(scircle, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_ellipse_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_ellipse_neg(scircle, sellipse) IS
   'true if spherical circle does not contain spherical ellipse';
@@ -509,7 +509,7 @@ CREATE FUNCTION scircle_contains_ellipse_com_neg(sellipse, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_ellipse_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_ellipse_com_neg(sellipse, scircle) IS
   'true if spherical circle does not contain spherical ellipse';
@@ -523,7 +523,7 @@ CREATE FUNCTION sellipse_overlap_circle(sellipse, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_overlap_circle(sellipse, scircle) IS
   'true if spherical circle overlap spherical ellipse';
@@ -551,7 +551,7 @@ CREATE FUNCTION sellipse_overlap_circle_com(scircle, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_circle_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sellipse_overlap_circle_com(scircle, sellipse) IS
   'true if spherical circle overlap spherical ellipse';
@@ -578,7 +578,7 @@ CREATE FUNCTION sellipse_overlap_circle_neg(sellipse, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_circle_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sellipse_overlap_circle_neg(sellipse, scircle) IS
   'true if spherical circle does not overlap spherical ellipse';
@@ -606,7 +606,7 @@ CREATE FUNCTION sellipse_overlap_circle_com_neg(scircle, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_circle_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sellipse_overlap_circle_com_neg(scircle, sellipse) IS
   'true if spherical circle does not overlap spherical ellipse';
@@ -636,7 +636,7 @@ CREATE FUNCTION sellipse_overlap_line (sellipse, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_overlap_line (sellipse, sline) IS
   'returns true if spherical line overlaps spherical ellipse';
@@ -663,7 +663,7 @@ CREATE FUNCTION sellipse_overlap_line_com(sline, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_line_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_overlap_line_com(sline, sellipse) IS
   'returns true if spherical line overlaps spherical ellipse';
@@ -691,7 +691,7 @@ CREATE FUNCTION sellipse_overlap_line_neg (sellipse, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_line_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_overlap_line_neg (sellipse, sline) IS
   'returns true if spherical line overlaps spherical ellipse';
@@ -718,7 +718,7 @@ CREATE FUNCTION sellipse_overlap_line_com_neg(sline, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_line_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_overlap_line_com_neg(sline, sellipse) IS
   'returns true if spherical line does not overlap spherical ellipse';
@@ -747,7 +747,7 @@ CREATE FUNCTION sellipse_contains_line(sellipse, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_line(sellipse, sline) IS
   'returns true if spherical ellipse contains spherical line';
@@ -762,7 +762,7 @@ CREATE FUNCTION sellipse_contains_line_com(sline, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_line_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_line_com(sline, sellipse) IS
   'returns true if spherical ellipse contains spherical line';
@@ -775,7 +775,7 @@ CREATE FUNCTION sellipse_contains_line_neg(sellipse, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_line_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_line_neg(sellipse, sline) IS
   'returns true if spherical ellipse does not contain spherical line';
@@ -790,7 +790,7 @@ CREATE FUNCTION sellipse_contains_line_com_neg(sline, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_line_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_line_com_neg(sline, sellipse) IS
   'returns true if spherical ellipse does not contain spherical line';
diff --git a/pgs_euler.sql.in b/pgs_euler.sql.in
index 3739315..6bd25e7 100644
--- a/pgs_euler.sql.in
+++ b/pgs_euler.sql.in
@@ -6,7 +6,7 @@ CREATE FUNCTION strans_zxz(strans)
    RETURNS strans
    AS 'MODULE_PATHNAME', 'spheretrans_zxz'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_zxz(strans) IS
   'returns Euler transformation as ZXZ transformation';
@@ -15,7 +15,7 @@ CREATE FUNCTION strans(FLOAT8, FLOAT8, FLOAT8)
    RETURNS strans
    AS 'MODULE_PATHNAME', 'spheretrans_from_float8'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans(FLOAT8, FLOAT8, FLOAT8) IS
   'returns an transformation object using Euler angles (ZXZ)';
@@ -24,7 +24,7 @@ CREATE FUNCTION strans(FLOAT8, FLOAT8, FLOAT8, CSTRING)
    RETURNS strans
    AS 'MODULE_PATHNAME', 'spheretrans_from_float8_and_type'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans(FLOAT8, FLOAT8, FLOAT8, CSTRING) IS
   'returns an transformation object using Euler angles and axis';
@@ -33,7 +33,7 @@ CREATE FUNCTION phi(strans)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spheretrans_phi'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION phi(strans) IS
   'returns the first angle of Euler angles of a transformation object';
@@ -42,7 +42,7 @@ CREATE FUNCTION theta(strans)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spheretrans_theta'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION theta(strans) IS
   'returns the second angle of Euler angles of a transformation object';
@@ -51,7 +51,7 @@ CREATE FUNCTION psi(strans)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spheretrans_psi'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION psi(strans) IS
   'returns the third angle of Euler angles of a transformation object';
@@ -60,7 +60,7 @@ CREATE FUNCTION axes(strans)
    RETURNS CHARACTER(3)
    AS 'MODULE_PATHNAME', 'spheretrans_type'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION axes (strans) IS
   'returns the axis of Euler angles of a transformation object';
@@ -72,7 +72,7 @@ CREATE FUNCTION strans_equal(strans, strans)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spheretrans_equal'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_equal(strans, strans) IS
   'returns true, if Euler transformations are equal';
@@ -96,7 +96,7 @@ CREATE FUNCTION strans_not_equal(strans, strans)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spheretrans_not_equal'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_not_equal(strans, strans) IS
   'returns true, if Euler transformations are not equal';
@@ -119,7 +119,7 @@ CREATE FUNCTION strans(strans)
    RETURNS strans
    AS 'MODULE_PATHNAME', 'spheretrans'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans(strans) IS
   'returns Euler transformation';
@@ -136,7 +136,7 @@ CREATE FUNCTION strans_invert(strans)
    RETURNS strans
    AS 'MODULE_PATHNAME', 'spheretrans_invert'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_invert(strans) IS
   'returns inverse Euler transformation';
@@ -153,7 +153,7 @@ CREATE FUNCTION strans_point(spoint, strans)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'spheretrans_point'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_point (spoint, strans) IS
   'returns a transformated spherical point';
@@ -171,7 +171,7 @@ CREATE FUNCTION strans_point_inverse(spoint, strans)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'spheretrans_point_inverse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_point_inverse (spoint, strans) IS
   'returns a inverse transformated spherical point';
@@ -189,7 +189,7 @@ CREATE FUNCTION strans_trans(strans, strans)
    RETURNS strans
    AS 'MODULE_PATHNAME', 'spheretrans_trans'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_trans (strans, strans) IS
   'returns a transformated Euler transformation';
@@ -207,7 +207,7 @@ CREATE FUNCTION strans_trans_inv(strans, strans)
    RETURNS strans
    AS 'MODULE_PATHNAME', 'spheretrans_trans_inv'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_trans_inv (strans, strans) IS
   'returns a inverse transformated Euler transformation';
diff --git a/pgs_gist.sql.in b/pgs_gist.sql.in
index fe26187..e8ac119 100644
--- a/pgs_gist.sql.in
+++ b/pgs_gist.sql.in
@@ -39,19 +39,19 @@ CREATE FUNCTION pointkey_volume(pointkey)
    RETURNS float8
    AS 'MODULE_PATHNAME', 'pointkey_volume'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE FUNCTION pointkey_area(pointkey)
    RETURNS float8
    AS 'MODULE_PATHNAME', 'pointkey_area'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE FUNCTION pointkey_perimeter(pointkey)
    RETURNS float8
    AS 'MODULE_PATHNAME', 'pointkey_perimeter'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE TYPE pointkey (
    input = pointkey_in,
diff --git a/pgs_gist_pointkey.sql.in b/pgs_gist_pointkey.sql.in
index d447927..47618e4 100644
--- a/pgs_gist_pointkey.sql.in
+++ b/pgs_gist_pointkey.sql.in
@@ -2,32 +2,32 @@ CREATE FUNCTION pointkey_in(CSTRING)
    RETURNS pointkey
    AS 'MODULE_PATHNAME', 'pointkey_in'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 
 CREATE FUNCTION pointkey_out(pointkey)
    RETURNS CSTRING
    AS 'MODULE_PATHNAME', 'pointkey_out'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE FUNCTION pointkey_volume(pointkey)
    RETURNS float8
    AS 'MODULE_PATHNAME', 'pointkey_volume'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE FUNCTION pointkey_area(pointkey)
    RETURNS float8
    AS 'MODULE_PATHNAME', 'pointkey_area'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE FUNCTION pointkey_perimeter(pointkey)
    RETURNS float8
    AS 'MODULE_PATHNAME', 'pointkey_perimeter'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE TYPE pointkey (
    input = pointkey_in,
diff --git a/pgs_gist_spoint3.sql.in b/pgs_gist_spoint3.sql.in
index 6574eda..0382dad 100644
--- a/pgs_gist_spoint3.sql.in
+++ b/pgs_gist_spoint3.sql.in
@@ -9,7 +9,7 @@ CREATE FUNCTION g_spoint3_penalty (internal, internal, internal)
 	RETURNS internal
 	AS 'MODULE_PATHNAME', 'g_spoint3_penalty'
 	LANGUAGE 'c'
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION g_spoint3_picksplit(internal, internal)
 	RETURNS internal
@@ -40,7 +40,7 @@ CREATE FUNCTION g_spoint3_fetch(internal)
 	RETURNS internal
 	AS 'MODULE_PATHNAME', 'g_spoint3_fetch'
 	LANGUAGE 'c'
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE OPERATOR CLASS spoint3
 	FOR TYPE spoint USING gist AS
diff --git a/pgs_line.sql.in b/pgs_line.sql.in
index 4a02c8a..9814355 100644
--- a/pgs_line.sql.in
+++ b/pgs_line.sql.in
@@ -8,7 +8,7 @@ CREATE FUNCTION sline(spoint, spoint)
    RETURNS sline
    AS 'MODULE_PATHNAME', 'sphereline_from_points'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline(spoint, spoint) IS
   'returns a spherical line using begin (arg1) and end (arg2)';
@@ -17,7 +17,7 @@ CREATE FUNCTION sline(strans, float8)
    RETURNS sline
    AS 'MODULE_PATHNAME', 'sphereline_from_trans'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline(strans, float8) IS
   'returns a spherical line using Euler transformation (arg1) and length (arg2)';
@@ -26,7 +26,7 @@ CREATE FUNCTION meridian(float8)
    RETURNS sline
    AS 'MODULE_PATHNAME', 'sphereline_meridian'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION meridian(float8) IS
   'returns a spherical line as a meridian along longitude arg';
@@ -36,7 +36,7 @@ CREATE FUNCTION sl_beg(sline)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'sphereline_begin'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sl_beg(sline) IS
   'returns the begin of a spherical line';
@@ -45,7 +45,7 @@ CREATE FUNCTION sl_end(sline)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'sphereline_end'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sl_end(sline) IS
   'returns the end of a spherical line';
@@ -59,7 +59,7 @@ CREATE FUNCTION strans(sline)
    RETURNS strans
    AS 'MODULE_PATHNAME', 'spheretrans_from_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans(sline) IS
   'converts line to a transformation (ZXZ)';
@@ -77,7 +77,7 @@ CREATE FUNCTION sline(spoint)
    RETURNS sline
    AS 'MODULE_PATHNAME', 'sphereline_from_point'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline(spoint) IS
   'casts a spherical point to a spherical line';
@@ -105,7 +105,7 @@ CREATE FUNCTION sline_equal(sline, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_equal'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_equal(sline, sline) IS
   'returns true, if spherical lines are equal';
@@ -132,7 +132,7 @@ CREATE FUNCTION sline_equal_neg(sline, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_equal_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_equal_neg(sline, sline) IS
   'returns true, if spherical lines are not equal';
@@ -159,7 +159,7 @@ CREATE FUNCTION length(sline)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'sphereline_length'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION length(sline) IS
   'returns the length of a spherical line (in radians)';
@@ -181,7 +181,7 @@ CREATE FUNCTION swap(sline)
    RETURNS sline
    AS 'MODULE_PATHNAME', 'sphereline_swap_beg_end'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION swap(sline) IS
   'returns a spherical line with swapped begin and end';
@@ -202,7 +202,7 @@ CREATE FUNCTION turn(sline)
    RETURNS sline
    AS 'MODULE_PATHNAME', 'sphereline_turn'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION turn(sline) IS
   'returns a turned spherical line but keeps begin and end';
@@ -225,7 +225,7 @@ CREATE FUNCTION sline_crosses(sline, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_crosses'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_crosses(sline, sline) IS
   'returns true if spherical lines cross';
@@ -253,7 +253,7 @@ CREATE FUNCTION sline_crosses_neg(sline, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_crosses_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_crosses_neg(sline, sline) IS
   'returns true if spherical lines do not cross';
@@ -281,7 +281,7 @@ CREATE FUNCTION sline_overlap(sline, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_overlap'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_overlap(sline, sline) IS
   'returns true if spherical lines overlap or cross';
@@ -308,7 +308,7 @@ CREATE FUNCTION sline_overlap_neg(sline, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_overlap_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_overlap_neg(sline, sline) IS
   'returns true if spherical lines do not overlap or cross';
@@ -337,7 +337,7 @@ CREATE FUNCTION sline_contains_point (sline, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_cont_point'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_contains_point (sline, spoint) IS
   'returns true if spherical line contains spherical point';
@@ -352,7 +352,7 @@ CREATE FUNCTION sline_contains_point_com (spoint, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_cont_point_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_contains_point_com (spoint, sline) IS
   'returns true if spherical line contains spherical point';
@@ -366,7 +366,7 @@ CREATE FUNCTION sline_contains_point_neg (sline, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_cont_point_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_contains_point_neg (sline, spoint) IS
   'returns true if spherical line does not contain spherical point';
@@ -380,7 +380,7 @@ CREATE FUNCTION sline_contains_point_com_neg (spoint, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_cont_point_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_contains_point_com_neg (spoint, sline) IS
   'returns true if spherical line does not contain spherical point';
@@ -393,7 +393,7 @@ CREATE FUNCTION strans_line(sline, strans)
    RETURNS sline
    AS 'MODULE_PATHNAME', 'spheretrans_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_line (sline, strans) IS
   'returns a transformated spherical line';
@@ -412,7 +412,7 @@ CREATE FUNCTION strans_line_inverse(sline, strans)
    RETURNS sline
    AS 'MODULE_PATHNAME', 'spheretrans_line_inverse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_line_inverse (sline, strans) IS
   'returns a inverse transformated spherical line';
@@ -435,7 +435,7 @@ CREATE FUNCTION sline_overlap_circle(sline, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_overlap_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_overlap_circle(sline, scircle) IS
   'returns true if spherical line overlaps spherical circle';
@@ -462,7 +462,7 @@ CREATE FUNCTION sline_overlap_circle_com(scircle, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_overlap_circle_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_overlap_circle_com(scircle, sline) IS
   'returns true if spherical line overlaps spherical circle';
@@ -489,7 +489,7 @@ CREATE FUNCTION sline_overlap_circle_neg(sline, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_overlap_circle_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_overlap_circle_neg(sline, scircle) IS
   'returns true if spherical line does not overlap spherical circle';
@@ -516,7 +516,7 @@ CREATE FUNCTION sline_overlap_circle_com_neg(scircle, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereline_overlap_circle_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sline_overlap_circle_com_neg(scircle, sline) IS
   'returns true if spherical line overlaps spherical circle';
@@ -545,7 +545,7 @@ CREATE FUNCTION scircle_contains_line(scircle, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_line(scircle, sline) IS
   'returns true if spherical circle contains spherical line';
@@ -560,7 +560,7 @@ CREATE FUNCTION scircle_contains_line_com(sline, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_line_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_line_com(sline, scircle) IS
   'returns true if spherical circle contains spherical line';
@@ -573,7 +573,7 @@ CREATE FUNCTION scircle_contains_line_neg(scircle, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_line_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_line_neg(scircle, sline) IS
   'returns true if spherical circle does not contain spherical line';
@@ -587,7 +587,7 @@ CREATE FUNCTION scircle_contains_line_com_neg(sline, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_line_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_line_com_neg(sline, scircle) IS
   'returns true if spherical circle does not contain spherical line';
diff --git a/pgs_moc_geo_casts.sql.in b/pgs_moc_geo_casts.sql.in
index 3ace187..1d30710 100644
--- a/pgs_moc_geo_casts.sql.in
+++ b/pgs_moc_geo_casts.sql.in
@@ -29,10 +29,11 @@ reset client_min_messages;
 
 -- #################################
 --  smoc/geo OVERLAPS
+
 CREATE OR REPLACE FUNCTION scircle_subset_smoc(
   geo_arg scircle, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) <@ a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR <@ (
   LEFTARG    = scircle,
   RIGHTARG   = smoc,
@@ -46,7 +47,7 @@ CREATE OPERATOR <@ (
 CREATE OR REPLACE FUNCTION smoc_subset_scircle(
   a_moc smoc, geo_arg scircle) RETURNS BOOL AS $body$
     SELECT a_moc <@ smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR <@ (
   LEFTARG    = smoc,
   RIGHTARG   = scircle,
@@ -60,7 +61,7 @@ CREATE OPERATOR <@ (
 CREATE OR REPLACE FUNCTION spoly_subset_smoc(
   geo_arg spoly, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) <@ a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR <@ (
   LEFTARG    = spoly,
   RIGHTARG   = smoc,
@@ -74,7 +75,7 @@ CREATE OPERATOR <@ (
 CREATE OR REPLACE FUNCTION smoc_subset_spoly(
   a_moc smoc, geo_arg spoly) RETURNS BOOL AS $body$
     SELECT a_moc <@ smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR <@ (
   LEFTARG    = smoc,
   RIGHTARG   = spoly,
@@ -89,7 +90,7 @@ CREATE OPERATOR <@ (
 CREATE OR REPLACE FUNCTION scircle_not_subset_smoc(
   geo_arg scircle, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) !<@ a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !<@ (
   LEFTARG    = scircle,
   RIGHTARG   = smoc,
@@ -103,7 +104,7 @@ CREATE OPERATOR !<@ (
 CREATE OR REPLACE FUNCTION smoc_not_subset_scircle(
   a_moc smoc, geo_arg scircle) RETURNS BOOL AS $body$
     SELECT a_moc !<@ smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !<@ (
   LEFTARG    = smoc,
   RIGHTARG   = scircle,
@@ -117,7 +118,7 @@ CREATE OPERATOR !<@ (
 CREATE OR REPLACE FUNCTION spoly_not_subset_smoc(
   geo_arg spoly, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) !<@ a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !<@ (
   LEFTARG    = spoly,
   RIGHTARG   = smoc,
@@ -131,7 +132,7 @@ CREATE OPERATOR !<@ (
 CREATE OR REPLACE FUNCTION smoc_not_subset_spoly(
   a_moc smoc, geo_arg spoly) RETURNS BOOL AS $body$
     SELECT a_moc !<@ smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !<@ (
   LEFTARG    = smoc,
   RIGHTARG   = spoly,
@@ -146,7 +147,7 @@ CREATE OPERATOR !<@ (
 CREATE OR REPLACE FUNCTION scircle_superset_smoc(
   geo_arg scircle, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) @> a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR @> (
   LEFTARG    = scircle,
   RIGHTARG   = smoc,
@@ -160,7 +161,7 @@ CREATE OPERATOR @> (
 CREATE OR REPLACE FUNCTION smoc_superset_scircle(
   a_moc smoc, geo_arg scircle) RETURNS BOOL AS $body$
     SELECT a_moc @> smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR @> (
   LEFTARG    = smoc,
   RIGHTARG   = scircle,
@@ -174,7 +175,7 @@ CREATE OPERATOR @> (
 CREATE OR REPLACE FUNCTION spoly_superset_smoc(
   geo_arg spoly, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) @> a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR @> (
   LEFTARG    = spoly,
   RIGHTARG   = smoc,
@@ -188,7 +189,7 @@ CREATE OPERATOR @> (
 CREATE OR REPLACE FUNCTION smoc_superset_spoly(
   a_moc smoc, geo_arg spoly) RETURNS BOOL AS $body$
     SELECT a_moc @> smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR @> (
   LEFTARG    = smoc,
   RIGHTARG   = spoly,
@@ -203,7 +204,7 @@ CREATE OPERATOR @> (
 CREATE OR REPLACE FUNCTION scircle_not_superset_smoc(
   geo_arg scircle, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) !@> a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !@> (
   LEFTARG    = scircle,
   RIGHTARG   = smoc,
@@ -217,7 +218,7 @@ CREATE OPERATOR !@> (
 CREATE OR REPLACE FUNCTION smoc_not_superset_scircle(
   a_moc smoc, geo_arg scircle) RETURNS BOOL AS $body$
     SELECT a_moc !@> smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !@> (
   LEFTARG    = smoc,
   RIGHTARG   = scircle,
@@ -231,7 +232,7 @@ CREATE OPERATOR !@> (
 CREATE OR REPLACE FUNCTION spoly_not_superset_smoc(
   geo_arg spoly, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) !@> a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !@> (
   LEFTARG    = spoly,
   RIGHTARG   = smoc,
@@ -245,7 +246,7 @@ CREATE OPERATOR !@> (
 CREATE OR REPLACE FUNCTION smoc_not_superset_spoly(
   a_moc smoc, geo_arg spoly) RETURNS BOOL AS $body$
     SELECT a_moc !@> smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !@> (
   LEFTARG    = smoc,
   RIGHTARG   = spoly,
@@ -263,7 +264,7 @@ CREATE OPERATOR !@> (
 CREATE OR REPLACE FUNCTION scircle_intersect_smoc(
   geo_arg scircle, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) && a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR && (
   LEFTARG    = scircle,
   RIGHTARG   = smoc,
@@ -277,7 +278,7 @@ CREATE OPERATOR && (
 CREATE OR REPLACE FUNCTION smoc_intersect_scircle(
   a_moc smoc, geo_arg scircle) RETURNS BOOL AS $body$
     SELECT a_moc && smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR && (
   LEFTARG    = smoc,
   RIGHTARG   = scircle,
@@ -291,7 +292,7 @@ CREATE OPERATOR && (
 CREATE OR REPLACE FUNCTION spoly_intersect_smoc(
   geo_arg spoly, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) && a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR && (
   LEFTARG    = spoly,
   RIGHTARG   = smoc,
@@ -305,7 +306,7 @@ CREATE OPERATOR && (
 CREATE OR REPLACE FUNCTION smoc_intersect_spoly(
   a_moc smoc, geo_arg spoly) RETURNS BOOL AS $body$
     SELECT a_moc && smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR && (
   LEFTARG    = smoc,
   RIGHTARG   = spoly,
@@ -320,7 +321,7 @@ CREATE OPERATOR && (
 CREATE OR REPLACE FUNCTION scircle_not_intersect_smoc(
   geo_arg scircle, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) !&& a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !&& (
   LEFTARG    = scircle,
   RIGHTARG   = smoc,
@@ -334,7 +335,7 @@ CREATE OPERATOR !&& (
 CREATE OR REPLACE FUNCTION smoc_not_intersect_scircle(
   a_moc smoc, geo_arg scircle) RETURNS BOOL AS $body$
     SELECT a_moc !&& smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !&& (
   LEFTARG    = smoc,
   RIGHTARG   = scircle,
@@ -348,7 +349,7 @@ CREATE OPERATOR !&& (
 CREATE OR REPLACE FUNCTION spoly_not_intersect_smoc(
   geo_arg spoly, a_moc smoc) RETURNS BOOL AS $body$
     SELECT smoc(max_order(a_moc), geo_arg) !&& a_moc
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !&& (
   LEFTARG    = spoly,
   RIGHTARG   = smoc,
@@ -362,7 +363,7 @@ CREATE OPERATOR !&& (
 CREATE OR REPLACE FUNCTION smoc_not_intersect_spoly(
   a_moc smoc, geo_arg spoly) RETURNS BOOL AS $body$
     SELECT a_moc !&& smoc(max_order(a_moc), geo_arg)
-  $body$ LANGUAGE SQL STABLE;
+  $body$ LANGUAGE SQL STABLE PARALLEL SAFE;
 CREATE OPERATOR !&& (
   LEFTARG    = smoc,
   RIGHTARG   = spoly,
@@ -372,6 +373,3 @@ CREATE OPERATOR !&& (
   RESTRICT   = contsel,
   JOIN       = contjoinsel
 );
-
-
-
diff --git a/pgs_moc_type.sql.in b/pgs_moc_type.sql.in
index 5f2c8fe..c49dad7 100644
--- a/pgs_moc_type.sql.in
+++ b/pgs_moc_type.sql.in
@@ -4,13 +4,13 @@ CREATE FUNCTION smoc_in(cstring)
 	RETURNS smoc
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	IMMUTABLE STRICT;
+	IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE FUNCTION smoc_out(smoc)
 	RETURNS cstring
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	IMMUTABLE STRICT;
+	IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE TYPE smoc (
 	input = smoc_in,
@@ -25,67 +25,67 @@ CREATE FUNCTION moc_debug()
 	RETURNS text
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION set_smoc_output_type(integer)
 	RETURNS cstring
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION max_order(smoc)
 	RETURNS integer
 	AS 'MODULE_PATHNAME', 'smoc_order'
 	LANGUAGE C
-	IMMUTABLE STRICT;
+	IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE FUNCTION healpix_subset_smoc(bigint, smoc)
 	RETURNS bool
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION healpix_not_subset_smoc(bigint, smoc)
 	RETURNS bool
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION smoc_superset_healpix(smoc, bigint)
 	RETURNS bool
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION smoc_not_superset_healpix(smoc, bigint)
 	RETURNS bool
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION spoint_subset_smoc(spoint, smoc)
 	RETURNS bool
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION spoint_not_subset_smoc(spoint, smoc)
 	RETURNS bool
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION smoc_superset_spoint(smoc, spoint)
 	RETURNS bool
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE FUNCTION smoc_not_superset_spoint(smoc, spoint)
 	RETURNS bool
 	AS 'MODULE_PATHNAME'
 	LANGUAGE C
-	STRICT;
+	STRICT PARALLEL SAFE;
 
 CREATE OPERATOR <@ (
    LEFTARG    = bigint,
diff --git a/pgs_path.sql.in b/pgs_path.sql.in
index 36cee2c..94f3222 100644
--- a/pgs_path.sql.in
+++ b/pgs_path.sql.in
@@ -11,7 +11,7 @@ CREATE FUNCTION npoints(spath)
    RETURNS INT4
    AS 'MODULE_PATHNAME', 'spherepath_npts'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  npoints(spath) IS
   'returns number of points of spherical path';
@@ -20,7 +20,7 @@ CREATE FUNCTION spoint(spath, int4)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'spherepath_get_point'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoint(spath, int4) IS
   'returns n-th point of spherical path';
@@ -29,7 +29,7 @@ CREATE FUNCTION spoint(spath, float8)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'spherepath_point'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoint(spath, float8) IS
   'returns n-th point of spherical path using linear interpolation';
@@ -50,7 +50,7 @@ CREATE FUNCTION spath_equal(spath, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_equal'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spath_equal(spath, spath) IS
   'returns true, if spherical paths are equal';
@@ -78,7 +78,7 @@ CREATE FUNCTION spath_equal_neg(spath, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_equal_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spath_equal_neg(spath, spath) IS
   'returns true, if spherical paths are equal';
@@ -106,7 +106,7 @@ CREATE FUNCTION length(spath)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherepath_length'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  length(spath) IS
   'returns length of spherical path';
@@ -130,7 +130,7 @@ CREATE FUNCTION swap(spath)
    RETURNS spath
    AS 'MODULE_PATHNAME', 'spherepath_swap'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION swap(spath) IS
   'returns a swapped spherical path (changed direction)';
@@ -153,7 +153,7 @@ CREATE FUNCTION spath_overlap_path(spath, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_overlap_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spath_overlap_path(spath, spath) IS
   'true if spherical path overlaps spherical path';
@@ -179,7 +179,7 @@ CREATE FUNCTION spath_overlap_path_neg(spath, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_overlap_path_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spath_overlap_path_neg(spath, spath) IS
   'true if spherical path does not overlap spherical path';
@@ -209,7 +209,7 @@ CREATE FUNCTION spath_contains_point(spath, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_cont_point'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spath_contains_point(spath, spoint) IS
   'true if spherical path contains spherical point';
@@ -223,7 +223,7 @@ CREATE FUNCTION spath_contains_point_com(spoint, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_cont_point_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spath_contains_point_com(spoint, spath) IS
   'true if spherical path contains spherical point';
@@ -237,7 +237,7 @@ CREATE FUNCTION spath_contains_point_neg(spath, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_cont_point_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spath_contains_point_neg(spath, spoint) IS
   'true if spherical path does not contain spherical point';
@@ -251,7 +251,7 @@ CREATE FUNCTION spath_contains_point_com_neg(spoint, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_cont_point_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spath_contains_point_com_neg(spoint, spath) IS
   'true if spherical path does not contain spherical point';
@@ -264,7 +264,7 @@ CREATE FUNCTION strans_path(spath, strans)
    RETURNS spath
    AS 'MODULE_PATHNAME', 'spheretrans_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_path (spath, strans) IS
   'returns a transformated spherical path';
@@ -282,7 +282,7 @@ CREATE FUNCTION strans_path_inverse(spath, strans)
    RETURNS spath
    AS 'MODULE_PATHNAME', 'spheretrans_path_inverse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_path_inverse (spath, strans) IS
   'returns a inverse transformated spherical path';
@@ -306,7 +306,7 @@ CREATE FUNCTION scircle_contains_path(scircle, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_path(scircle, spath) IS
   'true if spherical circle contains spherical path';
@@ -320,7 +320,7 @@ CREATE FUNCTION scircle_contains_path_com(spath, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_path_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_path_com(spath, scircle) IS
   'true if spherical circle contains spherical path';
@@ -333,7 +333,7 @@ CREATE FUNCTION scircle_contains_path_neg(scircle, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_path_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_path_neg(scircle, spath) IS
   'true if spherical circle does not contain spherical path';
@@ -347,7 +347,7 @@ CREATE FUNCTION scircle_contains_path_com_neg(spath, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_path_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_path_com_neg(spath, scircle) IS
   'true if spherical circle does not contain spherical path';
@@ -360,7 +360,7 @@ CREATE FUNCTION scircle_overlap_path(scircle, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_overlap_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  scircle_overlap_path(scircle, spath) IS
   'true if spherical circle overlap spherical path';
@@ -388,7 +388,7 @@ CREATE FUNCTION scircle_overlap_path_com(spath, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_overlap_path_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  scircle_overlap_path_com(spath, scircle) IS
   'true if spherical circle overlap spherical path';
@@ -414,7 +414,7 @@ CREATE FUNCTION scircle_overlap_path_neg(scircle, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_overlap_path_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  scircle_overlap_path_neg(scircle, spath) IS
   'true if spherical circle does not overlap spherical path';
@@ -442,7 +442,7 @@ CREATE FUNCTION scircle_overlap_path_com_neg(spath, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_overlap_path_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  scircle_overlap_path_com_neg(spath, scircle) IS
   'true if spherical circle overlap spherical path';
@@ -468,7 +468,7 @@ CREATE FUNCTION spath_overlap_line(spath, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_overlap_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spath_overlap_line(spath, sline) IS
   'true if spherical path overlaps spherical line';
@@ -496,7 +496,7 @@ CREATE FUNCTION spath_overlap_line_com(sline, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_overlap_line_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spath_overlap_line_com(sline, spath) IS
   'true if spherical path overlaps spherical line';
@@ -524,7 +524,7 @@ CREATE FUNCTION spath_overlap_line_neg(spath, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_overlap_line_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spath_overlap_line_neg(spath, sline) IS
   'true if spherical path does not overlap spherical line';
@@ -552,7 +552,7 @@ CREATE FUNCTION spath_overlap_line_com_neg(sline, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepath_overlap_line_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spath_overlap_line_com_neg(sline, spath) IS
   'true if spherical path does not overlap spherical line';
@@ -580,7 +580,7 @@ CREATE FUNCTION sellipse_contains_path(sellipse, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_path(sellipse, spath) IS
   'true if spherical ellipse contains spherical path';
@@ -594,7 +594,7 @@ CREATE FUNCTION sellipse_contains_path_com(spath, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_path_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_path_com(spath, sellipse) IS
   'true if spherical ellipse contains spherical path';
@@ -607,7 +607,7 @@ CREATE FUNCTION sellipse_contains_path_neg(sellipse, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_path_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_path_neg(sellipse, spath) IS
   'true if spherical ellipse does not contain spherical path';
@@ -621,7 +621,7 @@ CREATE FUNCTION sellipse_contains_path_com_neg(spath, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_path_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_path_com_neg(spath, sellipse) IS
   'true if spherical ellipse does not contain spherical path';
@@ -634,7 +634,7 @@ CREATE FUNCTION sellipse_overlap_path(sellipse, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sellipse_overlap_path(sellipse, spath) IS
   'true if spherical ellipse overlap spherical path';
@@ -662,7 +662,7 @@ CREATE FUNCTION sellipse_overlap_path_com(spath, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_path_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sellipse_overlap_path_com(spath, sellipse) IS
   'true if spherical ellipse overlap spherical path';
@@ -688,7 +688,7 @@ CREATE FUNCTION sellipse_overlap_path_neg(sellipse, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_path_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sellipse_overlap_path_neg(sellipse, spath) IS
   'true if spherical ellipse does not overlap spherical path';
@@ -716,7 +716,7 @@ CREATE FUNCTION sellipse_overlap_path_com_neg(spath, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_overlap_path_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  sellipse_overlap_path_com_neg(spath, sellipse) IS
   'true if spherical ellipse overlap spherical path';
@@ -743,7 +743,7 @@ CREATE FUNCTION spoly_contains_path(spoly, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_path(spoly, spath) IS
   'true if spherical polygon contains spherical path';
@@ -757,7 +757,7 @@ CREATE FUNCTION spoly_contains_path_com(spath, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_path_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_path_com(spath, spoly) IS
   'true if spherical polygon contains spherical path';
@@ -770,7 +770,7 @@ CREATE FUNCTION spoly_contains_path_neg(spoly, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_path_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_path_neg(spoly, spath) IS
   'true if spherical polygon does not contain spherical path';
@@ -784,7 +784,7 @@ CREATE FUNCTION spoly_contains_path_com_neg(spath, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_path_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_path_com_neg(spath, spoly) IS
   'true if spherical polygon does not contain spherical path';
@@ -797,7 +797,7 @@ CREATE FUNCTION spoly_overlap_path(spoly, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_path'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_path(spoly, spath) IS
   'true if spherical polygon overlap spherical path';
@@ -825,7 +825,7 @@ CREATE FUNCTION spoly_overlap_path_com(spath, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_path_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_path_com(spath, spoly) IS
   'true if spherical polygon overlap spherical path';
@@ -851,7 +851,7 @@ CREATE FUNCTION spoly_overlap_path_neg(spoly, spath)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_path_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_path_neg(spoly, spath) IS
   'true if spherical polygon does not overlap spherical path';
@@ -879,7 +879,7 @@ CREATE FUNCTION spoly_overlap_path_com_neg(spath, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_path_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_path_com_neg(spath, spoly) IS
   'true if spherical polygon overlap spherical path';
@@ -907,7 +907,7 @@ CREATE FUNCTION spath_add_point_aggr (spath, spoint)
   RETURNS spath
   AS 'MODULE_PATHNAME', 'spherepath_add_point'
   LANGUAGE 'c'
-  IMMUTABLE;
+  IMMUTABLE PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spath_add_point_aggr (spath, spoint) IS
   'adds a spherical point to spherical path. Do not use it standalone!';
@@ -916,7 +916,7 @@ CREATE FUNCTION spath_add_points_fin_aggr (spath)
   RETURNS spath
   AS 'MODULE_PATHNAME', 'spherepath_add_points_finalize'
   LANGUAGE 'c'
-  IMMUTABLE STRICT ;
+  IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spath_add_points_fin_aggr (spath) IS
   'Finalize spherical point adding to spherical path. Do not use it standalone!';
diff --git a/pgs_point.sql.in b/pgs_point.sql.in
index c946c5b..a9afb84 100644
--- a/pgs_point.sql.in
+++ b/pgs_point.sql.in
@@ -13,7 +13,7 @@ CREATE FUNCTION spoint(FLOAT8, FLOAT8)
    RETURNS spoint
    AS 'MODULE_PATHNAME', 'spherepoint_from_long_lat'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE FUNCTION set_sphere_output_precision(INT4)
    RETURNS CSTRING
@@ -32,7 +32,7 @@ CREATE FUNCTION long(spoint)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherepoint_long'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION long(spoint) IS
   'longitude of spherical point';
@@ -41,7 +41,7 @@ CREATE FUNCTION lat(spoint)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherepoint_lat'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION lat(spoint) IS
   'latitude of spherical point';
@@ -50,7 +50,7 @@ CREATE FUNCTION x(spoint)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherepoint_x'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION x(spoint) IS
   'cartesian x value of spherical point';
@@ -60,7 +60,7 @@ CREATE FUNCTION y(spoint)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherepoint_y'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION y(spoint) IS
   'cartesian y value of spherical point';
@@ -69,7 +69,7 @@ CREATE FUNCTION xyz(spoint)
    RETURNS FLOAT8[]
    AS 'MODULE_PATHNAME', 'spherepoint_xyz'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION xyz(spoint) IS
   'cartesian values of spherical point';
@@ -79,7 +79,7 @@ CREATE FUNCTION z(spoint)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherepoint_z'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION z(spoint) IS
   'cartesian z value of spherical point';
@@ -99,7 +99,7 @@ CREATE FUNCTION spoint_equal(spoint, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoint_equal'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoint_equal(spoint, spoint) IS
   'returns true, if spherical points are equal';
@@ -125,7 +125,7 @@ CREATE FUNCTION spoint_equal_neg (spoint, spoint)
    RETURNS BOOL
    AS 'SELECT NOT spoint_equal($1,$2);'
    LANGUAGE 'sql'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoint_equal_neg (spoint, spoint) IS
   'returns true, if spherical points are not equal';
@@ -152,7 +152,7 @@ CREATE FUNCTION dist(spoint, spoint)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherepoint_distance'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION dist(spoint, spoint) IS
   'distance between spherical points';
diff --git a/pgs_polygon.sql.in b/pgs_polygon.sql.in
index b9e68c4..701c860 100644
--- a/pgs_polygon.sql.in
+++ b/pgs_polygon.sql.in
@@ -6,7 +6,7 @@ CREATE FUNCTION npoints(spoly)
    RETURNS INT4
    AS 'MODULE_PATHNAME', 'spherepoly_npts'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  npoints(spoly) IS
   'returns number of points of spherical polygon';
@@ -15,7 +15,7 @@ CREATE FUNCTION area(spoly)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherepoly_area'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  area(spoly) IS
   'returns area of spherical polygon';
@@ -37,7 +37,7 @@ CREATE FUNCTION spoly_equal(spoly, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_equal'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_equal(spoly, spoly) IS
   'returns true, if spherical polygons are equal';
@@ -64,7 +64,7 @@ CREATE FUNCTION spoly_not_equal(spoly, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_equal_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_not_equal(spoly, spoly) IS
   'returns true, if spherical polygons are not equal';
@@ -90,7 +90,7 @@ CREATE FUNCTION circum(spoly)
    RETURNS FLOAT8
    AS 'MODULE_PATHNAME', 'spherepoly_circ'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  circum(spoly) IS
   'returns circumference of spherical polygon';
@@ -112,7 +112,7 @@ CREATE FUNCTION spoly_contains_polygon(spoly, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_poly'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_polygon(spoly, spoly) IS
   'true if spherical polygon contains spherical polygon';
@@ -126,7 +126,7 @@ CREATE FUNCTION spoly_contains_polygon_com(spoly, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_poly_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_polygon_com(spoly, spoly) IS
   'true if spherical polygon is contained by spherical polygon';
@@ -140,7 +140,7 @@ CREATE FUNCTION spoly_contains_polygon_neg(spoly, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_poly_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_polygon_neg(spoly, spoly) IS
   'true if spherical polygon does not contain spherical polygon';
@@ -154,7 +154,7 @@ CREATE FUNCTION spoly_contains_polygon_com_neg(spoly, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_poly_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_polygon_com_neg(spoly, spoly) IS
   'true if spherical polygon is not contained by spherical polygon';
@@ -168,7 +168,7 @@ CREATE FUNCTION spoly_overlap_polygon(spoly, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_poly'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_polygon(spoly, spoly) IS
   'true if spherical polygon overlaps spherical polygon';
@@ -195,7 +195,7 @@ CREATE FUNCTION spoly_overlap_polygon_neg(spoly, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_poly_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_polygon_neg(spoly, spoly) IS
   'true if spherical polygon does not overlap spherical polygon';
@@ -223,7 +223,7 @@ CREATE FUNCTION spoly_contains_point(spoly, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_point'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_point(spoly, spoint) IS
   'true if spherical polygon contains spherical point';
@@ -236,7 +236,7 @@ CREATE FUNCTION spoly_contains_point_com(spoint, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_point_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_point_com(spoint, spoly) IS
   'true if spherical polygon contains spherical point';
@@ -249,7 +249,7 @@ CREATE FUNCTION spoly_contains_point_neg(spoly, spoint)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_point_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_point_neg(spoly, spoint) IS
   'true if spherical polygon does not contain spherical point';
@@ -262,7 +262,7 @@ CREATE FUNCTION spoly_contains_point_com_neg(spoint, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_point_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_point_com_neg(spoint, spoly) IS
   'true if spherical polygon does not contain spherical point';
@@ -275,7 +275,7 @@ CREATE FUNCTION strans_poly(spoly, strans)
    RETURNS spoly
    AS 'MODULE_PATHNAME', 'spheretrans_poly'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_poly (spoly, strans) IS
   'returns a transformated spherical polygon';
@@ -293,7 +293,7 @@ CREATE FUNCTION strans_poly_inverse(spoly, strans)
    RETURNS spoly
    AS 'MODULE_PATHNAME', 'spheretrans_poly_inverse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION strans_poly_inverse (spoly, strans) IS
   'returns a inverse transformated spherical polygon';
@@ -316,7 +316,7 @@ CREATE FUNCTION spoly_contains_circle(spoly, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_circle(spoly, scircle) IS
   'true if spherical polygon contains spherical circle';
@@ -330,7 +330,7 @@ CREATE FUNCTION spoly_contains_circle_com(scircle, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_circle_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_circle_com(scircle, spoly) IS
   'true if spherical polygon contains spherical circle';
@@ -344,7 +344,7 @@ CREATE FUNCTION spoly_contains_circle_neg(spoly, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_circle_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_circle_neg(spoly, scircle) IS
   'true if spherical polygon does not contain spherical circle';
@@ -358,7 +358,7 @@ CREATE FUNCTION spoly_contains_circle_com_neg(scircle, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_circle_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_circle_com_neg(scircle, spoly) IS
   'true if spherical polygon does not contain spherical circle';
@@ -372,7 +372,7 @@ CREATE FUNCTION scircle_contains_polygon(scircle, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_poly'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_polygon(scircle, spoly) IS
   'true if spherical circle contains spherical polygon';
@@ -386,7 +386,7 @@ CREATE FUNCTION scircle_contains_polygon_com(spoly, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_poly_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_polygon_com(spoly, scircle) IS
   'true if spherical circle contains spherical polygon';
@@ -400,7 +400,7 @@ CREATE FUNCTION scircle_contains_polygon_neg(scircle, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_poly_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_polygon_neg(scircle, spoly) IS
   'true if spherical circle does not contain spherical polygon';
@@ -414,7 +414,7 @@ CREATE FUNCTION scircle_contains_polygon_com_neg(spoly, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherecircle_cont_poly_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION scircle_contains_polygon_com_neg(spoly, scircle) IS
   'true if spherical circle does not contain spherical polygon';
@@ -428,7 +428,7 @@ CREATE FUNCTION spoly_overlap_circle(spoly, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_circle'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_overlap_circle(spoly, scircle) IS
   'true if spherical circle overlap spherical polygon';
@@ -455,7 +455,7 @@ CREATE FUNCTION spoly_overlap_circle_com(scircle, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_circle_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_circle_com(scircle, spoly) IS
   'true if spherical circle overlap spherical polygon';
@@ -483,7 +483,7 @@ CREATE FUNCTION spoly_overlap_circle_neg(spoly, scircle)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_circle_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_circle_neg(spoly, scircle) IS
   'true if spherical circle does not overlap spherical polygon';
@@ -510,7 +510,7 @@ CREATE FUNCTION spoly_overlap_circle_com_neg(scircle, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_circle_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_circle_com_neg(scircle, spoly) IS
   'true if spherical circle does not overlap spherical polygon';
@@ -538,7 +538,7 @@ CREATE FUNCTION spoly_contains_line(spoly, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_line(spoly, sline) IS
   'true if spherical polygon contains spherical line';
@@ -551,7 +551,7 @@ CREATE FUNCTION spoly_contains_line_com(sline, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_line_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_line_com(sline, spoly) IS
   'true if spherical polygon contains spherical line';
@@ -564,7 +564,7 @@ CREATE FUNCTION spoly_contains_line_neg(spoly, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_line_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_line_neg(spoly, sline) IS
   'true if spherical polygon does not contain spherical line';
@@ -577,7 +577,7 @@ CREATE FUNCTION spoly_contains_line_com_neg(sline, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_line_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_line_com_neg(sline, spoly) IS
   'true if spherical polygon does not contain spherical line';
@@ -590,7 +590,7 @@ CREATE FUNCTION spoly_overlap_line(spoly, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_line'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_overlap_line(spoly, sline) IS
   'true if spherical line overlap spherical polygon';
@@ -617,7 +617,7 @@ CREATE FUNCTION spoly_overlap_line_com(sline, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_line_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_line_com(sline, spoly) IS
   'true if spherical line overlap spherical polygon';
@@ -645,7 +645,7 @@ CREATE FUNCTION spoly_overlap_line_neg(spoly, sline)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_line_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_line_neg(spoly, sline) IS
   'true if spherical line does not overlap spherical polygon';
@@ -672,7 +672,7 @@ CREATE FUNCTION spoly_overlap_line_com_neg(sline, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_line_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_line_com_neg(sline, spoly) IS
   'true if spherical line does not overlap spherical polygon';
@@ -701,7 +701,7 @@ CREATE FUNCTION spoly_contains_ellipse(spoly, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_ellipse(spoly, sellipse) IS
   'true if spherical polygon contains spherical ellipse';
@@ -715,7 +715,7 @@ CREATE FUNCTION spoly_contains_ellipse_com(sellipse, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_ellipse_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_ellipse_com(sellipse, spoly) IS
   'true if spherical polygon contains spherical ellipse';
@@ -729,7 +729,7 @@ CREATE FUNCTION spoly_contains_ellipse_neg(spoly, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_ellipse_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_ellipse_neg(spoly, sellipse) IS
   'true if spherical polygon does not contain spherical ellipse';
@@ -743,7 +743,7 @@ CREATE FUNCTION spoly_contains_ellipse_com_neg(sellipse, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_cont_ellipse_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_contains_ellipse_com_neg(sellipse, spoly) IS
   'true if spherical polygon does not contain spherical ellipse';
@@ -757,7 +757,7 @@ CREATE FUNCTION sellipse_contains_polygon(sellipse, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_poly'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_polygon(sellipse, spoly) IS
   'true if spherical ellipse contains spherical polygon';
@@ -771,7 +771,7 @@ CREATE FUNCTION sellipse_contains_polygon_com(spoly, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_poly_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_polygon_com(spoly, sellipse) IS
   'true if spherical ellipse contains spherical polygon';
@@ -785,7 +785,7 @@ CREATE FUNCTION sellipse_contains_polygon_neg(sellipse, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_poly_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_polygon_neg(sellipse, spoly) IS
   'true if spherical ellipse does not contain spherical polygon';
@@ -799,7 +799,7 @@ CREATE FUNCTION sellipse_contains_polygon_com_neg(spoly, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'sphereellipse_cont_poly_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION sellipse_contains_polygon_com_neg(spoly, sellipse) IS
   'true if spherical ellipse does not contain spherical polygon';
@@ -813,7 +813,7 @@ CREATE FUNCTION spoly_overlap_ellipse(spoly, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_ellipse'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION spoly_overlap_ellipse(spoly, sellipse) IS
   'true if spherical ellipse overlap spherical polygon';
@@ -840,7 +840,7 @@ CREATE FUNCTION spoly_overlap_ellipse_com(sellipse, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_ellipse_com'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_ellipse_com(sellipse, spoly) IS
   'true if spherical ellipse overlap spherical polygon';
@@ -868,7 +868,7 @@ CREATE FUNCTION spoly_overlap_ellipse_neg(spoly, sellipse)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_ellipse_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_ellipse_neg(spoly, sellipse) IS
   'true if spherical ellipse does not overlap spherical polygon';
@@ -895,7 +895,7 @@ CREATE FUNCTION spoly_overlap_ellipse_com_neg(sellipse, spoly)
    RETURNS BOOL
    AS 'MODULE_PATHNAME', 'spherepoly_overlap_ellipse_com_neg'
    LANGUAGE 'c'
-   IMMUTABLE STRICT;
+   IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_overlap_ellipse_com_neg(sellipse, spoly) IS
   'true if spherical ellipse does not overlap spherical polygon';
@@ -923,7 +923,7 @@ CREATE FUNCTION spoly_add_point_aggr (spoly, spoint)
   RETURNS spoly
   AS 'MODULE_PATHNAME', 'spherepoly_add_point'
   LANGUAGE 'c'
-  IMMUTABLE;
+  IMMUTABLE PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_add_point_aggr (spoly, spoint) IS
   'adds a spherical point to spherical polygon. Do not use it standalone!';
@@ -932,7 +932,7 @@ CREATE FUNCTION spoly_add_points_fin_aggr (spoly)
   RETURNS spoly
   AS 'MODULE_PATHNAME', 'spherepoly_add_points_finalize'
   LANGUAGE 'c'
-  IMMUTABLE STRICT ;
+  IMMUTABLE STRICT PARALLEL SAFE;
 
 COMMENT ON FUNCTION  spoly_add_points_fin_aggr (spoly) IS
   'Finalize spherical point adding to spherical polygon. Do not use it standalone!';
diff --git a/pgs_types.sql.in b/pgs_types.sql.in
index 15aeb39..e0ff8f3 100644
--- a/pgs_types.sql.in
+++ b/pgs_types.sql.in
@@ -190,4 +190,3 @@ CREATE TYPE sbox (
    input   = sbox_in,
    output  = sbox_out
 );
-
diff --git a/upgrade_scripts/pg_sphere--1.2.1--1.2.2.sql.in b/upgrade_scripts/pg_sphere--1.2.1--1.2.2.sql.in
new file mode 100644
index 0000000..ad2dfca
--- /dev/null
+++ b/upgrade_scripts/pg_sphere--1.2.1--1.2.2.sql.in
@@ -0,0 +1,347 @@
+-- gnomo
+ALTER FUNCTION gnomonic_proj(spoint, spoint) PARALLEL SAFE;
+ALTER FUNCTION gnomonic_inv(point, spoint) PARALLEL SAFE;
+
+-- healpix
+ALTER FUNCTION nest2ring(integer, bigint) PARALLEL SAFE;
+ALTER FUNCTION ring2nest(integer, bigint) PARALLEL SAFE;
+ALTER FUNCTION healpix_convert_nest(integer, integer, bigint) PARALLEL SAFE;
+ALTER FUNCTION healpix_convert_ring(integer, integer, bigint) PARALLEL SAFE;
+ALTER FUNCTION nside2order(bigint) PARALLEL SAFE;
+ALTER FUNCTION order2nside(integer) PARALLEL SAFE;
+ALTER FUNCTION nside2npix(bigint) PARALLEL SAFE;
+ALTER FUNCTION npix2nside(bigint) PARALLEL SAFE;
+ALTER FUNCTION healpix_nest(integer, spoint) PARALLEL SAFE;
+ALTER FUNCTION healpix_ring(integer, spoint) PARALLEL SAFE;
+ALTER FUNCTION centre_of_healpix_nest(integer, bigint) PARALLEL SAFE;
+ALTER FUNCTION centre_of_healpix_ring(integer, bigint) PARALLEL SAFE;
+ALTER FUNCTION center_of_healpix_nest(integer, bigint) PARALLEL SAFE;
+ALTER FUNCTION center_of_healpix_ring(integer, bigint) PARALLEL SAFE;
+
+-- sbox
+ALTER FUNCTION sbox(spoint, spoint) PARALLEL SAFE;
+ALTER FUNCTION sw(sbox) PARALLEL SAFE;
+ALTER FUNCTION se(sbox) PARALLEL SAFE;
+ALTER FUNCTION nw(sbox) PARALLEL SAFE;
+ALTER FUNCTION ne(sbox) PARALLEL SAFE;
+ALTER FUNCTION area(sbox) PARALLEL SAFE;
+ALTER FUNCTION circum(sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_equal(sbox, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_equal_neg(sbox, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_box(sbox, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_box_com(sbox, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_box_neg(sbox, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_box_com_neg(sbox, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_box(sbox, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_box_neg(sbox, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_cont_point_com(spoint, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_cont_point_com_neg(spoint, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_cont_point(sbox, spoint) PARALLEL SAFE;
+ALTER FUNCTION sbox_cont_point_neg(sbox, spoint) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_circle(sbox, scircle) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_circle_com(scircle, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_circle_neg(sbox, scircle) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_circle_com_neg(scircle, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_circle(sbox, scircle) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_circle_com(scircle, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_circle_neg(sbox, scircle) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_circle_com_neg(scircle, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_line(sbox, sline) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_line_com(sline, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_line_neg(sbox, sline) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_line_com_neg(sline, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_line(sbox, sline) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_line_com(sline, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_line_neg(sbox, sline) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_line_com_neg(sline, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_ellipse(sbox, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_ellipse_com(sellipse, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_ellipse_neg(sbox, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_ellipse_com_neg(sellipse, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_ellipse(sbox, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_ellipse_com(sellipse, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_ellipse_neg(sbox, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_ellipse_com_neg(sellipse, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_poly(sbox, spoly) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_poly_com(spoly, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_poly_neg(sbox, spoly) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_poly_com_neg(spoly, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_poly(sbox, spoly) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_poly_com(spoly, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_poly_neg(sbox, spoly) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_poly_com_neg(spoly, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_path(sbox, spath) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_path_com(spath, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_path_neg(sbox, spath) PARALLEL SAFE;
+ALTER FUNCTION sbox_contains_path_com_neg(spath, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_path(sbox, spath) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_path_com(spath, sbox) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_path_neg(sbox, spath) PARALLEL SAFE;
+ALTER FUNCTION sbox_overlap_path_com_neg(spath, sbox) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_box(scircle, sbox) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_box_com(sbox, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_box_neg(scircle, sbox) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_box_com_neg(sbox, scircle) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_box(sellipse, sbox) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_box_com(sbox, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_box_neg(sellipse, sbox) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_box_com_neg(sbox, sellipse) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_box(spoly, sbox) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_box_com(sbox, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_box_neg(spoly, sbox) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_box_com_neg(sbox, spoly) PARALLEL SAFE;
+
+-- scircle
+ALTER FUNCTION area(scircle) PARALLEL SAFE;
+ALTER FUNCTION radius(scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle(spoint, float8) PARALLEL SAFE;
+ALTER FUNCTION scircle(spoint) PARALLEL SAFE;
+ALTER FUNCTION scircle_equal(scircle, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_equal_neg(scircle, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_overlap(scircle, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_overlap_neg(scircle, scircle) PARALLEL SAFE;
+ALTER FUNCTION center(scircle) PARALLEL SAFE;
+ALTER FUNCTION circum(scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_contained_by_circle(scircle, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_contained_by_circle_neg(scircle, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_circle(scircle, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_circle_neg(scircle, scircle) PARALLEL SAFE;
+ALTER FUNCTION spoint_contained_by_circle(spoint, scircle) PARALLEL SAFE;
+ALTER FUNCTION spoint_contained_by_circle_neg(spoint, scircle) PARALLEL SAFE;
+ALTER FUNCTION spoint_contained_by_circle_com(scircle, spoint) PARALLEL SAFE;
+ALTER FUNCTION spoint_contained_by_circle_com_neg(scircle, spoint) PARALLEL SAFE;
+ALTER FUNCTION dist(scircle, scircle) PARALLEL SAFE;
+ALTER FUNCTION dist(scircle, spoint) PARALLEL SAFE;
+ALTER FUNCTION dist(spoint, scircle) PARALLEL SAFE;
+ALTER FUNCTION strans_circle(scircle, strans) PARALLEL SAFE;
+ALTER FUNCTION strans_circle_inverse(scircle, strans) PARALLEL SAFE;
+
+-- sellipse 
+ALTER FUNCTION sellipse(spoint, float8, float8, float8) PARALLEL SAFE;
+ALTER FUNCTION inc(sellipse) PARALLEL SAFE;
+ALTER FUNCTION lrad(sellipse) PARALLEL SAFE;
+ALTER FUNCTION srad(sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse(spoint) PARALLEL SAFE;
+ALTER FUNCTION scircle(sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse(scircle) PARALLEL SAFE;
+ALTER FUNCTION strans(sellipse) PARALLEL SAFE;
+ALTER FUNCTION center(sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_equal(sellipse, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_equal_neg(sellipse, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_ellipse(sellipse, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_ellipse_com(sellipse, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_ellipse_neg(sellipse, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_ellipse_com_neg(sellipse, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_ellipse(sellipse, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_ellipse_neg(sellipse, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_point(sellipse, spoint) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_point_com(spoint, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_point_neg(sellipse, spoint) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_point_com_neg(spoint, sellipse) PARALLEL SAFE;
+ALTER FUNCTION strans_ellipse(sellipse, strans) PARALLEL SAFE;
+ALTER FUNCTION strans_ellipse_inverse(sellipse, strans) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_circle(sellipse, scircle) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_circle_com(scircle, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_circle_neg(sellipse, scircle) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_circle_com_neg(scircle, sellipse) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_ellipse(scircle, sellipse) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_ellipse_com(sellipse, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_ellipse_neg(scircle, sellipse) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_ellipse_com_neg(sellipse, scircle) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_circle(sellipse, scircle) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_circle_com(scircle, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_circle_neg(sellipse, scircle) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_circle_com_neg(scircle, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_line(sellipse, sline) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_line_com(sline, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_line_neg(sellipse, sline) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_line_com_neg(sline, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_line(sellipse, sline) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_line_com(sline, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_line_neg(sellipse, sline) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_line_com_neg(sline, sellipse) PARALLEL SAFE;
+
+-- euler
+ALTER FUNCTION strans_zxz(strans) PARALLEL SAFE;
+ALTER FUNCTION strans(FLOAT8, FLOAT8, FLOAT8) PARALLEL SAFE;
+ALTER FUNCTION strans(FLOAT8, FLOAT8, FLOAT8, CSTRING) PARALLEL SAFE;
+ALTER FUNCTION phi(strans) PARALLEL SAFE;
+ALTER FUNCTION theta(strans) PARALLEL SAFE;
+ALTER FUNCTION psi(strans) PARALLEL SAFE;
+ALTER FUNCTION axes(strans) PARALLEL SAFE;
+ALTER FUNCTION strans_equal(strans, strans) PARALLEL SAFE;
+ALTER FUNCTION strans_not_equal(strans, strans) PARALLEL SAFE;
+ALTER FUNCTION strans(strans) PARALLEL SAFE;
+ALTER FUNCTION strans_invert(strans) PARALLEL SAFE;
+ALTER FUNCTION strans_point(spoint, strans) PARALLEL SAFE;
+ALTER FUNCTION strans_point_inverse(spoint, strans) PARALLEL SAFE;
+ALTER FUNCTION strans_trans(strans, strans) PARALLEL SAFE;
+ALTER FUNCTION strans_trans_inv(strans, strans) PARALLEL SAFE;
+
+-- gist
+ALTER FUNCTION pointkey_volume(pointkey) PARALLEL SAFE;
+ALTER FUNCTION pointkey_area(pointkey) PARALLEL SAFE;
+ALTER FUNCTION pointkey_perimeter(pointkey) PARALLEL SAFE;
+
+-- sline 
+ALTER FUNCTION sline(spoint, spoint) PARALLEL SAFE;
+ALTER FUNCTION sline(strans, float8) PARALLEL SAFE;
+ALTER FUNCTION meridian(float8) PARALLEL SAFE;
+ALTER FUNCTION sl_beg(sline) PARALLEL SAFE;
+ALTER FUNCTION sl_end(sline) PARALLEL SAFE;
+ALTER FUNCTION strans(sline) PARALLEL SAFE;
+ALTER FUNCTION sline(spoint) PARALLEL SAFE;
+ALTER FUNCTION sline_equal(sline, sline) PARALLEL SAFE;
+ALTER FUNCTION sline_equal_neg(sline, sline) PARALLEL SAFE;
+ALTER FUNCTION length(sline) PARALLEL SAFE;
+ALTER FUNCTION swap(sline) PARALLEL SAFE;
+ALTER FUNCTION turn(sline) PARALLEL SAFE;
+ALTER FUNCTION sline_crosses(sline, sline) PARALLEL SAFE;
+ALTER FUNCTION sline_crosses_neg(sline, sline) PARALLEL SAFE;
+ALTER FUNCTION sline_overlap(sline, sline) PARALLEL SAFE;
+ALTER FUNCTION sline_overlap_neg(sline, sline) PARALLEL SAFE;
+ALTER FUNCTION sline_contains_point(sline, spoint) PARALLEL SAFE;
+ALTER FUNCTION sline_contains_point_com(spoint, sline) PARALLEL SAFE;
+ALTER FUNCTION sline_contains_point_neg(sline, spoint) PARALLEL SAFE;
+ALTER FUNCTION sline_contains_point_com_neg(spoint, sline) PARALLEL SAFE;
+ALTER FUNCTION strans_line(sline, strans) PARALLEL SAFE;
+ALTER FUNCTION strans_line_inverse(sline, strans) PARALLEL SAFE;
+ALTER FUNCTION sline_overlap_circle(sline, scircle) PARALLEL SAFE;
+ALTER FUNCTION sline_overlap_circle_com(scircle, sline) PARALLEL SAFE;
+ALTER FUNCTION sline_overlap_circle_neg(sline, scircle) PARALLEL SAFE;
+ALTER FUNCTION sline_overlap_circle_com_neg(scircle, sline) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_line(scircle, sline) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_line_com(sline, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_line_neg(scircle, sline) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_line_com_neg(sline, scircle) PARALLEL SAFE;
+
+-- moc_type
+ALTER FUNCTION smoc_in(cstring) PARALLEL SAFE;
+ALTER FUNCTION smoc_out(smoc) PARALLEL SAFE;
+ALTER FUNCTION moc_debug() PARALLEL SAFE;
+ALTER FUNCTION set_smoc_output_type(integer) PARALLEL SAFE;
+ALTER FUNCTION max_order(smoc) PARALLEL SAFE;
+ALTER FUNCTION healpix_subset_smoc(bigint, smoc) PARALLEL SAFE;
+ALTER FUNCTION healpix_not_subset_smoc(bigint, smoc) PARALLEL SAFE;
+ALTER FUNCTION smoc_superset_healpix(smoc, bigint) PARALLEL SAFE;
+ALTER FUNCTION smoc_not_superset_healpix(smoc, bigint) PARALLEL SAFE;
+ALTER FUNCTION spoint_subset_smoc(spoint, smoc) PARALLEL SAFE;
+ALTER FUNCTION spoint_not_subset_smoc(spoint, smoc) PARALLEL SAFE;
+ALTER FUNCTION smoc_superset_spoint(smoc, spoint) PARALLEL SAFE;
+ALTER FUNCTION smoc_not_superset_spoint(smoc, spoint) PARALLEL SAFE;
+
+-- spath
+ALTER FUNCTION npoints(spath) PARALLEL SAFE;
+ALTER FUNCTION spoint(spath, int4) PARALLEL SAFE;
+ALTER FUNCTION spoint(spath, float8) PARALLEL SAFE;
+ALTER FUNCTION spath_equal(spath, spath) PARALLEL SAFE;
+ALTER FUNCTION spath_equal_neg(spath, spath) PARALLEL SAFE;
+ALTER FUNCTION length(spath) PARALLEL SAFE;
+ALTER FUNCTION swap(spath) PARALLEL SAFE;
+ALTER FUNCTION spath_overlap_path(spath, spath) PARALLEL SAFE;
+ALTER FUNCTION spath_overlap_path_neg(spath, spath) PARALLEL SAFE;
+ALTER FUNCTION spath_contains_point(spath, spoint) PARALLEL SAFE;
+ALTER FUNCTION spath_contains_point_com(spoint, spath) PARALLEL SAFE;
+ALTER FUNCTION spath_contains_point_neg(spath, spoint) PARALLEL SAFE;
+ALTER FUNCTION spath_contains_point_com_neg(spoint, spath) PARALLEL SAFE;
+ALTER FUNCTION strans_path(spath, strans) PARALLEL SAFE;
+ALTER FUNCTION strans_path_inverse(spath, strans) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_path(scircle, spath) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_path_com(spath, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_path_neg(scircle, spath) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_path_com_neg(spath, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_overlap_path(scircle, spath) PARALLEL SAFE;
+ALTER FUNCTION scircle_overlap_path_com(spath, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_overlap_path_neg(scircle, spath) PARALLEL SAFE;
+ALTER FUNCTION scircle_overlap_path_com_neg(spath, scircle) PARALLEL SAFE;
+ALTER FUNCTION spath_overlap_line(spath, sline) PARALLEL SAFE;
+ALTER FUNCTION spath_overlap_line_com(sline, spath) PARALLEL SAFE;
+ALTER FUNCTION spath_overlap_line_neg(spath, sline) PARALLEL SAFE;
+ALTER FUNCTION spath_overlap_line_com_neg(sline, spath) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_path(sellipse, spath) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_path_com(spath, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_path_neg(sellipse, spath) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_path_com_neg(spath, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_path(sellipse, spath) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_path_com(spath, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_path_neg(sellipse, spath) PARALLEL SAFE;
+ALTER FUNCTION sellipse_overlap_path_com_neg(spath, sellipse) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_path(spoly, spath) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_path_com(spath, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_path_neg(spoly, spath) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_path_com_neg(spath, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_path(spoly, spath) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_path_com(spath, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_path_neg(spoly, spath) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_path_com_neg(spath, spoly) PARALLEL SAFE;
+ALTER FUNCTION spath_add_point_aggr(spath, spoint) PARALLEL SAFE;
+ALTER FUNCTION spath_add_points_fin_aggr(spath) PARALLEL SAFE;
+
+-- spoint
+ALTER FUNCTION spoint(FLOAT8, FLOAT8) PARALLEL SAFE;
+ALTER FUNCTION long(spoint) PARALLEL SAFE;
+ALTER FUNCTION lat(spoint) PARALLEL SAFE;
+ALTER FUNCTION x(spoint) PARALLEL SAFE;
+ALTER FUNCTION y(spoint) PARALLEL SAFE;
+ALTER FUNCTION xyz(spoint) PARALLEL SAFE;
+ALTER FUNCTION z(spoint) PARALLEL SAFE;
+ALTER FUNCTION spoint_equal(spoint, spoint) PARALLEL SAFE;
+ALTER FUNCTION spoint_equal_neg(spoint, spoint) PARALLEL SAFE;
+ALTER FUNCTION dist(spoint, spoint) PARALLEL SAFE;
+
+-- spoly
+ALTER FUNCTION npoints(spoly) PARALLEL SAFE;
+ALTER FUNCTION area(spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_equal(spoly, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_not_equal(spoly, spoly) PARALLEL SAFE;
+ALTER FUNCTION circum(spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_polygon(spoly, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_polygon_com(spoly, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_polygon_neg(spoly, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_polygon_com_neg(spoly, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_polygon(spoly, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_polygon_neg(spoly, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_point(spoly, spoint) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_point_com(spoint, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_point_neg(spoly, spoint) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_point_com_neg(spoint, spoly) PARALLEL SAFE;
+ALTER FUNCTION strans_poly(spoly, strans) PARALLEL SAFE;
+ALTER FUNCTION strans_poly_inverse(spoly, strans) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_circle(spoly, scircle) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_circle_com(scircle, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_circle_neg(spoly, scircle) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_circle_com_neg(scircle, spoly) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_polygon(scircle, spoly) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_polygon_com(spoly, scircle) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_polygon_neg(scircle, spoly) PARALLEL SAFE;
+ALTER FUNCTION scircle_contains_polygon_com_neg(spoly, scircle) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_circle(spoly, scircle) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_circle_com(scircle, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_circle_neg(spoly, scircle) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_circle_com_neg(scircle, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_line(spoly, sline) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_line_com(sline, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_line_neg(spoly, sline) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_line_com_neg(sline, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_line(spoly, sline) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_line_com(sline, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_line_neg(spoly, sline) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_line_com_neg(sline, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_ellipse(spoly, sellipse) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_ellipse_com(sellipse, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_ellipse_neg(spoly, sellipse) PARALLEL SAFE;
+ALTER FUNCTION spoly_contains_ellipse_com_neg(sellipse, spoly) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_polygon(sellipse, spoly) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_polygon_com(spoly, sellipse) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_polygon_neg(sellipse, spoly) PARALLEL SAFE;
+ALTER FUNCTION sellipse_contains_polygon_com_neg(spoly, sellipse) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_ellipse(spoly, sellipse) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_ellipse_com(sellipse, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_ellipse_neg(spoly, sellipse) PARALLEL SAFE;
+ALTER FUNCTION spoly_overlap_ellipse_com_neg(sellipse, spoly) PARALLEL SAFE;
+ALTER FUNCTION spoly_add_point_aggr(spoly, spoint) PARALLEL SAFE;
+ALTER FUNCTION spoly_add_points_fin_aggr(spoly) PARALLEL SAFE;
+
+-- gist_spoint3
+ALTER FUNCTION g_spoint3_penalty(internal, internal, internal) PARALLEL SAFE;
+ALTER FUNCTION g_spoint3_fetch(internal, internal, internal) PARALLEL SAFE;