]> granicus.if.org Git - postgis/commitdiff
Clean up old compatibility code. (#196)
authorPaul Ramsey <pramsey@cleverelephant.ca>
Thu, 11 Jun 2009 15:52:30 +0000 (15:52 +0000)
committerPaul Ramsey <pramsey@cleverelephant.ca>
Thu, 11 Jun 2009 15:52:30 +0000 (15:52 +0000)
git-svn-id: http://svn.osgeo.org/postgis/trunk@4166 b70326c6-7e19-0410-871a-916f4a2858ee

postgis/long_xact.sql.in.c
postgis/postgis.sql.in.c
postgis/sqldefines.h.in
postgis/sqlmm.sql.in.c

index 17f1eee77f6f0d30b7037a54ba0f5057cd159cf3..7e436543d40d6f93c2658788e85a4adbb96dc832 100644 (file)
@@ -22,7 +22,7 @@
 -- UnlockRows(authid)
 -- removes all locks held by the given auth
 -- returns the number of locks released
-CREATEFUNCTION UnlockRows(text)
+CREATE OR REPLACE FUNCTION UnlockRows(text)
        RETURNS int
        AS $$ 
 DECLARE
@@ -45,7 +45,7 @@ LANGUAGE 'plpgsql' _VOLATILE_STRICT;
 
 -- LockRow([schema], table, rowid, auth, [expires]) 
 -- Returns 1 if successfully obtained the lock, 0 otherwise
-CREATEFUNCTION LockRow(text, text, text, text, timestamp)
+CREATE OR REPLACE FUNCTION LockRow(text, text, text, text, timestamp)
        RETURNS int
        AS $$ 
 DECLARE
@@ -96,28 +96,28 @@ $$
 LANGUAGE 'plpgsql' _VOLATILE_STRICT;
 
 -- LockRow(schema, table, rid, authid);
-CREATEFUNCTION LockRow(text, text, text, text)
+CREATE OR REPLACE FUNCTION LockRow(text, text, text, text)
        RETURNS int
        AS
 $$ SELECT LockRow($1, $2, $3, $4, now()::timestamp+'1:00'); $$
        LANGUAGE 'sql' _VOLATILE_STRICT;
 
 -- LockRow(table, rid, authid);
-CREATEFUNCTION LockRow(text, text, text)
+CREATE OR REPLACE FUNCTION LockRow(text, text, text)
        RETURNS int
        AS
 $$ SELECT LockRow(current_schema(), $1, $2, $3, now()::timestamp+'1:00'); $$
        LANGUAGE 'sql' _VOLATILE_STRICT;
 
 -- LockRow(schema, table, rid, expires);
-CREATEFUNCTION LockRow(text, text, text, timestamp)
+CREATE OR REPLACE FUNCTION LockRow(text, text, text, timestamp)
        RETURNS int
        AS
 $$ SELECT LockRow(current_schema(), $1, $2, $3, $4); $$
        LANGUAGE 'sql' _VOLATILE_STRICT;
 
 
-CREATEFUNCTION AddAuth(text)
+CREATE OR REPLACE FUNCTION AddAuth(text)
        RETURNS BOOLEAN
        AS $$ 
 DECLARE
@@ -154,7 +154,7 @@ LANGUAGE PLPGSQL;
 --
 -- Returns 0
 --
-CREATEFUNCTION CheckAuth(text, text, text)
+CREATE OR REPLACE FUNCTION CheckAuth(text, text, text)
        RETURNS INT
        AS $$ 
 DECLARE
@@ -183,18 +183,18 @@ $$
 LANGUAGE 'plpgsql';
 
 -- CheckAuth(<table>, <ridcolumn>)
-CREATEFUNCTION CheckAuth(text, text)
+CREATE OR REPLACE FUNCTION CheckAuth(text, text)
        RETURNS INT
        AS
        $$ SELECT CheckAuth('', $1, $2) $$
        LANGUAGE 'SQL';
 
-CREATEFUNCTION CheckAuthTrigger()
+CREATE OR REPLACE FUNCTION CheckAuthTrigger()
        RETURNS trigger AS 
        'MODULE_PATHNAME', 'check_authorization'
        LANGUAGE C;
 
-CREATEFUNCTION GetTransactionID()
+CREATE OR REPLACE FUNCTION GetTransactionID()
        RETURNS xid AS 
        'MODULE_PATHNAME', 'getTransactionID'
        LANGUAGE C;
@@ -205,7 +205,7 @@ CREATEFUNCTION GetTransactionID()
 --
 --  Creates the authorization_table if not already existing
 --
-CREATEFUNCTION EnableLongTransactions()
+CREATE OR REPLACE FUNCTION EnableLongTransactions()
        RETURNS TEXT
        AS $$ 
 DECLARE
@@ -261,7 +261,7 @@ LANGUAGE 'plpgsql';
 --
 -- Check if Long transactions support is enabled
 --
-CREATEFUNCTION LongTransactionsEnabled()
+CREATE OR REPLACE FUNCTION LongTransactionsEnabled()
        RETURNS bool
 AS $$ 
 DECLARE
@@ -283,7 +283,7 @@ LANGUAGE 'plpgsql';
 --  (2) Drop the authorization_table
 --  (3) KEEP the authorized_tables view
 --
-CREATEFUNCTION DisableLongTransactions()
+CREATE OR REPLACE FUNCTION DisableLongTransactions()
        RETURNS TEXT
        AS $$ 
 DECLARE
index b691eeb3848501aded2a4581a06a93a7d53b3c76..9e292aeea328c52713fa6b390180e14c54ffb605 100644 (file)
@@ -28,28 +28,28 @@ BEGIN;
 -------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION spheroid_in(cstring)
+CREATE OR REPLACE FUNCTION spheroid_in(cstring)
        RETURNS spheroid 
        AS 'MODULE_PATHNAME','ellipsoid_in'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_spheroid_in(cstring)
+CREATE OR REPLACE FUNCTION ST_spheroid_in(cstring)
        RETURNS spheroid 
        AS 'MODULE_PATHNAME','ellipsoid_in'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION spheroid_out(spheroid)
+CREATE OR REPLACE FUNCTION spheroid_out(spheroid)
        RETURNS cstring 
        AS 'MODULE_PATHNAME','ellipsoid_out'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_spheroid_out(spheroid)
+CREATE OR REPLACE FUNCTION ST_spheroid_out(spheroid)
        RETURNS cstring 
        AS 'MODULE_PATHNAME','ellipsoid_out'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 CREATE TYPE spheroid (
        alignment = double,
@@ -63,74 +63,74 @@ CREATE TYPE spheroid (
 -------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_in(cstring)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','LWGEOM_in'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION geometry_in(cstring)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','LWGEOM_in'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_in(cstring)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','LWGEOM_in'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_geometry_in(cstring)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','LWGEOM_in'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_out(geometry)
-        RETURNS cstring
-        AS 'MODULE_PATHNAME','LWGEOM_out'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION geometry_out(geometry)
+       RETURNS cstring
+       AS 'MODULE_PATHNAME','LWGEOM_out'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_out(geometry)
-        RETURNS cstring
-        AS 'MODULE_PATHNAME','LWGEOM_out'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_geometry_out(geometry)
+       RETURNS cstring
+       AS 'MODULE_PATHNAME','LWGEOM_out'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_analyze(internal)
+CREATE OR REPLACE FUNCTION geometry_analyze(internal)
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_analyze'
-       LANGUAGE 'C' _VOLATILE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' VOLATILE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_analyze(internal)
+CREATE OR REPLACE FUNCTION ST_geometry_analyze(internal)
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_analyze'
-       LANGUAGE 'C' _VOLATILE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' VOLATILE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_recv(internal)
+CREATE OR REPLACE FUNCTION geometry_recv(internal)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_recv'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_recv(internal)
+CREATE OR REPLACE FUNCTION ST_geometry_recv(internal)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_recv'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_send(geometry)
+CREATE OR REPLACE FUNCTION geometry_send(geometry)
        RETURNS bytea
        AS 'MODULE_PATHNAME','LWGEOM_send'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_send(geometry)
+CREATE OR REPLACE FUNCTION ST_geometry_send(geometry)
        RETURNS bytea
        AS 'MODULE_PATHNAME','LWGEOM_send'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 CREATE TYPE geometry (
-        internallength = variable,
-        input = ST_geometry_in,
-        output = ST_geometry_out,
+       internallength = variable,
+       input = ST_geometry_in,
+       output = ST_geometry_out,
        send = ST_geometry_send,
        receive = ST_geometry_recv,
        delimiter = ':',
        analyze = ST_geometry_analyze,
-        storage = main
+       storage = main
 );
 
 -------------------------------------------
@@ -139,187 +139,187 @@ CREATE TYPE geometry (
 
 -- Availability: 1.1.2
 -- Deprecation in 1.2.3
-CREATEFUNCTION Affine(geometry,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8)
+CREATE OR REPLACE FUNCTION Affine(geometry,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_affine'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; 
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Affine(geometry,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8)
+CREATE OR REPLACE FUNCTION ST_Affine(geometry,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8,float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_affine'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; 
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.1.2
 -- Deprecation in 1.2.3
-CREATEFUNCTION Affine(geometry,float8,float8,float8,float8,float8,float8)
+CREATE OR REPLACE FUNCTION Affine(geometry,float8,float8,float8,float8,float8,float8)
        RETURNS geometry
        AS 'SELECT affine($1,  $2, $3, 0,  $4, $5, 0,  0, 0, 1,  $6, $7, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Affine(geometry,float8,float8,float8,float8,float8,float8)
+CREATE OR REPLACE FUNCTION ST_Affine(geometry,float8,float8,float8,float8,float8,float8)
        RETURNS geometry
        AS 'SELECT affine($1,  $2, $3, 0,  $4, $5, 0,  0, 0, 1,  $6, $7, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.1.2
 -- Deprecation in 1.2.3
-CREATEFUNCTION RotateZ(geometry,float8)
+CREATE OR REPLACE FUNCTION RotateZ(geometry,float8)
        RETURNS geometry
        AS 'SELECT affine($1,  cos($2), -sin($2), 0,  sin($2), cos($2), 0,  0, 0, 1,  0, 0, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_RotateZ(geometry,float8)
+CREATE OR REPLACE FUNCTION ST_RotateZ(geometry,float8)
        RETURNS geometry
        AS 'SELECT affine($1,  cos($2), -sin($2), 0,  sin($2), cos($2), 0,  0, 0, 1,  0, 0, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.1.2
 -- Deprecation in 1.2.3
-CREATEFUNCTION Rotate(geometry,float8)
+CREATE OR REPLACE FUNCTION Rotate(geometry,float8)
        RETURNS geometry
        AS 'SELECT rotateZ($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Rotate(geometry,float8)
+CREATE OR REPLACE FUNCTION ST_Rotate(geometry,float8)
        RETURNS geometry
        AS 'SELECT rotateZ($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.1.2
 -- Deprecation in 1.2.3
-CREATEFUNCTION RotateX(geometry,float8)
+CREATE OR REPLACE FUNCTION RotateX(geometry,float8)
        RETURNS geometry
        AS 'SELECT affine($1, 1, 0, 0, 0, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_RotateX(geometry,float8)
+CREATE OR REPLACE FUNCTION ST_RotateX(geometry,float8)
        RETURNS geometry
        AS 'SELECT affine($1, 1, 0, 0, 0, cos($2), -sin($2), 0, sin($2), cos($2), 0, 0, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.1.2
 -- Deprecation in 1.2.3
-CREATEFUNCTION RotateY(geometry,float8)
+CREATE OR REPLACE FUNCTION RotateY(geometry,float8)
        RETURNS geometry
        AS 'SELECT affine($1,  cos($2), 0, sin($2),  0, 1, 0,  -sin($2), 0, cos($2), 0,  0, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_RotateY(geometry,float8)
+CREATE OR REPLACE FUNCTION ST_RotateY(geometry,float8)
        RETURNS geometry
        AS 'SELECT affine($1,  cos($2), 0, sin($2),  0, 1, 0,  -sin($2), 0, cos($2), 0,  0, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Translate(geometry,float8,float8,float8)
+CREATE OR REPLACE FUNCTION Translate(geometry,float8,float8,float8)
        RETURNS geometry
        AS 'SELECT affine($1, 1, 0, 0, 0, 1, 0, 0, 0, 1, $2, $3, $4)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Translate(geometry,float8,float8,float8)
+CREATE OR REPLACE FUNCTION ST_Translate(geometry,float8,float8,float8)
        RETURNS geometry
        AS 'SELECT affine($1, 1, 0, 0, 0, 1, 0, 0, 0, 1, $2, $3, $4)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Translate(geometry,float8,float8)
+CREATE OR REPLACE FUNCTION Translate(geometry,float8,float8)
        RETURNS geometry
        AS 'SELECT translate($1, $2, $3, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT;
+       LANGUAGE 'SQL' IMMUTABLE STRICT;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Translate(geometry,float8,float8)
+CREATE OR REPLACE FUNCTION ST_Translate(geometry,float8,float8)
        RETURNS geometry
        AS 'SELECT translate($1, $2, $3, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT;
+       LANGUAGE 'SQL' IMMUTABLE STRICT;
 
 -- Availability: 1.1.0
 -- Deprecation in 1.2.3
-CREATEFUNCTION Scale(geometry,float8,float8,float8)
+CREATE OR REPLACE FUNCTION Scale(geometry,float8,float8,float8)
        RETURNS geometry
        AS 'SELECT affine($1,  $2, 0, 0,  0, $3, 0,  0, 0, $4,  0, 0, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Scale(geometry,float8,float8,float8)
+CREATE OR REPLACE FUNCTION ST_Scale(geometry,float8,float8,float8)
        RETURNS geometry
        AS 'SELECT affine($1,  $2, 0, 0,  0, $3, 0,  0, 0, $4,  0, 0, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.1.0
 -- Deprecation in 1.2.3
-CREATEFUNCTION Scale(geometry,float8,float8)
+CREATE OR REPLACE FUNCTION Scale(geometry,float8,float8)
        RETURNS geometry
        AS 'SELECT scale($1, $2, $3, 1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Scale(geometry,float8,float8)
+CREATE OR REPLACE FUNCTION ST_Scale(geometry,float8,float8)
        RETURNS geometry
        AS 'SELECT scale($1, $2, $3, 1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; 
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.1.0 
 -- Deprecation in 1.2.3
-CREATEFUNCTION transscale(geometry,float8,float8,float8,float8)
-        RETURNS geometry
-        AS 'SELECT affine($1,  $4, 0, 0,  0, $5, 0, 
+CREATE OR REPLACE FUNCTION transscale(geometry,float8,float8,float8,float8)
+       RETURNS geometry
+       AS 'SELECT affine($1,  $4, 0, 0,  0, $5, 0, 
                0, 0, 1,  $2 * $4, $3 * $5, 0)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT;
+       LANGUAGE 'SQL' IMMUTABLE STRICT;
 
 -- Availability: 1.2.2 
-CREATEFUNCTION ST_transscale(geometry,float8,float8,float8,float8)
-        RETURNS geometry
-        AS 'SELECT affine($1,  $4, 0, 0,  0, $5, 0, 
+CREATE OR REPLACE FUNCTION ST_transscale(geometry,float8,float8,float8,float8)
+       RETURNS geometry
+       AS 'SELECT affine($1,  $4, 0, 0,  0, $5, 0, 
                0, 0, 1,  $2 * $4, $3 * $5, 0)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT;
+       LANGUAGE 'SQL' IMMUTABLE STRICT;
 
 -- Availability: 1.1.0
 -- Deprecation in 1.2.3
-CREATEFUNCTION shift_longitude(geometry)
+CREATE OR REPLACE FUNCTION shift_longitude(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_longitude_shift'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; 
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_shift_longitude(geometry)
+CREATE OR REPLACE FUNCTION ST_shift_longitude(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_longitude_shift'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; 
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -------------------------------------------------------------------
 --  BOX3D TYPE
 -------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box3d_in(cstring)
+CREATE OR REPLACE FUNCTION box3d_in(cstring)
        RETURNS box3d 
        AS 'MODULE_PATHNAME', 'BOX3D_in'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box3d_out(box3d)
+CREATE OR REPLACE FUNCTION box3d_out(box3d)
        RETURNS cstring 
        AS 'MODULE_PATHNAME', 'BOX3D_out'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box3d_in(cstring)
+CREATE OR REPLACE FUNCTION ST_box3d_in(cstring)
        RETURNS box3d 
        AS 'MODULE_PATHNAME', 'BOX3D_in'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box3d_out(box3d)
+CREATE OR REPLACE FUNCTION ST_box3d_out(box3d)
        RETURNS cstring 
        AS 'MODULE_PATHNAME', 'BOX3D_out'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 CREATE TYPE box3d (
        alignment = double,
@@ -331,15 +331,15 @@ CREATE TYPE box3d (
 -- Temporary box3d aggregate type to retain full double precision
 -- for ST_Extent(). Should be removed when we change the output 
 -- type of ST_Extent() to return something other than BOX2DFLOAT4.
-CREATEFUNCTION box3d_extent_in(cstring)
-        RETURNS box3d_extent
-        AS '$libdir/postgis-1.4', 'BOX3D_in'
-        LANGUAGE 'C' IMMUTABLE STRICT; -- WITH (isstrict);
+CREATE OR REPLACE FUNCTION box3d_extent_in(cstring)
+       RETURNS box3d_extent
+       AS '$libdir/postgis-1.4', 'BOX3D_in'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
-CREATEFUNCTION box3d_extent_out(box3d_extent)
+CREATE OR REPLACE FUNCTION box3d_extent_out(box3d_extent)
        RETURNS cstring 
        AS 'MODULE_PATHNAME', 'BOX3D_extent_out'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 CREATE TYPE box3d_extent (
        alignment = double,
@@ -349,121 +349,121 @@ CREATE TYPE box3d_extent (
 );
 
 -- Availability: 1.4.0
-CREATEFUNCTION ST_box3d_extent(box3d_extent)
-        RETURNS box3d
-        AS 'MODULE_PATHNAME', 'BOX3D_extent_to_BOX3D'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
-
-CREATEFUNCTION ST_box2d(box3d_extent)
-        RETURNS box2d
-        AS 'MODULE_PATHNAME', 'BOX3D_to_BOX2DFLOAT4'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
-
-CREATEFUNCTION ST_geometry(box3d_extent)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','BOX3D_to_LWGEOM'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_box3d_extent(box3d_extent)
+       RETURNS box3d
+       AS 'MODULE_PATHNAME', 'BOX3D_extent_to_BOX3D'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
+
+CREATE OR REPLACE FUNCTION ST_box2d(box3d_extent)
+       RETURNS box2d
+       AS 'MODULE_PATHNAME', 'BOX3D_to_BOX2DFLOAT4'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
+
+CREATE OR REPLACE FUNCTION ST_geometry(box3d_extent)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','BOX3D_to_LWGEOM'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 -- End of temporary hack
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION xmin(box3d)
+CREATE OR REPLACE FUNCTION xmin(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_xmin'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_XMin(box3d)
+CREATE OR REPLACE FUNCTION ST_XMin(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_xmin'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION ymin(box3d)
+CREATE OR REPLACE FUNCTION ymin(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_ymin'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_YMin(box3d)
+CREATE OR REPLACE FUNCTION ST_YMin(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_ymin'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION zmin(box3d)
+CREATE OR REPLACE FUNCTION zmin(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_zmin'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_ZMin(box3d)
+CREATE OR REPLACE FUNCTION ST_ZMin(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_zmin'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION xmax(box3d)
+CREATE OR REPLACE FUNCTION xmax(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_xmax'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_XMax(box3d)
+CREATE OR REPLACE FUNCTION ST_XMax(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_xmax'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION ymax(box3d)
+CREATE OR REPLACE FUNCTION ymax(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_ymax'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_YMax(box3d)
+CREATE OR REPLACE FUNCTION ST_YMax(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_ymax'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION zmax(box3d)
+CREATE OR REPLACE FUNCTION zmax(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_zmax'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_ZMax(box3d)
+CREATE OR REPLACE FUNCTION ST_ZMax(box3d)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','BOX3D_zmax'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -------------------------------------------------------------------
 --  CHIP TYPE
 -------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION chip_in(cstring)
+CREATE OR REPLACE FUNCTION chip_in(cstring)
        RETURNS chip 
        AS 'MODULE_PATHNAME','CHIP_in'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
-        
+       LANGUAGE 'C' IMMUTABLE STRICT; 
+       
 -- Availability: 1.2.2
-CREATEFUNCTION ST_chip_in(cstring)
+CREATE OR REPLACE FUNCTION ST_chip_in(cstring)
        RETURNS chip 
        AS 'MODULE_PATHNAME','CHIP_in'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION chip_out(chip)
+CREATE OR REPLACE FUNCTION chip_out(chip)
        RETURNS cstring 
        AS 'MODULE_PATHNAME','CHIP_out'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_chip_out(chip)
+CREATE OR REPLACE FUNCTION ST_chip_out(chip)
        RETURNS cstring 
        AS 'MODULE_PATHNAME','CHIP_out'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 CREATE TYPE chip (
        alignment = double,
@@ -478,145 +478,145 @@ CREATE TYPE chip (
 -----------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_in(cstring)
-        RETURNS box2d
-        AS 'MODULE_PATHNAME','BOX2DFLOAT4_in'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION box2d_in(cstring)
+       RETURNS box2d
+       AS 'MODULE_PATHNAME','BOX2DFLOAT4_in'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_in(cstring)
-        RETURNS box2d
-        AS 'MODULE_PATHNAME','BOX2DFLOAT4_in'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_box2d_in(cstring)
+       RETURNS box2d
+       AS 'MODULE_PATHNAME','BOX2DFLOAT4_in'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_out(box2d)
-        RETURNS cstring
-        AS 'MODULE_PATHNAME','BOX2DFLOAT4_out'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION box2d_out(box2d)
+       RETURNS cstring
+       AS 'MODULE_PATHNAME','BOX2DFLOAT4_out'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_out(box2d)
-        RETURNS cstring
-        AS 'MODULE_PATHNAME','BOX2DFLOAT4_out'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_box2d_out(box2d)
+       RETURNS cstring
+       AS 'MODULE_PATHNAME','BOX2DFLOAT4_out'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 CREATE TYPE box2d (
-        internallength = 16,
-        input = ST_box2d_in,
-        output = ST_box2d_out,
-        storage = plain
+       internallength = 16,
+       input = ST_box2d_in,
+       output = ST_box2d_out,
+       storage = plain
 );
 
 ---- BOX2D  support functions
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_overleft(box2d, box2d) 
+CREATE OR REPLACE FUNCTION box2d_overleft(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_overleft'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_overleft(box2d, box2d) 
+CREATE OR REPLACE FUNCTION ST_box2d_overleft(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_overleft'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_overright(box2d, box2d) 
+CREATE OR REPLACE FUNCTION box2d_overright(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_overright' 
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_overright(box2d, box2d) 
+CREATE OR REPLACE FUNCTION ST_box2d_overright(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_overright' 
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_left(box2d, box2d) 
+CREATE OR REPLACE FUNCTION box2d_left(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_left' 
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_left(box2d, box2d) 
+CREATE OR REPLACE FUNCTION ST_box2d_left(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_left' 
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_right(box2d, box2d) 
+CREATE OR REPLACE FUNCTION box2d_right(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_right' 
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_right(box2d, box2d) 
+CREATE OR REPLACE FUNCTION ST_box2d_right(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_right' 
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_contain(box2d, box2d) 
+CREATE OR REPLACE FUNCTION box2d_contain(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_contain'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_contain(box2d, box2d) 
+CREATE OR REPLACE FUNCTION ST_box2d_contain(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_contain'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_contained(box2d, box2d) 
+CREATE OR REPLACE FUNCTION box2d_contained(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_contained'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_contained(box2d, box2d) 
+CREATE OR REPLACE FUNCTION ST_box2d_contained(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_contained'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_overlap(box2d, box2d) 
+CREATE OR REPLACE FUNCTION box2d_overlap(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_overlap'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_overlap(box2d, box2d) 
+CREATE OR REPLACE FUNCTION ST_box2d_overlap(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_overlap'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_same(box2d, box2d) 
+CREATE OR REPLACE FUNCTION box2d_same(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_same'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_same(box2d, box2d) 
+CREATE OR REPLACE FUNCTION ST_box2d_same(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_same'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d_intersects(box2d, box2d) 
+CREATE OR REPLACE FUNCTION box2d_intersects(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_intersects'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d_intersects(box2d, box2d) 
+CREATE OR REPLACE FUNCTION ST_box2d_intersects(box2d, box2d) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'BOX2D_intersects'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 
 -- lwgeom  operator support functions
@@ -626,108 +626,108 @@ CREATEFUNCTION ST_box2d_intersects(box2d, box2d)
 -------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_lt(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_lt(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_lt'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_lt(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_lt(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_lt'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_le(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_le(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_le'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_le(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_le(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_le'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_gt(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_gt(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_gt'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_gt(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_gt(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_gt'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_ge(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_ge(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_ge'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_ge(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_ge(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_ge'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_eq(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_eq(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_eq'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_eq(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_eq(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'lwgeom_eq'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_cmp(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_cmp(geometry, geometry) 
        RETURNS integer
        AS 'MODULE_PATHNAME', 'lwgeom_cmp'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_cmp(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_cmp(geometry, geometry) 
        RETURNS integer
        AS 'MODULE_PATHNAME', 'lwgeom_cmp'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 --
 -- Sorting operators for Btree
 --
 
 CREATE OPERATOR < (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_lt,
-   COMMUTATOR = '>', NEGATOR = '>=',
-   RESTRICT = contsel, JOIN = contjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_lt,
+       COMMUTATOR = '>', NEGATOR = '>=',
+       RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR <= (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_le,
-   COMMUTATOR = '>=', NEGATOR = '>',
-   RESTRICT = contsel, JOIN = contjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_le,
+       COMMUTATOR = '>=', NEGATOR = '>',
+       RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR = (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_eq,
-   COMMUTATOR = '=', -- we might implement a faster negator here
-   RESTRICT = contsel, JOIN = contjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_eq,
+       COMMUTATOR = '=', -- we might implement a faster negator here
+       RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR >= (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_ge,
-   COMMUTATOR = '<=', NEGATOR = '<',
-   RESTRICT = contsel, JOIN = contjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_ge,
+       COMMUTATOR = '<=', NEGATOR = '<',
+       RESTRICT = contsel, JOIN = contjoinsel
 );
 CREATE OPERATOR > (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_gt,
-   COMMUTATOR = '<', NEGATOR = '<=',
-   RESTRICT = contsel, JOIN = contjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_gt,
+       COMMUTATOR = '<', NEGATOR = '<=',
+       RESTRICT = contsel, JOIN = contjoinsel
 );
 
 
@@ -746,280 +746,280 @@ CREATE OPERATOR CLASS btree_geometry_ops
 -- GiST indexes
 -------------------------------------------------------------------
 -- Deprecation in 1.2.3
-CREATEFUNCTION postgis_gist_sel (internal, oid, internal, int4)
+CREATE OR REPLACE FUNCTION postgis_gist_sel (internal, oid, internal, int4)
        RETURNS float8
        AS 'MODULE_PATHNAME', 'LWGEOM_gist_sel'
        LANGUAGE 'C';
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_postgis_gist_sel (internal, oid, internal, int4)
+CREATE OR REPLACE FUNCTION ST_postgis_gist_sel (internal, oid, internal, int4)
        RETURNS float8
        AS 'MODULE_PATHNAME', 'LWGEOM_gist_sel'
        LANGUAGE 'C';
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION postgis_gist_joinsel(internal, oid, internal, smallint)
+CREATE OR REPLACE FUNCTION postgis_gist_joinsel(internal, oid, internal, smallint)
        RETURNS float8
        AS 'MODULE_PATHNAME', 'LWGEOM_gist_joinsel'
        LANGUAGE 'C';
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_postgis_gist_joinsel(internal, oid, internal, smallint)
+CREATE OR REPLACE FUNCTION ST_postgis_gist_joinsel(internal, oid, internal, smallint)
        RETURNS float8
        AS 'MODULE_PATHNAME', 'LWGEOM_gist_joinsel'
        LANGUAGE 'C';
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_overleft(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_overleft(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overleft'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_overleft(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_overleft(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overleft'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_overright(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_overright(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overright'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_overright(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_overright(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overright'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_overabove(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_overabove(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overabove'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_overabove(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_overabove(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overabove'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_overbelow(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_overbelow(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overbelow'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_overbelow(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_overbelow(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overbelow'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_left(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_left(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_left'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_left(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_left(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_left'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_right(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_right(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_right'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_right(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_right(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_right'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_above(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_above(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_above'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_above(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_above(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_above'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_below(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_below(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_below'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_below(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_below(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_below'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_contain(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_contain(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_contain'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_contain(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_contain(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_contain'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_contained(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_contained(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_contained'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_contained(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_contained(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_contained'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_overlap(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_overlap(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overlap'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry_overlap(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_overlap(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_overlap'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry_same(geometry, geometry) 
+CREATE OR REPLACE FUNCTION geometry_same(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_same'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 --Availability: 1.2.2
-CREATEFUNCTION ST_geometry_same(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_geometry_same(geometry, geometry) 
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_same'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- GEOMETRY operators
 
 CREATE OPERATOR << (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_left,
-   COMMUTATOR = '>>',
-   RESTRICT = positionsel, JOIN = positionjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_left,
+       COMMUTATOR = '>>',
+       RESTRICT = positionsel, JOIN = positionjoinsel
 );
 
 CREATE OPERATOR &< (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overleft,
-   COMMUTATOR = '&>',
-   RESTRICT = positionsel, JOIN = positionjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overleft,
+       COMMUTATOR = '&>',
+       RESTRICT = positionsel, JOIN = positionjoinsel
 );
 
 CREATE OPERATOR <<| (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_below,
-   COMMUTATOR = '|>>',
-   RESTRICT = positionsel, JOIN = positionjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_below,
+       COMMUTATOR = '|>>',
+       RESTRICT = positionsel, JOIN = positionjoinsel
 );
 
 CREATE OPERATOR &<| (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overbelow,
-   COMMUTATOR = '|&>',
-   RESTRICT = positionsel, JOIN = positionjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overbelow,
+       COMMUTATOR = '|&>',
+       RESTRICT = positionsel, JOIN = positionjoinsel
 );
 
 CREATE OPERATOR && (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overlap,
-   COMMUTATOR = '&&',
-   RESTRICT = ST_postgis_gist_sel, JOIN = ST_postgis_gist_joinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overlap,
+       COMMUTATOR = '&&',
+       RESTRICT = ST_postgis_gist_sel, JOIN = ST_postgis_gist_joinsel
 );
 
 CREATE OPERATOR &> (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overright,
-   COMMUTATOR = '&<',
-   RESTRICT = positionsel, JOIN = positionjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overright,
+       COMMUTATOR = '&<',
+       RESTRICT = positionsel, JOIN = positionjoinsel
 );
 
 CREATE OPERATOR >> (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_right,
-   COMMUTATOR = '<<',
-   RESTRICT = positionsel, JOIN = positionjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_right,
+       COMMUTATOR = '<<',
+       RESTRICT = positionsel, JOIN = positionjoinsel
 );
 
 CREATE OPERATOR |&> (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overabove,
-   COMMUTATOR = '&<|',
-   RESTRICT = positionsel, JOIN = positionjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_overabove,
+       COMMUTATOR = '&<|',
+       RESTRICT = positionsel, JOIN = positionjoinsel
 );
 
 CREATE OPERATOR |>> (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_above,
-   COMMUTATOR = '<<|',
-   RESTRICT = positionsel, JOIN = positionjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_above,
+       COMMUTATOR = '<<|',
+       RESTRICT = positionsel, JOIN = positionjoinsel
 );
 
 CREATE OPERATOR ~= (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_same,
-   COMMUTATOR = '~=', 
-   RESTRICT = eqsel, JOIN = eqjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_same,
+       COMMUTATOR = '~=', 
+       RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR @ (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_contained,
-   COMMUTATOR = '~',
-   RESTRICT = contsel, JOIN = contjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_contained,
+       COMMUTATOR = '~',
+       RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR ~ (
-   LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_contain,
-   COMMUTATOR = '@',
-   RESTRICT = contsel, JOIN = contjoinsel
+       LEFTARG = geometry, RIGHTARG = geometry, PROCEDURE = ST_geometry_contain,
+       COMMUTATOR = '@',
+       RESTRICT = contsel, JOIN = contjoinsel
 );
 
 -- gist support functions
 
-CREATEFUNCTION LWGEOM_gist_consistent(internal,geometry,int4) 
+CREATE OR REPLACE FUNCTION LWGEOM_gist_consistent(internal,geometry,int4) 
        RETURNS bool 
        AS 'MODULE_PATHNAME' ,'LWGEOM_gist_consistent'
        LANGUAGE 'C';
 
-CREATEFUNCTION LWGEOM_gist_compress(internal) 
+CREATE OR REPLACE FUNCTION LWGEOM_gist_compress(internal) 
        RETURNS internal 
        AS 'MODULE_PATHNAME','LWGEOM_gist_compress'
        LANGUAGE 'C';
 
-CREATEFUNCTION LWGEOM_gist_penalty(internal,internal,internal) 
+CREATE OR REPLACE FUNCTION LWGEOM_gist_penalty(internal,internal,internal) 
        RETURNS internal 
        AS 'MODULE_PATHNAME' ,'LWGEOM_gist_penalty'
        LANGUAGE 'C';
 
-CREATEFUNCTION LWGEOM_gist_picksplit(internal, internal) 
+CREATE OR REPLACE FUNCTION LWGEOM_gist_picksplit(internal, internal) 
        RETURNS internal 
        AS 'MODULE_PATHNAME' ,'LWGEOM_gist_picksplit'
        LANGUAGE 'C';
 
-CREATEFUNCTION LWGEOM_gist_union(bytea, internal) 
+CREATE OR REPLACE FUNCTION LWGEOM_gist_union(bytea, internal) 
        RETURNS internal 
        AS 'MODULE_PATHNAME' ,'LWGEOM_gist_union'
        LANGUAGE 'C';
 
-CREATEFUNCTION LWGEOM_gist_same(box2d, box2d, internal) 
+CREATE OR REPLACE FUNCTION LWGEOM_gist_same(box2d, box2d, internal) 
        RETURNS internal 
        AS 'MODULE_PATHNAME' ,'LWGEOM_gist_same'
        LANGUAGE 'C';
 
-CREATEFUNCTION LWGEOM_gist_decompress(internal) 
+CREATE OR REPLACE FUNCTION LWGEOM_gist_decompress(internal) 
        RETURNS internal 
        AS 'MODULE_PATHNAME' ,'LWGEOM_gist_decompress'
        LANGUAGE 'C';
@@ -1032,225 +1032,225 @@ CREATEFUNCTION LWGEOM_gist_decompress(internal)
 --
 
 CREATE OPERATOR CLASS gist_geometry_ops
-        DEFAULT FOR TYPE geometry USING gist AS
+       DEFAULT FOR TYPE geometry USING gist AS
        STORAGE         box2d,
-        OPERATOR        1        <<    ,
-        OPERATOR        2        &<    ,
-        OPERATOR        3        &&    ,
-        OPERATOR        4        &>    ,
-        OPERATOR        5        >>    ,
-        OPERATOR        6        ~=    ,
-        OPERATOR        7        ~     ,
-        OPERATOR        8        @     ,
+       OPERATOR        1        <<     ,
+       OPERATOR        2        &<     ,
+       OPERATOR        3        &&     ,
+       OPERATOR        4        &>     ,
+       OPERATOR        5        >>     ,
+       OPERATOR        6        ~=     ,
+       OPERATOR        7        ~      ,
+       OPERATOR        8        @      ,
        OPERATOR        9        &<|    ,
        OPERATOR        10       <<|    ,
        OPERATOR        11       |>>    ,
        OPERATOR        12       |&>    ,
        FUNCTION        1        LWGEOM_gist_consistent (internal, geometry, int4),
-        FUNCTION        2        LWGEOM_gist_union (bytea, internal),
-        FUNCTION        3        LWGEOM_gist_compress (internal),
-        FUNCTION        4        LWGEOM_gist_decompress (internal),
-        FUNCTION        5        LWGEOM_gist_penalty (internal, internal, internal),
-        FUNCTION        6        LWGEOM_gist_picksplit (internal, internal),
-        FUNCTION        7        LWGEOM_gist_same (box2d, box2d, internal);
+       FUNCTION        2        LWGEOM_gist_union (bytea, internal),
+       FUNCTION        3        LWGEOM_gist_compress (internal),
+       FUNCTION        4        LWGEOM_gist_decompress (internal),
+       FUNCTION        5        LWGEOM_gist_penalty (internal, internal, internal),
+       FUNCTION        6        LWGEOM_gist_picksplit (internal, internal),
+       FUNCTION        7        LWGEOM_gist_same (box2d, box2d, internal);
        
 -------------------------------------------
 -- other lwgeom functions
 -------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION addBBOX(geometry) 
+CREATE OR REPLACE FUNCTION addBBOX(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_addBBOX'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_addBBOX(geometry) 
+CREATE OR REPLACE FUNCTION ST_addBBOX(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_addBBOX'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION dropBBOX(geometry) 
+CREATE OR REPLACE FUNCTION dropBBOX(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_dropBBOX'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_dropBBOX(geometry) 
+CREATE OR REPLACE FUNCTION ST_dropBBOX(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_dropBBOX'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
        
 -- Deprecation in 1.2.3
-CREATEFUNCTION getSRID(geometry) 
+CREATE OR REPLACE FUNCTION getSRID(geometry) 
        RETURNS int4
        AS 'MODULE_PATHNAME','LWGEOM_getSRID'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION getSRID(geometry) 
+CREATE OR REPLACE FUNCTION getSRID(geometry) 
        RETURNS int4
        AS 'MODULE_PATHNAME','LWGEOM_getSRID'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION getBBOX(geometry)
-        RETURNS box2d
-        AS 'MODULE_PATHNAME','LWGEOM_to_BOX2DFLOAT4'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION getBBOX(geometry)
+       RETURNS box2d
+       AS 'MODULE_PATHNAME','LWGEOM_to_BOX2DFLOAT4'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION getBBOX(geometry)
-        RETURNS box2d
-        AS 'MODULE_PATHNAME','LWGEOM_to_BOX2DFLOAT4'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION getBBOX(geometry)
+       RETURNS box2d
+       AS 'MODULE_PATHNAME','LWGEOM_to_BOX2DFLOAT4'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -------------------------------------------
 --- CHIP functions
 -------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION srid(chip)
+CREATE OR REPLACE FUNCTION srid(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getSRID'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_srid(chip)
+CREATE OR REPLACE FUNCTION ST_srid(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getSRID'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION height(chip)
+CREATE OR REPLACE FUNCTION height(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getHeight'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_height(chip)
+CREATE OR REPLACE FUNCTION ST_height(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getHeight'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION factor(chip)
+CREATE OR REPLACE FUNCTION factor(chip)
        RETURNS FLOAT4
        AS 'MODULE_PATHNAME','CHIP_getFactor'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_factor(chip)
+CREATE OR REPLACE FUNCTION ST_factor(chip)
        RETURNS FLOAT4
        AS 'MODULE_PATHNAME','CHIP_getFactor'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION width(chip)
+CREATE OR REPLACE FUNCTION width(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getWidth'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_width(chip)
+CREATE OR REPLACE FUNCTION ST_width(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getWidth'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION datatype(chip)
+CREATE OR REPLACE FUNCTION datatype(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getDatatype'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_datatype(chip)
+CREATE OR REPLACE FUNCTION ST_datatype(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getDatatype'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION compression(chip)
+CREATE OR REPLACE FUNCTION compression(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getCompression'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_compression(chip)
+CREATE OR REPLACE FUNCTION ST_compression(chip)
        RETURNS int4
        AS 'MODULE_PATHNAME','CHIP_getCompression'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION setSRID(chip,int4)
+CREATE OR REPLACE FUNCTION setSRID(chip,int4)
        RETURNS chip
        AS 'MODULE_PATHNAME','CHIP_setSRID'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION setFactor(chip,float4)
+CREATE OR REPLACE FUNCTION setFactor(chip,float4)
        RETURNS chip
        AS 'MODULE_PATHNAME','CHIP_setFactor'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_setFactor(chip,float4)
+CREATE OR REPLACE FUNCTION ST_setFactor(chip,float4)
        RETURNS chip
        AS 'MODULE_PATHNAME','CHIP_setFactor'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 ------------------------------------------------------------------------
 -- DEBUG
 ------------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION mem_size(geometry)
+CREATE OR REPLACE FUNCTION mem_size(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_mem_size'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_mem_size(geometry)
+CREATE OR REPLACE FUNCTION ST_mem_size(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_mem_size'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION summary(geometry)
+CREATE OR REPLACE FUNCTION summary(geometry)
        RETURNS text
        AS 'MODULE_PATHNAME', 'LWGEOM_summary'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_summary(geometry)
+CREATE OR REPLACE FUNCTION ST_summary(geometry)
        RETURNS text
        AS 'MODULE_PATHNAME', 'LWGEOM_summary'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION npoints(geometry)
+CREATE OR REPLACE FUNCTION npoints(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_npoints'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_npoints(geometry)
+CREATE OR REPLACE FUNCTION ST_npoints(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_npoints'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION nrings(geometry)
+CREATE OR REPLACE FUNCTION nrings(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_nrings'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_nrings(geometry)
+CREATE OR REPLACE FUNCTION ST_nrings(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_nrings'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 ------------------------------------------------------------------------
 -- Misures
@@ -1259,519 +1259,519 @@ CREATEFUNCTION ST_nrings(geometry)
 -- this is a fake (for back-compatibility)
 -- uses 3d if 3d is available, 2d otherwise
 -- Deprecation in 1.2.3
-CREATEFUNCTION length3d(geometry)
+CREATE OR REPLACE FUNCTION length3d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_length_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_length3d(geometry)
+CREATE OR REPLACE FUNCTION ST_length3d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_length_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION length2d(geometry)
+CREATE OR REPLACE FUNCTION length2d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_length2d_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_length2d(geometry)
+CREATE OR REPLACE FUNCTION ST_length2d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_length2d_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
-CREATEFUNCTION length(geometry)
+CREATE OR REPLACE FUNCTION length(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_length_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: length2d(geometry)
-CREATEFUNCTION ST_Length(geometry)
+CREATE OR REPLACE FUNCTION ST_Length(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_length2d_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- this is a fake (for back-compatibility)
 -- uses 3d if 3d is available, 2d otherwise
 -- Deprecation in 1.2.3
-CREATEFUNCTION length3d_spheroid(geometry, spheroid)
+CREATE OR REPLACE FUNCTION length3d_spheroid(geometry, spheroid)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_length_ellipsoid_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_length3d_spheroid(geometry, spheroid)
+CREATE OR REPLACE FUNCTION ST_length3d_spheroid(geometry, spheroid)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_length_ellipsoid_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION length_spheroid(geometry, spheroid)
+CREATE OR REPLACE FUNCTION length_spheroid(geometry, spheroid)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_length_ellipsoid_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_length_spheroid(geometry, spheroid)
+CREATE OR REPLACE FUNCTION ST_length_spheroid(geometry, spheroid)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_length_ellipsoid_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION length2d_spheroid(geometry, spheroid)
+CREATE OR REPLACE FUNCTION length2d_spheroid(geometry, spheroid)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_length2d_ellipsoid_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_length2d_spheroid(geometry, spheroid)
+CREATE OR REPLACE FUNCTION ST_length2d_spheroid(geometry, spheroid)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_length2d_ellipsoid_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- this is a fake (for back-compatibility)
 -- uses 3d if 3d is available, 2d otherwise
 -- Deprecation in 1.2.3
-CREATEFUNCTION perimeter3d(geometry)
+CREATE OR REPLACE FUNCTION perimeter3d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_perimeter_poly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_perimeter3d(geometry)
+CREATE OR REPLACE FUNCTION ST_perimeter3d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_perimeter_poly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION perimeter2d(geometry)
+CREATE OR REPLACE FUNCTION perimeter2d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_perimeter2d_poly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_perimeter2d(geometry)
+CREATE OR REPLACE FUNCTION ST_perimeter2d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_perimeter2d_poly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION perimeter(geometry)
+CREATE OR REPLACE FUNCTION perimeter(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_perimeter_poly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: perimeter2d(geometry)
-CREATEFUNCTION ST_Perimeter(geometry)
+CREATE OR REPLACE FUNCTION ST_Perimeter(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_perimeter2d_poly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- this is an alias for 'area(geometry)'
 -- there is nothing such an 'area3d'...
 -- Deprecation in 1.2.3
-CREATEFUNCTION area2d(geometry)
+CREATE OR REPLACE FUNCTION area2d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_area_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
 -- Deprecation in 1.3.4
-CREATEFUNCTION ST_area2d(geometry)
+CREATE OR REPLACE FUNCTION ST_area2d(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME', 'LWGEOM_area_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION area(geometry)
+CREATE OR REPLACE FUNCTION area(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_area_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: area(geometry)
-CREATEFUNCTION ST_Area(geometry)
+CREATE OR REPLACE FUNCTION ST_Area(geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_area_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION distance_spheroid(geometry,geometry,spheroid)
+CREATE OR REPLACE FUNCTION distance_spheroid(geometry,geometry,spheroid)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_distance_ellipsoid_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_distance_spheroid(geometry,geometry,spheroid)
+CREATE OR REPLACE FUNCTION ST_distance_spheroid(geometry,geometry,spheroid)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_distance_ellipsoid_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION distance_sphere(geometry,geometry)
+CREATE OR REPLACE FUNCTION distance_sphere(geometry,geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_distance_sphere'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_distance_sphere(geometry,geometry)
+CREATE OR REPLACE FUNCTION ST_distance_sphere(geometry,geometry)
        RETURNS FLOAT8
        AS 'MODULE_PATHNAME','LWGEOM_distance_sphere'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Minimum distance. 2d only.
 -- Deprecation in 1.2.3
-CREATEFUNCTION distance(geometry,geometry)
+CREATE OR REPLACE FUNCTION distance(geometry,geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME', 'LWGEOM_mindistance2d'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: distance(geometry,geometry)
-CREATEFUNCTION ST_Distance(geometry,geometry)
-    RETURNS float8
-    AS 'MODULE_PATHNAME', 'LWGEOM_mindistance2d'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Distance(geometry,geometry)
+       RETURNS float8
+       AS 'MODULE_PATHNAME', 'LWGEOM_mindistance2d'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Maximum distance between linestrings. 2d only. Very bogus.
 -- Deprecation in 1.2.3
-CREATEFUNCTION max_distance(geometry,geometry)
+CREATE OR REPLACE FUNCTION max_distance(geometry,geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME', 'LWGEOM_maxdistance2d_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_max_distance(geometry,geometry)
+CREATE OR REPLACE FUNCTION ST_max_distance(geometry,geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME', 'LWGEOM_maxdistance2d_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION point_inside_circle(geometry,float8,float8,float8)
+CREATE OR REPLACE FUNCTION point_inside_circle(geometry,float8,float8,float8)
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_inside_circle_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_point_inside_circle(geometry,float8,float8,float8)
+CREATE OR REPLACE FUNCTION ST_point_inside_circle(geometry,float8,float8,float8)
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_inside_circle_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION azimuth(geometry,geometry)
+CREATE OR REPLACE FUNCTION azimuth(geometry,geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME', 'LWGEOM_azimuth'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_azimuth(geometry,geometry)
+CREATE OR REPLACE FUNCTION ST_azimuth(geometry,geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME', 'LWGEOM_azimuth'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 ------------------------------------------------------------------------
 -- MISC
 ------------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION force_2d(geometry) 
+CREATE OR REPLACE FUNCTION force_2d(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_2d'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_force_2d(geometry) 
+CREATE OR REPLACE FUNCTION ST_force_2d(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_2d'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION force_3dz(geometry) 
+CREATE OR REPLACE FUNCTION force_3dz(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_3dz'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_force_3dz(geometry) 
+CREATE OR REPLACE FUNCTION ST_force_3dz(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_3dz'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- an alias for force_3dz
 -- Deprecation in 1.2.3
-CREATEFUNCTION force_3d(geometry) 
+CREATE OR REPLACE FUNCTION force_3d(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_3dz'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_force_3d(geometry) 
+CREATE OR REPLACE FUNCTION ST_force_3d(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_3dz'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION force_3dm(geometry) 
+CREATE OR REPLACE FUNCTION force_3dm(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_3dm'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_force_3dm(geometry) 
+CREATE OR REPLACE FUNCTION ST_force_3dm(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_3dm'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION force_4d(geometry) 
+CREATE OR REPLACE FUNCTION force_4d(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_4d'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_force_4d(geometry) 
+CREATE OR REPLACE FUNCTION ST_force_4d(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_4d'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION force_collection(geometry) 
+CREATE OR REPLACE FUNCTION force_collection(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_collection'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_force_collection(geometry) 
+CREATE OR REPLACE FUNCTION ST_force_collection(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_collection'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION multi(geometry) 
+CREATE OR REPLACE FUNCTION multi(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_multi'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_multi(geometry) 
+CREATE OR REPLACE FUNCTION ST_multi(geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_force_multi'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION expand(box3d,float8)
+CREATE OR REPLACE FUNCTION expand(box3d,float8)
        RETURNS box3d
        AS 'MODULE_PATHNAME', 'BOX3D_expand'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Expand(box3d,float8)
+CREATE OR REPLACE FUNCTION ST_Expand(box3d,float8)
        RETURNS box3d
        AS 'MODULE_PATHNAME', 'BOX3D_expand'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION expand(box2d,float8)
+CREATE OR REPLACE FUNCTION expand(box2d,float8)
        RETURNS box2d
        AS 'MODULE_PATHNAME', 'BOX2DFLOAT4_expand'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_expand(box2d,float8)
+CREATE OR REPLACE FUNCTION ST_expand(box2d,float8)
        RETURNS box2d
        AS 'MODULE_PATHNAME', 'BOX2DFLOAT4_expand'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION expand(geometry,float8)
+CREATE OR REPLACE FUNCTION expand(geometry,float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_expand'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_expand(geometry,float8)
+CREATE OR REPLACE FUNCTION ST_expand(geometry,float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_expand'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION envelope(geometry)
+CREATE OR REPLACE FUNCTION envelope(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_envelope'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: envelope(geometry)
-CREATEFUNCTION ST_Envelope(geometry)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME', 'LWGEOM_envelope'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+CREATE OR REPLACE FUNCTION ST_Envelope(geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_envelope'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION reverse(geometry)
+CREATE OR REPLACE FUNCTION reverse(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_reverse'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Reverse(geometry)
+CREATE OR REPLACE FUNCTION ST_Reverse(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_reverse'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION ForceRHR(geometry)
+CREATE OR REPLACE FUNCTION ForceRHR(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_forceRHR_poly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_ForceRHR(geometry)
+CREATE OR REPLACE FUNCTION ST_ForceRHR(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_forceRHR_poly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION noop(geometry)
+CREATE OR REPLACE FUNCTION noop(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_noop'
-       LANGUAGE 'C' _VOLATILE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' VOLATILE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_noop(geometry)
+CREATE OR REPLACE FUNCTION ST_noop(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_noop'
-       LANGUAGE 'C' _VOLATILE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' VOLATILE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION zmflag(geometry)
+CREATE OR REPLACE FUNCTION zmflag(geometry)
        RETURNS smallint
        AS 'MODULE_PATHNAME', 'LWGEOM_zmflag'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_zmflag(geometry)
+CREATE OR REPLACE FUNCTION ST_zmflag(geometry)
        RETURNS smallint
        AS 'MODULE_PATHNAME', 'LWGEOM_zmflag'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION hasBBOX(geometry)
+CREATE OR REPLACE FUNCTION hasBBOX(geometry)
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_hasBBOX'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availabitily: 1.2.2
-CREATEFUNCTION ST_HasBBOX(geometry)
+CREATE OR REPLACE FUNCTION ST_HasBBOX(geometry)
        RETURNS bool
        AS 'MODULE_PATHNAME', 'LWGEOM_hasBBOX'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION ndims(geometry)
+CREATE OR REPLACE FUNCTION ndims(geometry)
        RETURNS smallint
        AS 'MODULE_PATHNAME', 'LWGEOM_ndims'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_NDims(geometry)
+CREATE OR REPLACE FUNCTION ST_NDims(geometry)
        RETURNS smallint
        AS 'MODULE_PATHNAME', 'LWGEOM_ndims'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsEWKT(geometry)
+CREATE OR REPLACE FUNCTION AsEWKT(geometry)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','LWGEOM_asEWKT'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsEWKT(geometry)
+CREATE OR REPLACE FUNCTION ST_AsEWKT(geometry)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','LWGEOM_asEWKT'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsEWKB(geometry)
+CREATE OR REPLACE FUNCTION AsEWKB(geometry)
        RETURNS BYTEA
        AS 'MODULE_PATHNAME','WKBFromLWGEOM'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsEWKB(geometry)
+CREATE OR REPLACE FUNCTION ST_AsEWKB(geometry)
        RETURNS BYTEA
        AS 'MODULE_PATHNAME','WKBFromLWGEOM'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsHEXEWKB(geometry)
+CREATE OR REPLACE FUNCTION AsHEXEWKB(geometry)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','LWGEOM_asHEXEWKB'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsHEXEWKB(geometry)
+CREATE OR REPLACE FUNCTION ST_AsHEXEWKB(geometry)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','LWGEOM_asHEXEWKB'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsHEXEWKB(geometry, text)
+CREATE OR REPLACE FUNCTION AsHEXEWKB(geometry, text)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','LWGEOM_asHEXEWKB'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsHEXEWKB(geometry, text)
+CREATE OR REPLACE FUNCTION ST_AsHEXEWKB(geometry, text)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','LWGEOM_asHEXEWKB'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsEWKB(geometry,text)
+CREATE OR REPLACE FUNCTION AsEWKB(geometry,text)
        RETURNS bytea
        AS 'MODULE_PATHNAME','WKBFromLWGEOM'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsEWKB(geometry,text)
+CREATE OR REPLACE FUNCTION ST_AsEWKB(geometry,text)
        RETURNS bytea
        AS 'MODULE_PATHNAME','WKBFromLWGEOM'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomFromEWKB(bytea)
+CREATE OR REPLACE FUNCTION GeomFromEWKB(bytea)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOMFromWKB'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeomFromEWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_GeomFromEWKB(bytea)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOMFromWKB'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomFromEWKT(text)
+CREATE OR REPLACE FUNCTION GeomFromEWKT(text)
        RETURNS geometry
        AS 'MODULE_PATHNAME','parse_WKT_lwgeom'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeomFromEWKT(text)
+CREATE OR REPLACE FUNCTION ST_GeomFromEWKT(text)
        RETURNS geometry
        AS 'MODULE_PATHNAME','parse_WKT_lwgeom'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION cache_bbox()
-        RETURNS trigger
-        AS 'MODULE_PATHNAME'
-        LANGUAGE 'C';
+CREATE OR REPLACE FUNCTION cache_bbox()
+       RETURNS trigger
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C';
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Cache_BBox()
+CREATE OR REPLACE FUNCTION ST_Cache_BBox()
        RETURNS trigger
        AS 'MODULE_PATHNAME','cache_bbox'
        LANGUAGE 'C';
@@ -1781,260 +1781,260 @@ CREATEFUNCTION ST_Cache_BBox()
 ------------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MakePoint(float8, float8)
+CREATE OR REPLACE FUNCTION MakePoint(float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MakePoint(float8, float8)
+CREATE OR REPLACE FUNCTION ST_MakePoint(float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MakePoint(float8, float8, float8)
+CREATE OR REPLACE FUNCTION MakePoint(float8, float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MakePoint(float8, float8, float8)
+CREATE OR REPLACE FUNCTION ST_MakePoint(float8, float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MakePoint(float8, float8, float8, float8)
+CREATE OR REPLACE FUNCTION MakePoint(float8, float8, float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MakePoint(float8, float8, float8, float8)
+CREATE OR REPLACE FUNCTION ST_MakePoint(float8, float8, float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MakePointM(float8, float8, float8)
+CREATE OR REPLACE FUNCTION MakePointM(float8, float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoint3dm'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
        
 -- Availability: 1.3.4
-CREATEFUNCTION ST_MakePointM(float8, float8, float8)
+CREATE OR REPLACE FUNCTION ST_MakePointM(float8, float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoint3dm'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MakeBox2d(geometry, geometry)
+CREATE OR REPLACE FUNCTION MakeBox2d(geometry, geometry)
        RETURNS box2d
        AS 'MODULE_PATHNAME', 'BOX2DFLOAT4_construct'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MakeBox2d(geometry, geometry)
+CREATE OR REPLACE FUNCTION ST_MakeBox2d(geometry, geometry)
        RETURNS box2d
        AS 'MODULE_PATHNAME', 'BOX2DFLOAT4_construct'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MakeBox3d(geometry, geometry)
+CREATE OR REPLACE FUNCTION MakeBox3d(geometry, geometry)
        RETURNS box3d
        AS 'MODULE_PATHNAME', 'BOX3D_construct'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MakeBox3d(geometry, geometry)
+CREATE OR REPLACE FUNCTION ST_MakeBox3d(geometry, geometry)
        RETURNS box3d
        AS 'MODULE_PATHNAME', 'BOX3D_construct'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION makeline_garray (geometry[])
+CREATE OR REPLACE FUNCTION makeline_garray (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makeline_garray'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MakeLine_GArray (geometry[])
+CREATE OR REPLACE FUNCTION ST_MakeLine_GArray (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makeline_garray'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Availability: 1.4.0
-CREATEFUNCTION ST_MakeLine (geometry[])
+CREATE OR REPLACE FUNCTION ST_MakeLine (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makeline_garray'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LineFromMultiPoint(geometry)
+CREATE OR REPLACE FUNCTION LineFromMultiPoint(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_line_from_mpoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_LineFromMultiPoint(geometry)
+CREATE OR REPLACE FUNCTION ST_LineFromMultiPoint(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_line_from_mpoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MakeLine(geometry, geometry)
+CREATE OR REPLACE FUNCTION MakeLine(geometry, geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makeline'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MakeLine(geometry, geometry)
+CREATE OR REPLACE FUNCTION ST_MakeLine(geometry, geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makeline'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AddPoint(geometry, geometry)
+CREATE OR REPLACE FUNCTION AddPoint(geometry, geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_addpoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AddPoint(geometry, geometry)
+CREATE OR REPLACE FUNCTION ST_AddPoint(geometry, geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_addpoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AddPoint(geometry, geometry, integer)
+CREATE OR REPLACE FUNCTION AddPoint(geometry, geometry, integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_addpoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AddPoint(geometry, geometry, integer)
+CREATE OR REPLACE FUNCTION ST_AddPoint(geometry, geometry, integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_addpoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION RemovePoint(geometry, integer)
+CREATE OR REPLACE FUNCTION RemovePoint(geometry, integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_removepoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_RemovePoint(geometry, integer)
+CREATE OR REPLACE FUNCTION ST_RemovePoint(geometry, integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_removepoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION SetPoint(geometry, integer, geometry)
+CREATE OR REPLACE FUNCTION SetPoint(geometry, integer, geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_setpoint_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_SetPoint(geometry, integer, geometry)
+CREATE OR REPLACE FUNCTION ST_SetPoint(geometry, integer, geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_setpoint_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MakePolygon(geometry, geometry[])
+CREATE OR REPLACE FUNCTION MakePolygon(geometry, geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MakePolygon(geometry, geometry[])
+CREATE OR REPLACE FUNCTION ST_MakePolygon(geometry, geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MakePolygon(geometry)
+CREATE OR REPLACE FUNCTION MakePolygon(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MakePolygon(geometry)
+CREATE OR REPLACE FUNCTION ST_MakePolygon(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoly'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION BuildArea(geometry)
+CREATE OR REPLACE FUNCTION BuildArea(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_buildarea'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_BuildArea(geometry)
+CREATE OR REPLACE FUNCTION ST_BuildArea(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_buildarea'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Polygonize_GArray (geometry[])
+CREATE OR REPLACE FUNCTION Polygonize_GArray (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'polygonize_garray'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Polygonize_GArray (geometry[])
+CREATE OR REPLACE FUNCTION ST_Polygonize_GArray (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'polygonize_garray'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Availability: 1.4.0
-CREATEFUNCTION ST_Polygonize (geometry[])
+CREATE OR REPLACE FUNCTION ST_Polygonize (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'polygonize_garray'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LineMerge(geometry)
+CREATE OR REPLACE FUNCTION LineMerge(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'linemerge'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_LineMerge(geometry)
+CREATE OR REPLACE FUNCTION ST_LineMerge(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'linemerge'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 
 CREATE TYPE geometry_dump AS (path integer[], geom geometry);
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Dump(geometry)
+CREATE OR REPLACE FUNCTION Dump(geometry)
        RETURNS SETOF geometry_dump
        AS 'MODULE_PATHNAME', 'LWGEOM_dump'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Dump(geometry)
+CREATE OR REPLACE FUNCTION ST_Dump(geometry)
        RETURNS SETOF geometry_dump
        AS 'MODULE_PATHNAME', 'LWGEOM_dump'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION DumpRings(geometry)
+CREATE OR REPLACE FUNCTION DumpRings(geometry)
        RETURNS SETOF geometry_dump
        AS 'MODULE_PATHNAME', 'LWGEOM_dump_rings'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_DumpRings(geometry)
+CREATE OR REPLACE FUNCTION ST_DumpRings(geometry)
        RETURNS SETOF geometry_dump
        AS 'MODULE_PATHNAME', 'LWGEOM_dump_rings'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 ------------------------------------------------------------------------
 
@@ -2043,28 +2043,28 @@ CREATEFUNCTION ST_DumpRings(geometry)
 --
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION combine_bbox(box2d,geometry)
+CREATE OR REPLACE FUNCTION combine_bbox(box2d,geometry)
        RETURNS box2d
        AS 'MODULE_PATHNAME', 'BOX2DFLOAT4_combine'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Combine_BBox(box2d,geometry)
+CREATE OR REPLACE FUNCTION ST_Combine_BBox(box2d,geometry)
        RETURNS box2d
        AS 'MODULE_PATHNAME', 'BOX2DFLOAT4_combine'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Temporary hack function
-CREATEFUNCTION combine_bbox(box3d_extent,geometry)
+CREATE OR REPLACE FUNCTION combine_bbox(box3d_extent,geometry)
        RETURNS box3d_extent
        AS 'MODULE_PATHNAME', 'BOX3D_combine'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Temporary hack function
-CREATEFUNCTION ST_Combine_BBox(box3d_extent,geometry)
+CREATE OR REPLACE FUNCTION ST_Combine_BBox(box3d_extent,geometry)
        RETURNS box3d_extent
        AS 'MODULE_PATHNAME', 'BOX3D_combine'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Deprecation in 1.2.3
 CREATE AGGREGATE Extent(
@@ -2081,16 +2081,16 @@ CREATE AGGREGATE ST_Extent(
        );
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION combine_bbox(box3d,geometry)
+CREATE OR REPLACE FUNCTION combine_bbox(box3d,geometry)
        RETURNS box3d
        AS 'MODULE_PATHNAME', 'BOX3D_combine'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Combine_BBox(box3d,geometry)
+CREATE OR REPLACE FUNCTION ST_Combine_BBox(box3d,geometry)
        RETURNS box3d
        AS 'MODULE_PATHNAME', 'BOX3D_combine'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Deprecation in 1.2.3
 CREATE AGGREGATE Extent3d(
@@ -2110,33 +2110,33 @@ CREATE AGGREGATE ST_Extent3d(
 -- ESTIMATED_EXTENT( <schema name>, <table name>, <column name> )
 -----------------------------------------------------------------------
 -- Deprecation in 1.2.3
-CREATEFUNCTION estimated_extent(text,text,text) RETURNS box2d AS
+CREATE OR REPLACE FUNCTION estimated_extent(text,text,text) RETURNS box2d AS
        'MODULE_PATHNAME', 'LWGEOM_estimated_extent'
-       LANGUAGE 'C' _IMMUTABLE_STRICT _SECURITY_DEFINER;
+       LANGUAGE 'C' IMMUTABLE STRICT SECURITY DEFINER;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_estimated_extent(text,text,text) RETURNS box2d AS
+CREATE OR REPLACE FUNCTION ST_estimated_extent(text,text,text) RETURNS box2d AS
        'MODULE_PATHNAME', 'LWGEOM_estimated_extent'
-       LANGUAGE 'C' _IMMUTABLE_STRICT _SECURITY_DEFINER;
+       LANGUAGE 'C' IMMUTABLE STRICT SECURITY DEFINER;
 
 -----------------------------------------------------------------------
 -- ESTIMATED_EXTENT( <table name>, <column name> )
 -----------------------------------------------------------------------
 -- Deprecation in 1.2.3
-CREATEFUNCTION estimated_extent(text,text) RETURNS box2d AS
+CREATE OR REPLACE FUNCTION estimated_extent(text,text) RETURNS box2d AS
        'MODULE_PATHNAME', 'LWGEOM_estimated_extent'
-       LANGUAGE 'C' _IMMUTABLE_STRICT _SECURITY_DEFINER; 
+       LANGUAGE 'C' IMMUTABLE STRICT SECURITY DEFINER; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_estimated_extent(text,text) RETURNS box2d AS
+CREATE OR REPLACE FUNCTION ST_estimated_extent(text,text) RETURNS box2d AS
        'MODULE_PATHNAME', 'LWGEOM_estimated_extent'
-       LANGUAGE 'C' _IMMUTABLE_STRICT _SECURITY_DEFINER; 
+       LANGUAGE 'C' IMMUTABLE STRICT SECURITY DEFINER; 
 
 -----------------------------------------------------------------------
 -- FIND_EXTENT( <schema name>, <table name>, <column name> )
 -----------------------------------------------------------------------
 -- Deprecation in 1.2.3
-CREATEFUNCTION find_extent(text,text,text) RETURNS box2d AS
+CREATE OR REPLACE FUNCTION find_extent(text,text,text) RETURNS box2d AS
 $$
 DECLARE
        schemaname alias for $1;
@@ -2150,10 +2150,10 @@ BEGIN
        END LOOP; 
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_find_extent(text,text,text) RETURNS box2d AS
+CREATE OR REPLACE FUNCTION ST_find_extent(text,text,text) RETURNS box2d AS
 $$
 DECLARE
        schemaname alias for $1;
@@ -2167,14 +2167,14 @@ BEGIN
        END LOOP; 
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 
 -----------------------------------------------------------------------
 -- FIND_EXTENT( <table name>, <column name> )
 -----------------------------------------------------------------------
 -- Deprecation in 1.2.3
-CREATEFUNCTION find_extent(text,text) RETURNS box2d AS
+CREATE OR REPLACE FUNCTION find_extent(text,text) RETURNS box2d AS
 $$
 DECLARE
        tablename alias for $1;
@@ -2187,10 +2187,10 @@ BEGIN
        END LOOP; 
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_find_extent(text,text) RETURNS box2d AS
+CREATE OR REPLACE FUNCTION ST_find_extent(text,text) RETURNS box2d AS
 $$
 DECLARE
        tablename alias for $1;
@@ -2203,7 +2203,7 @@ BEGIN
        END LOOP; 
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 -------------------------------------------------------------------
 -- SPATIAL_REF_SYS
@@ -2243,12 +2243,12 @@ CREATE TABLE geometry_columns (
 -- way, but nobody can rely on it since old postgis versions did
 -- not do that.
 -----------------------------------------------------------------------
-CREATEFUNCTION rename_geometry_table_constraints() RETURNS text
+CREATE OR REPLACE FUNCTION rename_geometry_table_constraints() RETURNS text
 AS 
 $$
 SELECT 'rename_geometry_table_constraint() is obsoleted'::text
 $$
-LANGUAGE 'SQL' _IMMUTABLE;
+LANGUAGE 'SQL' IMMUTABLE;
 
 -----------------------------------------------------------------------
 -- FIX_GEOMETRY_COLUMNS() 
@@ -2266,7 +2266,7 @@ LANGUAGE 'SQL' _IMMUTABLE;
 --     
 -- 
 -----------------------------------------------------------------------
-CREATEFUNCTION fix_geometry_columns() RETURNS text
+CREATE OR REPLACE FUNCTION fix_geometry_columns() RETURNS text
 AS 
 $$
 DECLARE
@@ -2285,35 +2285,35 @@ BEGIN
        UPDATE geometry_columns SET f_table_schema = n.nspname
                FROM pg_namespace n, pg_class c, pg_attribute a,
                        pg_constraint sridcheck, pg_constraint typecheck
-                WHERE ( f_table_schema is NULL
+               WHERE ( f_table_schema is NULL
                OR f_table_schema = ''
-                OR f_table_schema NOT IN (
-                        SELECT nspname::varchar
-                        FROM pg_namespace nn, pg_class cc, pg_attribute aa
-                        WHERE cc.relnamespace = nn.oid
-                        AND cc.relname = f_table_name::name
-                        AND aa.attrelid = cc.oid
-                        AND aa.attname = f_geometry_column::name))
-                AND f_table_name::name = c.relname
-                AND c.oid = a.attrelid
-                AND c.relnamespace = n.oid
-                AND f_geometry_column::name = a.attname
-
-                AND sridcheck.conrelid = c.oid
+               OR f_table_schema NOT IN (
+                       SELECT nspname::varchar
+                       FROM pg_namespace nn, pg_class cc, pg_attribute aa
+                       WHERE cc.relnamespace = nn.oid
+                       AND cc.relname = f_table_name::name
+                       AND aa.attrelid = cc.oid
+                       AND aa.attname = f_geometry_column::name))
+               AND f_table_name::name = c.relname
+               AND c.oid = a.attrelid
+               AND c.relnamespace = n.oid
+               AND f_geometry_column::name = a.attname
+
+               AND sridcheck.conrelid = c.oid
                AND sridcheck.consrc LIKE '(srid(% = %)'
-                AND sridcheck.consrc ~ textcat(' = ', srid::text)
+               AND sridcheck.consrc ~ textcat(' = ', srid::text)
 
-                AND typecheck.conrelid = c.oid
+               AND typecheck.conrelid = c.oid
                AND typecheck.consrc LIKE
                '((geometrytype(%) = ''%''::text) OR (% IS NULL))'
-                AND typecheck.consrc ~ textcat(' = ''', type::text)
+               AND typecheck.consrc ~ textcat(' = ''', type::text)
 
-                AND NOT EXISTS (
-                        SELECT oid FROM geometry_columns gc
-                        WHERE c.relname::varchar = gc.f_table_name
-                        AND n.nspname::varchar = gc.f_table_schema
-                        AND a.attname::varchar = gc.f_geometry_column
-                );
+               AND NOT EXISTS (
+                       SELECT oid FROM geometry_columns gc
+                       WHERE c.relname::varchar = gc.f_table_name
+                       AND n.nspname::varchar = gc.f_table_schema
+                       AND a.attname::varchar = gc.f_geometry_column
+               );
 
        GET DIAGNOSTICS foundschema = ROW_COUNT;
 
@@ -2335,94 +2335,94 @@ LANGUAGE 'plpgsql' _VOLATILE;
 -- geometry_columns table.  
 -- Availability: 1.4.0
 -----------------------------------------------------------------------
-CREATEFUNCTION populate_geometry_columns()
-  RETURNS text AS
+CREATE OR REPLACE FUNCTION populate_geometry_columns()
+       RETURNS text AS
 $$
 DECLARE
-    inserted    integer;
-    oldcount    integer;
-    probed      integer;
-    stale       integer;
-    gcs         RECORD;
-    gc          RECORD;
-    gsrid       integer;
-    gndims      integer;
-    gtype       text;
-    query       text;
-    gc_is_valid boolean;
-    
+       inserted    integer;
+       oldcount    integer;
+       probed      integer;
+       stale       integer;
+       gcs         RECORD;
+       gc          RECORD;
+       gsrid       integer;
+       gndims      integer;
+       gtype       text;
+       query       text;
+       gc_is_valid boolean;
+       
 BEGIN
-    SELECT count(*) INTO oldcount FROM geometry_columns;
-    inserted := 0;
-
-    EXECUTE 'TRUNCATE geometry_columns';
-
-    -- Count the number of geometry columns in all tables and views
-    SELECT count(DISTINCT c.oid) INTO probed
-        FROM pg_class c, 
-             pg_attribute a, 
-             pg_type t, 
-             pg_namespace n
-        WHERE (c.relkind = 'r' OR c.relkind = 'v')
-        AND t.typname = 'geometry'
-        AND a.attisdropped = false
-        AND a.atttypid = t.oid
-        AND a.attrelid = c.oid
-        AND c.relnamespace = n.oid
+       SELECT count(*) INTO oldcount FROM geometry_columns;
+       inserted := 0;
+
+       EXECUTE 'TRUNCATE geometry_columns';
+
+       -- Count the number of geometry columns in all tables and views
+       SELECT count(DISTINCT c.oid) INTO probed
+       FROM pg_class c, 
+            pg_attribute a, 
+            pg_type t, 
+            pg_namespace n
+       WHERE (c.relkind = 'r' OR c.relkind = 'v')
+       AND t.typname = 'geometry'
+       AND a.attisdropped = false
+       AND a.atttypid = t.oid
+       AND a.attrelid = c.oid
+       AND c.relnamespace = n.oid
        AND n.nspname NOT ILIKE 'pg_temp%';
 
-    -- Iterate through all non-dropped geometry columns
-    RAISE DEBUG 'Processing Tables.....';
-
-    FOR gcs IN 
-        SELECT DISTINCT ON (c.oid) c.oid, n.nspname, c.relname
-            FROM pg_class c, 
-                 pg_attribute a, 
-                 pg_type t, 
-                 pg_namespace n
-            WHERE c.relkind = 'r'
-            AND t.typname = 'geometry'
-            AND a.attisdropped = false
-            AND a.atttypid = t.oid
-            AND a.attrelid = c.oid
-            AND c.relnamespace = n.oid
+       -- Iterate through all non-dropped geometry columns
+       RAISE DEBUG 'Processing Tables.....';
+
+       FOR gcs IN 
+       SELECT DISTINCT ON (c.oid) c.oid, n.nspname, c.relname
+           FROM pg_class c, 
+                pg_attribute a, 
+                pg_type t, 
+                pg_namespace n
+           WHERE c.relkind = 'r'
+           AND t.typname = 'geometry'
+           AND a.attisdropped = false
+           AND a.atttypid = t.oid
+           AND a.attrelid = c.oid
+           AND c.relnamespace = n.oid
            AND n.nspname NOT ILIKE 'pg_temp%'
-        LOOP
-        
-        inserted := inserted + populate_geometry_columns(gcs.oid);
-    END LOOP;
-    
-    -- Add views to geometry columns table
-    RAISE DEBUG 'Processing Views.....';
-    FOR gcs IN 
-        SELECT DISTINCT ON (c.oid) c.oid, n.nspname, c.relname
-            FROM pg_class c, 
-                 pg_attribute a, 
-                 pg_type t, 
-                 pg_namespace n
-            WHERE c.relkind = 'v'
-            AND t.typname = 'geometry'
-            AND a.attisdropped = false
-            AND a.atttypid = t.oid
-            AND a.attrelid = c.oid
-            AND c.relnamespace = n.oid
-        LOOP            
-            
-        inserted := inserted + populate_geometry_columns(gcs.oid);
-    END LOOP;
-
-    IF oldcount > inserted THEN
-        stale = oldcount-inserted;
-    ELSE
-        stale = 0;
-    END IF;
-
-    RETURN 'probed:' ||probed|| ' inserted:'||inserted|| ' conflicts:'||probed-inserted|| ' deleted:'||stale;
+       LOOP
+       
+       inserted := inserted + populate_geometry_columns(gcs.oid);
+       END LOOP;
+       
+       -- Add views to geometry columns table
+       RAISE DEBUG 'Processing Views.....';
+       FOR gcs IN 
+       SELECT DISTINCT ON (c.oid) c.oid, n.nspname, c.relname
+           FROM pg_class c, 
+                pg_attribute a, 
+                pg_type t, 
+                pg_namespace n
+           WHERE c.relkind = 'v'
+           AND t.typname = 'geometry'
+           AND a.attisdropped = false
+           AND a.atttypid = t.oid
+           AND a.attrelid = c.oid
+           AND c.relnamespace = n.oid
+       LOOP            
+           
+       inserted := inserted + populate_geometry_columns(gcs.oid);
+       END LOOP;
+
+       IF oldcount > inserted THEN
+       stale = oldcount-inserted;
+       ELSE
+       stale = 0;
+       END IF;
+
+       RETURN 'probed:' ||probed|| ' inserted:'||inserted|| ' conflicts:'||probed-inserted|| ' deleted:'||stale;
 END
 
 $$
 LANGUAGE 'plpgsql' _VOLATILE;
-  
+       
 -----------------------------------------------------------------------
 -- POPULATE_GEOMETRY_COLUMNS(tbl_oid oid) 
 -----------------------------------------------------------------------
@@ -2445,220 +2445,220 @@ LANGUAGE 'plpgsql' _VOLATILE;
 -- table. 
 -- Availability: 1.4.0
 -----------------------------------------------------------------------
-CREATEFUNCTION populate_geometry_columns(tbl_oid oid)
-  RETURNS integer AS
+CREATE OR REPLACE FUNCTION populate_geometry_columns(tbl_oid oid)
+       RETURNS integer AS
 $$
 DECLARE
-    gcs         RECORD;
-    gc          RECORD;
-    gsrid       integer;
-    gndims      integer;
-    gtype       text;
-    query       text;
-    gc_is_valid boolean;
-    inserted    integer;
-    
+       gcs         RECORD;
+       gc          RECORD;
+       gsrid       integer;
+       gndims      integer;
+       gtype       text;
+       query       text;
+       gc_is_valid boolean;
+       inserted    integer;
+       
 BEGIN
-    inserted := 0;
-    
-    -- Iterate through all geometry columns in this table
-    FOR gcs IN 
-        SELECT n.nspname, c.relname, a.attname
-            FROM pg_class c, 
-                 pg_attribute a, 
-                 pg_type t, 
-                 pg_namespace n
-            WHERE c.relkind = 'r'
-            AND t.typname = 'geometry'
-            AND a.attisdropped = false
-            AND a.atttypid = t.oid
-            AND a.attrelid = c.oid
-            AND c.relnamespace = n.oid
+       inserted := 0;
+       
+       -- Iterate through all geometry columns in this table
+       FOR gcs IN 
+       SELECT n.nspname, c.relname, a.attname
+           FROM pg_class c, 
+                pg_attribute a, 
+                pg_type t, 
+                pg_namespace n
+           WHERE c.relkind = 'r'
+           AND t.typname = 'geometry'
+           AND a.attisdropped = false
+           AND a.atttypid = t.oid
+           AND a.attrelid = c.oid
+           AND c.relnamespace = n.oid
            AND n.nspname NOT ILIKE 'pg_temp%'
-            AND c.oid = tbl_oid
-        LOOP
-        
-        RAISE DEBUG 'Processing table %.%.%', gcs.nspname, gcs.relname, gcs.attname;
-
-        DELETE FROM geometry_columns 
-          WHERE f_table_schema = quote_ident(gcs.nspname) 
-          AND f_table_name = quote_ident(gcs.relname)
-          AND f_geometry_column = quote_ident(gcs.attname);
-        
-        gc_is_valid := true;
-        
-        -- Try to find srid check from system tables (pg_constraint)
-        gsrid := 
-            (SELECT replace(replace(split_part(s.consrc, ' = ', 2), ')', ''), '(', '') 
-             FROM pg_class c, pg_namespace n, pg_attribute a, pg_constraint s 
-             WHERE n.nspname = gcs.nspname 
-             AND c.relname = gcs.relname 
-             AND a.attname = gcs.attname 
-             AND a.attrelid = c.oid
-             AND s.connamespace = n.oid
-             AND s.conrelid = c.oid
-             AND a.attnum = ANY (s.conkey)
-             AND s.consrc LIKE '%srid(% = %');
-        IF (gsrid IS NULL) THEN 
-            -- Try to find srid from the geometry itself
-            EXECUTE 'SELECT public.srid(' || quote_ident(gcs.attname) || ') 
-                     FROM ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
-                     WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
-                INTO gc;
-            gsrid := gc.srid;
-            
-            -- Try to apply srid check to column
-            IF (gsrid IS NOT NULL) THEN
-                BEGIN
-                    EXECUTE 'ALTER TABLE ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
-                             ADD CONSTRAINT ' || quote_ident('enforce_srid_' || gcs.attname) || ' 
-                             CHECK (srid(' || quote_ident(gcs.attname) || ') = ' || gsrid || ')';
-                EXCEPTION
-                    WHEN check_violation THEN
-                        RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not apply constraint CHECK (srid(%) = %)', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname), quote_ident(gcs.attname), gsrid;
-                        gc_is_valid := false;
-                END;
-            END IF;
-        END IF;
-        
-        -- Try to find ndims check from system tables (pg_constraint)
-        gndims := 
-            (SELECT replace(split_part(s.consrc, ' = ', 2), ')', '') 
-             FROM pg_class c, pg_namespace n, pg_attribute a, pg_constraint s 
-             WHERE n.nspname = gcs.nspname 
-             AND c.relname = gcs.relname 
-             AND a.attname = gcs.attname 
-             AND a.attrelid = c.oid
-             AND s.connamespace = n.oid
-             AND s.conrelid = c.oid
-             AND a.attnum = ANY (s.conkey)
-             AND s.consrc LIKE '%ndims(% = %');
-        IF (gndims IS NULL) THEN
-            -- Try to find ndims from the geometry itself
-            EXECUTE 'SELECT public.ndims(' || quote_ident(gcs.attname) || ') 
-                     FROM ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
-                     WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
-                INTO gc;
-            gndims := gc.ndims;
-            
-            -- Try to apply ndims check to column
-            IF (gndims IS NOT NULL) THEN
-                BEGIN
-                    EXECUTE 'ALTER TABLE ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
-                             ADD CONSTRAINT ' || quote_ident('enforce_dims_' || gcs.attname) || ' 
-                             CHECK (ndims(' || quote_ident(gcs.attname) || ') = '||gndims||')';
-                EXCEPTION
-                    WHEN check_violation THEN
-                        RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not apply constraint CHECK (ndims(%) = %)', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname), quote_ident(gcs.attname), gndims;
-                        gc_is_valid := false;
-                END;
-            END IF;
-        END IF;
-        
-        -- Try to find geotype check from system tables (pg_constraint)
-        gtype := 
-            (SELECT replace(split_part(s.consrc, '''', 2), ')', '') 
-             FROM pg_class c, pg_namespace n, pg_attribute a, pg_constraint s 
-             WHERE n.nspname = gcs.nspname 
-             AND c.relname = gcs.relname 
-             AND a.attname = gcs.attname 
-             AND a.attrelid = c.oid
-             AND s.connamespace = n.oid
-             AND s.conrelid = c.oid
-             AND a.attnum = ANY (s.conkey)
-             AND s.consrc LIKE '%geometrytype(% = %');
-        IF (gtype IS NULL) THEN
-            -- Try to find geotype from the geometry itself
-            EXECUTE 'SELECT public.geometrytype(' || quote_ident(gcs.attname) || ') 
-                     FROM ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
-                     WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
-                INTO gc;
-            gtype := gc.geometrytype;
-            --IF (gtype IS NULL) THEN
-            --    gtype := 'GEOMETRY';
-            --END IF;
-            
-            -- Try to apply geometrytype check to column
-            IF (gtype IS NOT NULL) THEN
-                BEGIN
-                    EXECUTE 'ALTER TABLE ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
-                    ADD CONSTRAINT ' || quote_ident('enforce_geotype_' || gcs.attname) || ' 
-                    CHECK ((geometrytype(' || quote_ident(gcs.attname) || ') = ' || quote_literal(gtype) || ') OR (' || quote_ident(gcs.attname) || ' IS NULL))';
-                EXCEPTION
-                    WHEN check_violation THEN
-                        -- No geometry check can be applied. This column contains a number of geometry types.
-                        RAISE WARNING 'Could not add geometry type check (%) to table column: %.%.%', gtype, quote_ident(gcs.nspname),quote_ident(gcs.relname),quote_ident(gcs.attname);
-                END;
-            END IF;
-        END IF;
-                
-        IF (gsrid IS NULL) THEN             
-            RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine the srid', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
-        ELSIF (gndims IS NULL) THEN
-            RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine the number of dimensions', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
-        ELSIF (gtype IS NULL) THEN
-            RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine the geometry type', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
-        ELSE
-            -- Only insert into geometry_columns if table constraints could be applied.
-            IF (gc_is_valid) THEN
-                INSERT INTO geometry_columns (f_table_catalog,f_table_schema, f_table_name, f_geometry_column, coord_dimension, srid, type) 
-                VALUES ('', gcs.nspname, gcs.relname, gcs.attname, gndims, gsrid, gtype);
-                inserted := inserted + 1;
-            END IF;
-        END IF;
-    END LOOP;
-
-    -- Add views to geometry columns table
-    FOR gcs IN 
-        SELECT n.nspname, c.relname, a.attname
-            FROM pg_class c, 
-                 pg_attribute a, 
-                 pg_type t, 
-                 pg_namespace n
-            WHERE c.relkind = 'v'
-            AND t.typname = 'geometry'
-            AND a.attisdropped = false
-            AND a.atttypid = t.oid
-            AND a.attrelid = c.oid
-            AND c.relnamespace = n.oid
+           AND c.oid = tbl_oid
+       LOOP
+       
+       RAISE DEBUG 'Processing table %.%.%', gcs.nspname, gcs.relname, gcs.attname;
+
+       DELETE FROM geometry_columns 
+         WHERE f_table_schema = quote_ident(gcs.nspname) 
+         AND f_table_name = quote_ident(gcs.relname)
+         AND f_geometry_column = quote_ident(gcs.attname);
+       
+       gc_is_valid := true;
+       
+       -- Try to find srid check from system tables (pg_constraint)
+       gsrid := 
+           (SELECT replace(replace(split_part(s.consrc, ' = ', 2), ')', ''), '(', '') 
+            FROM pg_class c, pg_namespace n, pg_attribute a, pg_constraint s 
+            WHERE n.nspname = gcs.nspname 
+            AND c.relname = gcs.relname 
+            AND a.attname = gcs.attname 
+            AND a.attrelid = c.oid
+            AND s.connamespace = n.oid
+            AND s.conrelid = c.oid
+            AND a.attnum = ANY (s.conkey)
+            AND s.consrc LIKE '%srid(% = %');
+       IF (gsrid IS NULL) THEN 
+           -- Try to find srid from the geometry itself
+           EXECUTE 'SELECT public.srid(' || quote_ident(gcs.attname) || ') 
+                    FROM ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
+                    WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
+               INTO gc;
+           gsrid := gc.srid;
+           
+           -- Try to apply srid check to column
+           IF (gsrid IS NOT NULL) THEN
+               BEGIN
+                   EXECUTE 'ALTER TABLE ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
+                            ADD CONSTRAINT ' || quote_ident('enforce_srid_' || gcs.attname) || ' 
+                            CHECK (srid(' || quote_ident(gcs.attname) || ') = ' || gsrid || ')';
+               EXCEPTION
+                   WHEN check_violation THEN
+                       RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not apply constraint CHECK (srid(%) = %)', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname), quote_ident(gcs.attname), gsrid;
+                       gc_is_valid := false;
+               END;
+           END IF;
+       END IF;
+       
+       -- Try to find ndims check from system tables (pg_constraint)
+       gndims := 
+           (SELECT replace(split_part(s.consrc, ' = ', 2), ')', '') 
+            FROM pg_class c, pg_namespace n, pg_attribute a, pg_constraint s 
+            WHERE n.nspname = gcs.nspname 
+            AND c.relname = gcs.relname 
+            AND a.attname = gcs.attname 
+            AND a.attrelid = c.oid
+            AND s.connamespace = n.oid
+            AND s.conrelid = c.oid
+            AND a.attnum = ANY (s.conkey)
+            AND s.consrc LIKE '%ndims(% = %');
+       IF (gndims IS NULL) THEN
+           -- Try to find ndims from the geometry itself
+           EXECUTE 'SELECT public.ndims(' || quote_ident(gcs.attname) || ') 
+                    FROM ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
+                    WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
+               INTO gc;
+           gndims := gc.ndims;
+           
+           -- Try to apply ndims check to column
+           IF (gndims IS NOT NULL) THEN
+               BEGIN
+                   EXECUTE 'ALTER TABLE ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
+                            ADD CONSTRAINT ' || quote_ident('enforce_dims_' || gcs.attname) || ' 
+                            CHECK (ndims(' || quote_ident(gcs.attname) || ') = '||gndims||')';
+               EXCEPTION
+                   WHEN check_violation THEN
+                       RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not apply constraint CHECK (ndims(%) = %)', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname), quote_ident(gcs.attname), gndims;
+                       gc_is_valid := false;
+               END;
+           END IF;
+       END IF;
+       
+       -- Try to find geotype check from system tables (pg_constraint)
+       gtype := 
+           (SELECT replace(split_part(s.consrc, '''', 2), ')', '') 
+            FROM pg_class c, pg_namespace n, pg_attribute a, pg_constraint s 
+            WHERE n.nspname = gcs.nspname 
+            AND c.relname = gcs.relname 
+            AND a.attname = gcs.attname 
+            AND a.attrelid = c.oid
+            AND s.connamespace = n.oid
+            AND s.conrelid = c.oid
+            AND a.attnum = ANY (s.conkey)
+            AND s.consrc LIKE '%geometrytype(% = %');
+       IF (gtype IS NULL) THEN
+           -- Try to find geotype from the geometry itself
+           EXECUTE 'SELECT public.geometrytype(' || quote_ident(gcs.attname) || ') 
+                    FROM ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
+                    WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
+               INTO gc;
+           gtype := gc.geometrytype;
+           --IF (gtype IS NULL) THEN
+           --    gtype := 'GEOMETRY';
+           --END IF;
+           
+           -- Try to apply geometrytype check to column
+           IF (gtype IS NOT NULL) THEN
+               BEGIN
+                   EXECUTE 'ALTER TABLE ONLY ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
+                   ADD CONSTRAINT ' || quote_ident('enforce_geotype_' || gcs.attname) || ' 
+                   CHECK ((geometrytype(' || quote_ident(gcs.attname) || ') = ' || quote_literal(gtype) || ') OR (' || quote_ident(gcs.attname) || ' IS NULL))';
+               EXCEPTION
+                   WHEN check_violation THEN
+                       -- No geometry check can be applied. This column contains a number of geometry types.
+                       RAISE WARNING 'Could not add geometry type check (%) to table column: %.%.%', gtype, quote_ident(gcs.nspname),quote_ident(gcs.relname),quote_ident(gcs.attname);
+               END;
+           END IF;
+       END IF;
+               
+       IF (gsrid IS NULL) THEN             
+           RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine the srid', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
+       ELSIF (gndims IS NULL) THEN
+           RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine the number of dimensions', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
+       ELSIF (gtype IS NULL) THEN
+           RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine the geometry type', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
+       ELSE
+           -- Only insert into geometry_columns if table constraints could be applied.
+           IF (gc_is_valid) THEN
+               INSERT INTO geometry_columns (f_table_catalog,f_table_schema, f_table_name, f_geometry_column, coord_dimension, srid, type) 
+               VALUES ('', gcs.nspname, gcs.relname, gcs.attname, gndims, gsrid, gtype);
+               inserted := inserted + 1;
+           END IF;
+       END IF;
+       END LOOP;
+
+       -- Add views to geometry columns table
+       FOR gcs IN 
+       SELECT n.nspname, c.relname, a.attname
+           FROM pg_class c, 
+                pg_attribute a, 
+                pg_type t, 
+                pg_namespace n
+           WHERE c.relkind = 'v'
+           AND t.typname = 'geometry'
+           AND a.attisdropped = false
+           AND a.atttypid = t.oid
+           AND a.attrelid = c.oid
+           AND c.relnamespace = n.oid
            AND n.nspname NOT ILIKE 'pg_temp%'
-            AND c.oid = tbl_oid
-        LOOP            
-            RAISE DEBUG 'Processing view %.%.%', gcs.nspname, gcs.relname, gcs.attname;
-
-            EXECUTE 'SELECT public.ndims(' || quote_ident(gcs.attname) || ') 
-                     FROM ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
-                     WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
-                INTO gc;
-            gndims := gc.ndims;
-            
-            EXECUTE 'SELECT public.srid(' || quote_ident(gcs.attname) || ') 
-                     FROM ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
-                     WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
-                INTO gc;
-            gsrid := gc.srid;
-            
-            EXECUTE 'SELECT public.geometrytype(' || quote_ident(gcs.attname) || ') 
-                     FROM ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
-                     WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
-                INTO gc;
-            gtype := gc.geometrytype;
-            
+           AND c.oid = tbl_oid
+       LOOP            
+           RAISE DEBUG 'Processing view %.%.%', gcs.nspname, gcs.relname, gcs.attname;
+
+           EXECUTE 'SELECT public.ndims(' || quote_ident(gcs.attname) || ') 
+                    FROM ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
+                    WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
+               INTO gc;
+           gndims := gc.ndims;
+           
+           EXECUTE 'SELECT public.srid(' || quote_ident(gcs.attname) || ') 
+                    FROM ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
+                    WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
+               INTO gc;
+           gsrid := gc.srid;
+           
+           EXECUTE 'SELECT public.geometrytype(' || quote_ident(gcs.attname) || ') 
+                    FROM ' || quote_ident(gcs.nspname) || '.' || quote_ident(gcs.relname) || ' 
+                    WHERE ' || quote_ident(gcs.attname) || ' IS NOT NULL LIMIT 1' 
+               INTO gc;
+           gtype := gc.geometrytype;
+           
            IF (gndims IS NULL) THEN
-                RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine ndims', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
-            ELSIF (gsrid IS NULL) THEN
-                RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine srid', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
-            ELSIF (gtype IS NULL) THEN
-                RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine gtype', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
-            ELSE
-                query := 'INSERT INTO geometry_columns (f_table_catalog,f_table_schema, f_table_name, f_geometry_column, coord_dimension, srid, type) ' ||
-                         'VALUES ('''', ' || quote_literal(gcs.nspname) || ',' || quote_literal(gcs.relname) || ',' || quote_literal(gcs.attname) || ',' || gndims || ',' || gsrid || ',' || quote_literal(gtype) || ')';
-                EXECUTE query;
-                inserted := inserted + 1;
-            END IF;
-    END LOOP;
-    
-    RETURN inserted;
+               RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine ndims', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
+           ELSIF (gsrid IS NULL) THEN
+               RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine srid', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
+           ELSIF (gtype IS NULL) THEN
+               RAISE WARNING 'Not inserting ''%'' in ''%.%'' into geometry_columns: could not determine gtype', quote_ident(gcs.attname), quote_ident(gcs.nspname), quote_ident(gcs.relname);
+           ELSE
+               query := 'INSERT INTO geometry_columns (f_table_catalog,f_table_schema, f_table_name, f_geometry_column, coord_dimension, srid, type) ' ||
+                        'VALUES ('''', ' || quote_literal(gcs.nspname) || ',' || quote_literal(gcs.relname) || ',' || quote_literal(gcs.attname) || ',' || gndims || ',' || gsrid || ',' || quote_literal(gtype) || ')';
+               EXECUTE query;
+               inserted := inserted + 1;
+           END IF;
+       END LOOP;
+       
+       RETURN inserted;
 END
 
 $$
@@ -2680,7 +2680,7 @@ LANGUAGE 'plpgsql' _VOLATILE;
 -- to have a fresh probe backup your geometry_columns, delete from
 -- it and probe.
 -----------------------------------------------------------------------
-CREATEFUNCTION probe_geometry_columns() RETURNS text AS
+CREATE OR REPLACE FUNCTION probe_geometry_columns() RETURNS text AS
 $$
 DECLARE
        inserted integer;
@@ -2738,12 +2738,12 @@ BEGIN
                AND typecheck.consrc LIKE
                '((geometrytype('||a.attname||') = ''%''::text) OR (% IS NULL))'
 
-                AND NOT EXISTS (
-                        SELECT oid FROM geometry_columns gc
-                        WHERE c.relname::varchar = gc.f_table_name
-                        AND n.nspname::varchar = gc.f_table_schema
-                        AND a.attname::varchar = gc.f_geometry_column
-                );
+               AND NOT EXISTS (
+                       SELECT oid FROM geometry_columns gc
+                       WHERE c.relname::varchar = gc.f_table_name
+                       AND n.nspname::varchar = gc.f_table_schema
+                       AND a.attname::varchar = gc.f_geometry_column
+               );
 
        GET DIAGNOSTICS inserted = ROW_COUNT;
 
@@ -2753,7 +2753,7 @@ BEGIN
                stale = 0;
        END IF;
 
-        RETURN 'probed:'||probed::text||
+       RETURN 'probed:'||probed::text||
                ' inserted:'||inserted::text||
                ' conflicts:'||(probed-inserted)::text||
                ' stale:'||stale::text;
@@ -2778,7 +2778,7 @@ LANGUAGE 'plpgsql' _VOLATILE;
 -- Should also check the precision grid (future expansion).
 --
 -----------------------------------------------------------------------
-CREATEFUNCTION AddGeometryColumn(varchar,varchar,varchar,varchar,integer,varchar,integer)
+CREATE OR REPLACE FUNCTION AddGeometryColumn(varchar,varchar,varchar,varchar,integer,varchar,integer)
        RETURNS text
        AS 
 $$
@@ -2970,7 +2970,7 @@ BEGIN
                ' DIMS:' || new_dim::text || ' ';
 END;
 $$
-LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' VOLATILE STRICT; 
 
 ----------------------------------------------------------------------------
 -- ADDGEOMETRYCOLUMN ( <schema>, <table>, <column>, <srid>, <type>, <dim> )
@@ -2980,7 +2980,7 @@ LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
 -- when catalogue is undefined
 --
 ----------------------------------------------------------------------------
-CREATEFUNCTION AddGeometryColumn(varchar,varchar,varchar,integer,varchar,integer) RETURNS text AS $$ 
+CREATE OR REPLACE FUNCTION AddGeometryColumn(varchar,varchar,varchar,integer,varchar,integer) RETURNS text AS $$ 
 DECLARE
        ret  text;
 BEGIN
@@ -2988,7 +2988,7 @@ BEGIN
        RETURN ret;
 END;
 $$
-LANGUAGE 'plpgsql' _STABLE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' STABLE STRICT; 
 
 ----------------------------------------------------------------------------
 -- ADDGEOMETRYCOLUMN ( <table>, <column>, <srid>, <type>, <dim> )
@@ -2998,7 +2998,7 @@ LANGUAGE 'plpgsql' _STABLE_STRICT; -- WITH (isstrict);
 -- when catalogue and schema are undefined
 --
 ----------------------------------------------------------------------------
-CREATEFUNCTION AddGeometryColumn(varchar,varchar,integer,varchar,integer) RETURNS text AS $$ 
+CREATE OR REPLACE FUNCTION AddGeometryColumn(varchar,varchar,integer,varchar,integer) RETURNS text AS $$ 
 DECLARE
        ret  text;
 BEGIN
@@ -3006,7 +3006,7 @@ BEGIN
        RETURN ret;
 END;
 $$
-LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' VOLATILE STRICT; 
 
 -----------------------------------------------------------------------
 -- DROPGEOMETRYCOLUMN
@@ -3018,7 +3018,7 @@ LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
 -- Make some silly enforcements on it for pgsql < 73
 --
 -----------------------------------------------------------------------
-CREATEFUNCTION DropGeometryColumn(varchar, varchar,varchar,varchar)
+CREATE OR REPLACE FUNCTION DropGeometryColumn(varchar, varchar,varchar,varchar)
        RETURNS text
        AS 
 $$
@@ -3077,7 +3077,7 @@ BEGIN
        
 END;
 $$
-LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' VOLATILE STRICT; 
 
 -----------------------------------------------------------------------
 -- DROPGEOMETRYCOLUMN
@@ -3088,7 +3088,7 @@ LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
 -- when catalogue is undefined
 --
 -----------------------------------------------------------------------
-CREATEFUNCTION DropGeometryColumn(varchar,varchar,varchar)
+CREATE OR REPLACE FUNCTION DropGeometryColumn(varchar,varchar,varchar)
        RETURNS text
        AS 
 $$
@@ -3099,7 +3099,7 @@ BEGIN
        RETURN ret;
 END;
 $$
-LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' VOLATILE STRICT; 
 
 -----------------------------------------------------------------------
 -- DROPGEOMETRYCOLUMN
@@ -3110,7 +3110,7 @@ LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
 -- when catalogue and schema is undefined. 
 --
 -----------------------------------------------------------------------
-CREATEFUNCTION DropGeometryColumn(varchar,varchar)
+CREATE OR REPLACE FUNCTION DropGeometryColumn(varchar,varchar)
        RETURNS text
        AS 
 $$
@@ -3121,7 +3121,7 @@ BEGIN
        RETURN ret;
 END;
 $$
-LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' VOLATILE STRICT; 
 
 -----------------------------------------------------------------------
 -- DROPGEOMETRYTABLE
@@ -3131,7 +3131,7 @@ LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
 -- Drop a table and all its references in geometry_columns
 --
 -----------------------------------------------------------------------
-CREATEFUNCTION DropGeometryTable(varchar, varchar,varchar)
+CREATE OR REPLACE FUNCTION DropGeometryTable(varchar, varchar,varchar)
        RETURNS text
        AS 
 $$
@@ -3166,7 +3166,7 @@ BEGIN
        
 END;
 $$
-LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' VOLATILE STRICT; 
 
 -----------------------------------------------------------------------
 -- DROPGEOMETRYTABLE
@@ -3176,7 +3176,7 @@ LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
 -- Drop a table and all its references in geometry_columns
 --
 -----------------------------------------------------------------------
-CREATEFUNCTION DropGeometryTable(varchar,varchar) RETURNS text AS 
+CREATE OR REPLACE FUNCTION DropGeometryTable(varchar,varchar) RETURNS text AS 
 $$ SELECT DropGeometryTable('',$1,$2) $$ 
 LANGUAGE 'sql' WITH (isstrict);
 
@@ -3189,9 +3189,9 @@ LANGUAGE 'sql' WITH (isstrict);
 -- For PG>=73 use current_schema()
 --
 -----------------------------------------------------------------------
-CREATEFUNCTION DropGeometryTable(varchar) RETURNS text AS 
+CREATE OR REPLACE FUNCTION DropGeometryTable(varchar) RETURNS text AS 
 $$ SELECT DropGeometryTable('','',$1) $$
-LANGUAGE 'sql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'sql' VOLATILE STRICT; 
 
 -----------------------------------------------------------------------
 -- UPDATEGEOMETRYSRID
@@ -3201,7 +3201,7 @@ LANGUAGE 'sql' _VOLATILE_STRICT; -- WITH (isstrict);
 -- Change SRID of all features in a spatially-enabled table
 --
 -----------------------------------------------------------------------
-CREATEFUNCTION UpdateGeometrySRID(varchar,varchar,varchar,varchar,integer)
+CREATE OR REPLACE FUNCTION UpdateGeometrySRID(varchar,varchar,varchar,varchar,integer)
        RETURNS text
        AS 
 $$
@@ -3279,13 +3279,13 @@ BEGIN
        
 END;
 $$
-LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' VOLATILE STRICT; 
 
 -----------------------------------------------------------------------
 -- UPDATEGEOMETRYSRID
 --   <schema>, <table>, <column>, <srid>
 -----------------------------------------------------------------------
-CREATEFUNCTION UpdateGeometrySRID(varchar,varchar,varchar,integer)
+CREATE OR REPLACE FUNCTION UpdateGeometrySRID(varchar,varchar,varchar,integer)
        RETURNS text
        AS $$ 
 DECLARE
@@ -3295,13 +3295,13 @@ BEGIN
        RETURN ret;
 END;
 $$
-LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' VOLATILE STRICT; 
 
 -----------------------------------------------------------------------
 -- UPDATEGEOMETRYSRID
 --   <table>, <column>, <srid>
 -----------------------------------------------------------------------
-CREATEFUNCTION UpdateGeometrySRID(varchar,varchar,integer)
+CREATE OR REPLACE FUNCTION UpdateGeometrySRID(varchar,varchar,integer)
        RETURNS text
        AS $$ 
 DECLARE
@@ -3311,91 +3311,91 @@ BEGIN
        RETURN ret;
 END;
 $$
-LANGUAGE 'plpgsql' _VOLATILE_STRICT; -- WITH (isstrict);
+LANGUAGE 'plpgsql' VOLATILE STRICT; 
 
 -----------------------------------------------------------------------
 -- FIND_SRID( <schema>, <table>, <geom col> )
 -----------------------------------------------------------------------
-CREATEFUNCTION find_srid(varchar,varchar,varchar) RETURNS int4 AS
+CREATE OR REPLACE FUNCTION find_srid(varchar,varchar,varchar) RETURNS int4 AS
 $$
 DECLARE
-   schem text;
-   tabl text;
-   sr int4;
+       schem text;
+       tabl text;
+       sr int4;
 BEGIN
-   IF $1 IS NULL THEN
-      RAISE EXCEPTION 'find_srid() - schema is NULL!';
-   END IF;
-   IF $2 IS NULL THEN
-      RAISE EXCEPTION 'find_srid() - table name is NULL!';
-   END IF;
-   IF $3 IS NULL THEN
-      RAISE EXCEPTION 'find_srid() - column name is NULL!';
-   END IF;
-   schem = $1;
-   tabl = $2;
+       IF $1 IS NULL THEN
+         RAISE EXCEPTION 'find_srid() - schema is NULL!';
+       END IF;
+       IF $2 IS NULL THEN
+         RAISE EXCEPTION 'find_srid() - table name is NULL!';
+       END IF;
+       IF $3 IS NULL THEN
+         RAISE EXCEPTION 'find_srid() - column name is NULL!';
+       END IF;
+       schem = $1;
+       tabl = $2;
 -- if the table contains a . and the schema is empty
 -- split the table into a schema and a table
 -- otherwise drop through to default behavior
-   IF ( schem = '' and tabl LIKE '%.%' ) THEN
-     schem = substr(tabl,1,strpos(tabl,'.')-1);
-     tabl = substr(tabl,length(schem)+2);
-   ELSE
-     schem = schem || '%';
-   END IF;
-
-   select SRID into sr from geometry_columns where f_table_schema like schem and f_table_name = tabl and f_geometry_column = $3;
-   IF NOT FOUND THEN
-       RAISE EXCEPTION 'find_srid() - couldnt find the corresponding SRID - is the geometry registered in the GEOMETRY_COLUMNS table?  Is there an uppercase/lowercase missmatch?';
-   END IF;
-  return sr;
+       IF ( schem = '' and tabl LIKE '%.%' ) THEN
+        schem = substr(tabl,1,strpos(tabl,'.')-1);
+        tabl = substr(tabl,length(schem)+2);
+       ELSE
+        schem = schem || '%';
+       END IF;
+
+       select SRID into sr from geometry_columns where f_table_schema like schem and f_table_name = tabl and f_geometry_column = $3;
+       IF NOT FOUND THEN
+          RAISE EXCEPTION 'find_srid() - couldnt find the corresponding SRID - is the geometry registered in the GEOMETRY_COLUMNS table?  Is there an uppercase/lowercase missmatch?';
+       END IF;
+       return sr;
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; -- WITH (iscachable); 
+LANGUAGE 'plpgsql' IMMUTABLE STRICT;  
 
 
 ---------------------------------------------------------------
 -- PROJ support
 ---------------------------------------------------------------
 
-CREATEFUNCTION get_proj4_from_srid(integer) RETURNS text AS
+CREATE OR REPLACE FUNCTION get_proj4_from_srid(integer) RETURNS text AS
 $$
 BEGIN
        RETURN proj4text::text FROM spatial_ref_sys WHERE srid= $1;
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 
 
-CREATEFUNCTION transform_geometry(geometry,text,text,int)
+CREATE OR REPLACE FUNCTION transform_geometry(geometry,text,text,int)
        RETURNS geometry
        AS 'MODULE_PATHNAME','transform_geom'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
-CREATEFUNCTION transform(geometry,integer)
+CREATE OR REPLACE FUNCTION transform(geometry,integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME','transform'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: transform(geometry,integer)
-CREATEFUNCTION ST_Transform(geometry,integer)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME','transform'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Transform(geometry,integer)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','transform'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 
 -----------------------------------------------------------------------
 -- POSTGIS_VERSION()
 -----------------------------------------------------------------------
 
-CREATEFUNCTION postgis_version() RETURNS text
+CREATE OR REPLACE FUNCTION postgis_version() RETURNS text
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
-CREATEFUNCTION postgis_proj_version() RETURNS text
+CREATE OR REPLACE FUNCTION postgis_proj_version() RETURNS text
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 --
 -- IMPORTANT:
@@ -3403,38 +3403,38 @@ CREATEFUNCTION postgis_proj_version() RETURNS text
 -- to extract version of postgis being installed.
 -- Do not modify this w/out also changing postgis_proc_upgrade.pl
 --
-CREATEFUNCTION postgis_scripts_installed() RETURNS text
-        AS _POSTGIS_SQL_SELECT_POSTGIS_SCRIPTS_VERSION 
-        LANGUAGE 'sql' _IMMUTABLE;
+CREATE OR REPLACE FUNCTION postgis_scripts_installed() RETURNS text
+       AS _POSTGIS_SQL_SELECT_POSTGIS_SCRIPTS_VERSION 
+       LANGUAGE 'sql' IMMUTABLE;
 
-CREATEFUNCTION postgis_lib_version() RETURNS text
+CREATE OR REPLACE FUNCTION postgis_lib_version() RETURNS text
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE; -- a new lib will require a new session
+       LANGUAGE 'C' IMMUTABLE; -- a new lib will require a new session
 
 -- NOTE: starting at 1.1.0 this is the same of postgis_lib_version()
-CREATEFUNCTION postgis_scripts_released() RETURNS text
+CREATE OR REPLACE FUNCTION postgis_scripts_released() RETURNS text
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
-CREATEFUNCTION postgis_uses_stats() RETURNS bool
+CREATE OR REPLACE FUNCTION postgis_uses_stats() RETURNS bool
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
-CREATEFUNCTION postgis_geos_version() RETURNS text
+CREATE OR REPLACE FUNCTION postgis_geos_version() RETURNS text
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
-CREATEFUNCTION postgis_scripts_build_date() RETURNS text
-        AS _POSTGIS_SQL_SELECT_POSTGIS_BUILD_DATE
-        LANGUAGE 'sql' _IMMUTABLE;
+CREATE OR REPLACE FUNCTION postgis_scripts_build_date() RETURNS text
+       AS _POSTGIS_SQL_SELECT_POSTGIS_BUILD_DATE
+       LANGUAGE 'sql' IMMUTABLE;
 
-CREATEFUNCTION postgis_lib_build_date() RETURNS text
+CREATE OR REPLACE FUNCTION postgis_lib_build_date() RETURNS text
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 
 
-CREATEFUNCTION postgis_full_version() RETURNS text
+CREATE OR REPLACE FUNCTION postgis_full_version() RETURNS text
 AS $$ 
 DECLARE
        libver text;
@@ -3476,174 +3476,174 @@ BEGIN
        RETURN fullver;
 END
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE;
+LANGUAGE 'plpgsql' IMMUTABLE;
 
 ---------------------------------------------------------------
 -- CASTS
 ---------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d(geometry)
-        RETURNS box2d
-        AS 'MODULE_PATHNAME','LWGEOM_to_BOX2DFLOAT4'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION box2d(geometry)
+       RETURNS box2d
+       AS 'MODULE_PATHNAME','LWGEOM_to_BOX2DFLOAT4'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d(geometry)
-        RETURNS box2d
-        AS 'MODULE_PATHNAME','LWGEOM_to_BOX2DFLOAT4'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_box2d(geometry)
+       RETURNS box2d
+       AS 'MODULE_PATHNAME','LWGEOM_to_BOX2DFLOAT4'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box3d(geometry)
-        RETURNS box3d
-        AS 'MODULE_PATHNAME','LWGEOM_to_BOX3D'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION box3d(geometry)
+       RETURNS box3d
+       AS 'MODULE_PATHNAME','LWGEOM_to_BOX3D'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box3d(geometry)
-        RETURNS box3d
-        AS 'MODULE_PATHNAME','LWGEOM_to_BOX3D'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_box3d(geometry)
+       RETURNS box3d
+       AS 'MODULE_PATHNAME','LWGEOM_to_BOX3D'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box(geometry)
-        RETURNS box
-        AS 'MODULE_PATHNAME','LWGEOM_to_BOX'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION box(geometry)
+       RETURNS box
+       AS 'MODULE_PATHNAME','LWGEOM_to_BOX'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box(geometry)
-        RETURNS box
-        AS 'MODULE_PATHNAME','LWGEOM_to_BOX'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_box(geometry)
+       RETURNS box
+       AS 'MODULE_PATHNAME','LWGEOM_to_BOX'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box2d(box3d)
-        RETURNS box2d
-        AS 'MODULE_PATHNAME','BOX3D_to_BOX2DFLOAT4'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION box2d(box3d)
+       RETURNS box2d
+       AS 'MODULE_PATHNAME','BOX3D_to_BOX2DFLOAT4'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box2d(box3d)
-        RETURNS box2d
-        AS 'MODULE_PATHNAME','BOX3D_to_BOX2DFLOAT4'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_box2d(box3d)
+       RETURNS box2d
+       AS 'MODULE_PATHNAME','BOX3D_to_BOX2DFLOAT4'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box3d(box2d)
-        RETURNS box3d
-        AS 'MODULE_PATHNAME','BOX2DFLOAT4_to_BOX3D'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION box3d(box2d)
+       RETURNS box3d
+       AS 'MODULE_PATHNAME','BOX2DFLOAT4_to_BOX3D'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box3d(box2d)
-        RETURNS box3d
-        AS 'MODULE_PATHNAME','BOX2DFLOAT4_to_BOX3D'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_box3d(box2d)
+       RETURNS box3d
+       AS 'MODULE_PATHNAME','BOX2DFLOAT4_to_BOX3D'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION box(box3d)
-        RETURNS box
-        AS 'MODULE_PATHNAME','BOX3D_to_BOX'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION box(box3d)
+       RETURNS box
+       AS 'MODULE_PATHNAME','BOX3D_to_BOX'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_box(box3d)
-        RETURNS box
-        AS 'MODULE_PATHNAME','BOX3D_to_BOX'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_box(box3d)
+       RETURNS box
+       AS 'MODULE_PATHNAME','BOX3D_to_BOX'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION text(geometry)
-        RETURNS text
-        AS 'MODULE_PATHNAME','LWGEOM_to_text'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION text(geometry)
+       RETURNS text
+       AS 'MODULE_PATHNAME','LWGEOM_to_text'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_text(geometry)
-        RETURNS text
-        AS 'MODULE_PATHNAME','LWGEOM_to_text'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_text(geometry)
+       RETURNS text
+       AS 'MODULE_PATHNAME','LWGEOM_to_text'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- this is kept for backward-compatibility
 -- Deprecation in 1.2.3
-CREATEFUNCTION box3dtobox(box3d)
-        RETURNS box
-        AS 'SELECT box($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION box3dtobox(box3d)
+       RETURNS box
+       AS 'SELECT box($1)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry(box2d)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','BOX2DFLOAT4_to_LWGEOM'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION geometry(box2d)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','BOX2DFLOAT4_to_LWGEOM'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry(box2d)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','BOX2DFLOAT4_to_LWGEOM'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_geometry(box2d)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','BOX2DFLOAT4_to_LWGEOM'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry(box3d)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','BOX3D_to_LWGEOM'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION geometry(box3d)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','BOX3D_to_LWGEOM'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry(box3d)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','BOX3D_to_LWGEOM'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_geometry(box3d)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','BOX3D_to_LWGEOM'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry(text)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','parse_WKT_lwgeom'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION geometry(text)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','parse_WKT_lwgeom'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry(text)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','parse_WKT_lwgeom'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_geometry(text)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','parse_WKT_lwgeom'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry(chip)
+CREATE OR REPLACE FUNCTION geometry(chip)
        RETURNS geometry
        AS 'MODULE_PATHNAME','CHIP_to_LWGEOM'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry(chip)
+CREATE OR REPLACE FUNCTION ST_geometry(chip)
        RETURNS geometry
        AS 'MODULE_PATHNAME','CHIP_to_LWGEOM'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geometry(bytea)
+CREATE OR REPLACE FUNCTION geometry(bytea)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_from_bytea'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geometry(bytea)
+CREATE OR REPLACE FUNCTION ST_geometry(bytea)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_from_bytea'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION bytea(geometry)
+CREATE OR REPLACE FUNCTION bytea(geometry)
        RETURNS bytea
        AS 'MODULE_PATHNAME','LWGEOM_to_bytea'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_bytea(geometry)
+CREATE OR REPLACE FUNCTION ST_bytea(geometry)
        RETURNS bytea
        AS 'MODULE_PATHNAME','LWGEOM_to_bytea'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- 7.3+ explicit casting definitions
 CREATE CAST (geometry AS box2d) WITH FUNCTION ST_box2d(geometry) AS IMPLICIT;
@@ -3670,323 +3670,323 @@ CREATE CAST (box3d_extent AS geometry) WITH FUNCTION ST_geometry(box3d_extent) A
 ---------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Simplify(geometry, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_simplify2d'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION Simplify(geometry, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_simplify2d'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Simplify(geometry, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_simplify2d'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Simplify(geometry, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_simplify2d'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- SnapToGrid(input, xoff, yoff, xsize, ysize)
 -- Deprecation in 1.2.3
-CREATEFUNCTION SnapToGrid(geometry, float8, float8, float8, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION SnapToGrid(geometry, float8, float8, float8, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_SnapToGrid(geometry, float8, float8, float8, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_SnapToGrid(geometry, float8, float8, float8, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- SnapToGrid(input, xsize, ysize) # offsets=0
 -- Deprecation in 1.2.3
-CREATEFUNCTION SnapToGrid(geometry, float8, float8)
-   RETURNS geometry
-   AS 'SELECT SnapToGrid($1, 0, 0, $2, $3)'
-   LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION SnapToGrid(geometry, float8, float8)
+       RETURNS geometry
+       AS 'SELECT SnapToGrid($1, 0, 0, $2, $3)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_SnapToGrid(geometry, float8, float8)
-   RETURNS geometry
-   AS 'SELECT ST_SnapToGrid($1, 0, 0, $2, $3)'
-   LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_SnapToGrid(geometry, float8, float8)
+       RETURNS geometry
+       AS 'SELECT ST_SnapToGrid($1, 0, 0, $2, $3)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- SnapToGrid(input, size) # xsize=ysize=size, offsets=0
 -- Deprecation in 1.2.3
-CREATEFUNCTION SnapToGrid(geometry, float8)
-   RETURNS geometry
-   AS 'SELECT SnapToGrid($1, 0, 0, $2, $2)'
-   LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION SnapToGrid(geometry, float8)
+       RETURNS geometry
+       AS 'SELECT SnapToGrid($1, 0, 0, $2, $2)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_SnapToGrid(geometry, float8)
-   RETURNS geometry
-   AS 'SELECT ST_SnapToGrid($1, 0, 0, $2, $2)'
-   LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_SnapToGrid(geometry, float8)
+       RETURNS geometry
+       AS 'SELECT ST_SnapToGrid($1, 0, 0, $2, $2)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- SnapToGrid(input, point_offsets, xsize, ysize, zsize, msize)
 -- Deprecation in 1.2.3
-CREATEFUNCTION SnapToGrid(geometry, geometry, float8, float8, float8, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid_pointoff'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION SnapToGrid(geometry, geometry, float8, float8, float8, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid_pointoff'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_SnapToGrid(geometry, geometry, float8, float8, float8, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid_pointoff'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_SnapToGrid(geometry, geometry, float8, float8, float8, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_snaptogrid_pointoff'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Segmentize(geometry, float8)
+CREATE OR REPLACE FUNCTION Segmentize(geometry, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_segmentize2d'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Segmentize(geometry, float8)
+CREATE OR REPLACE FUNCTION ST_Segmentize(geometry, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_segmentize2d'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 ---------------------------------------------------------------
 -- LRS
 ---------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION line_interpolate_point(geometry, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_line_interpolate_point'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION line_interpolate_point(geometry, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_line_interpolate_point'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_line_interpolate_point(geometry, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_line_interpolate_point'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_line_interpolate_point(geometry, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_line_interpolate_point'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION line_substring(geometry, float8, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_line_substring'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION line_substring(geometry, float8, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_line_substring'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_line_substring(geometry, float8, float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_line_substring'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_line_substring(geometry, float8, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_line_substring'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION line_locate_point(geometry, geometry)
-   RETURNS float8
-   AS 'MODULE_PATHNAME', 'LWGEOM_line_locate_point'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION line_locate_point(geometry, geometry)
+       RETURNS float8
+       AS 'MODULE_PATHNAME', 'LWGEOM_line_locate_point'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_line_locate_point(geometry, geometry)
-   RETURNS float8
-   AS 'MODULE_PATHNAME', 'LWGEOM_line_locate_point'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_line_locate_point(geometry, geometry)
+       RETURNS float8
+       AS 'MODULE_PATHNAME', 'LWGEOM_line_locate_point'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION locate_between_measures(geometry, float8, float8)
+CREATE OR REPLACE FUNCTION locate_between_measures(geometry, float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_locate_between_m'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_locate_between_measures(geometry, float8, float8)
+CREATE OR REPLACE FUNCTION ST_locate_between_measures(geometry, float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_locate_between_m'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION locate_along_measure(geometry, float8)
+CREATE OR REPLACE FUNCTION locate_along_measure(geometry, float8)
        RETURNS geometry
        AS $$ SELECT locate_between_measures($1, $2, $2) $$
-       LANGUAGE 'sql' _IMMUTABLE_STRICT;
+       LANGUAGE 'sql' IMMUTABLE STRICT;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_locate_along_measure(geometry, float8)
+CREATE OR REPLACE FUNCTION ST_locate_along_measure(geometry, float8)
        RETURNS geometry
        AS $$ SELECT locate_between_measures($1, $2, $2) $$
-       LANGUAGE 'sql' _IMMUTABLE_STRICT;
+       LANGUAGE 'sql' IMMUTABLE STRICT;
 
 ---------------------------------------------------------------
 -- GEOS
 ---------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION intersection(geometry,geometry)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME','intersection'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION intersection(geometry,geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','intersection'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: intersection(geometry,geometry)
-CREATEFUNCTION ST_Intersection(geometry,geometry)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME','intersection'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Intersection(geometry,geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','intersection'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION buffer(geometry,float8)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME','buffer'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION buffer(geometry,float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','buffer'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: buffer(geometry,float8)
-CREATEFUNCTION ST_Buffer(geometry,float8)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME','buffer'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Buffer(geometry,float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','buffer'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION buffer(geometry,float8,integer)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME','buffer'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION buffer(geometry,float8,integer)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','buffer'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_buffer(geometry,float8,integer)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME','buffer'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
-   
+CREATE OR REPLACE FUNCTION ST_buffer(geometry,float8,integer)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','buffer'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
+       
 -- Deprecation in 1.2.3
-CREATEFUNCTION convexhull(geometry)
+CREATE OR REPLACE FUNCTION convexhull(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME','convexhull'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: convexhull(geometry)
-CREATEFUNCTION ST_ConvexHull(geometry)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME','convexhull'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_ConvexHull(geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','convexhull'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Only accepts LINESTRING as parameters.
 -- Availability: 1.4.0
-CREATEFUNCTION _ST_LineCrossingDirection(geometry, geometry)
-    RETURNS integer
-    AS 'MODULE_PATHNAME', 'ST_LineCrossingDirection'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_LineCrossingDirection(geometry, geometry)
+       RETURNS integer
+       AS 'MODULE_PATHNAME', 'ST_LineCrossingDirection'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.4.0
-CREATEFUNCTION ST_LineCrossingDirection(geometry, geometry)
-  RETURNS integer AS 
-  $$ SELECT CASE WHEN NOT $1 && $2 THEN 0 ELSE _ST_LineCrossingDirection($1,$2) END $$
-  LANGUAGE 'sql' IMMUTABLE;
+CREATE OR REPLACE FUNCTION ST_LineCrossingDirection(geometry, geometry)
+       RETURNS integer AS 
+       $$ SELECT CASE WHEN NOT $1 && $2 THEN 0 ELSE _ST_LineCrossingDirection($1,$2) END $$
+       LANGUAGE 'sql' IMMUTABLE;
 
 
 -- Only accepts LINESTRING as parameters.
 -- Availability: 1.4.0
-CREATEFUNCTION ST_LocateBetweenElevations(geometry, float8, float8)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME', 'ST_LocateBetweenElevations'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_LocateBetweenElevations(geometry, float8, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'ST_LocateBetweenElevations'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 #if POSTGIS_GEOS_VERSION >= 30
 -- Requires GEOS >= 3.0.0
 -- Availability: 1.3.3
-CREATEFUNCTION ST_SimplifyPreserveTopology(geometry, float8)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME','topologypreservesimplify'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_SimplifyPreserveTopology(geometry, float8)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','topologypreservesimplify'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 #endif
 
 #if POSTGIS_GEOS_VERSION >= 31
 -- Requires GEOS >= 3.1.0
 -- Availability: 1.4.0
-CREATEFUNCTION ST_IsValidReason(geometry)
-    RETURNS text
-    AS 'MODULE_PATHNAME', 'isvalidreason'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_IsValidReason(geometry)
+       RETURNS text
+       AS 'MODULE_PATHNAME', 'isvalidreason'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 #endif
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION difference(geometry,geometry)
+CREATE OR REPLACE FUNCTION difference(geometry,geometry)
        RETURNS geometry
-        AS 'MODULE_PATHNAME','difference'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       AS 'MODULE_PATHNAME','difference'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: difference(geometry,geometry)
-CREATEFUNCTION ST_Difference(geometry,geometry)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME','difference'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Difference(geometry,geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','difference'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION boundary(geometry)
+CREATE OR REPLACE FUNCTION boundary(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME','boundary'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: boundary(geometry)
-CREATEFUNCTION ST_Boundary(geometry)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','boundary'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Boundary(geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','boundary'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION symdifference(geometry,geometry)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','symdifference'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION symdifference(geometry,geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','symdifference'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: symdifference(geometry,geometry)
-CREATEFUNCTION ST_SymDifference(geometry,geometry)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME','symdifference'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_SymDifference(geometry,geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','symdifference'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION symmetricdifference(geometry,geometry)
+CREATE OR REPLACE FUNCTION symmetricdifference(geometry,geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME','symdifference'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_symmetricdifference(geometry,geometry)
+CREATE OR REPLACE FUNCTION ST_symmetricdifference(geometry,geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME','symdifference'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomUnion(geometry,geometry)
+CREATE OR REPLACE FUNCTION GeomUnion(geometry,geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME','geomunion'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: GeomUnion(geometry,geometry)
-CREATEFUNCTION ST_Union(geometry,geometry)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME','geomunion'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Union(geometry,geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','geomunion'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 --------------------------------------------------------------------------------
 -- Aggregates and their supporting functions
 --------------------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION collector(geometry, geometry) 
+CREATE OR REPLACE FUNCTION collector(geometry, geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_collect'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_collector(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_collector(geometry, geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_collect'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION collect(geometry, geometry) 
+CREATE OR REPLACE FUNCTION collect(geometry, geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_collect'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_collect(geometry, geometry) 
+CREATE OR REPLACE FUNCTION ST_collect(geometry, geometry) 
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_collect'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Deprecation in 1.2.3
 CREATE AGGREGATE memcollect(
@@ -4003,36 +4003,36 @@ CREATE AGGREGATE ST_memcollect(
        );
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION geom_accum (geometry[],geometry)
+CREATE OR REPLACE FUNCTION geom_accum (geometry[],geometry)
        RETURNS geometry[]
        AS 'MODULE_PATHNAME', 'LWGEOM_accum'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_geom_accum (geometry[],geometry)
+CREATE OR REPLACE FUNCTION ST_geom_accum (geometry[],geometry)
        RETURNS geometry[]
        AS 'MODULE_PATHNAME', 'LWGEOM_accum'
-       LANGUAGE 'C' _IMMUTABLE;
+       LANGUAGE 'C' IMMUTABLE;
 
 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION collect_garray (geometry[])
+CREATE OR REPLACE FUNCTION collect_garray (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_collect_garray'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_collect_garray (geometry[])
+CREATE OR REPLACE FUNCTION ST_collect_garray (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_collect_garray'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_collect (geometry[])
+CREATE OR REPLACE FUNCTION ST_collect (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_collect_garray'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 -- Deprecation in 1.2.3
 CREATE AGGREGATE MemGeomUnion (
@@ -4053,74 +4053,74 @@ CREATE AGGREGATE ST_MemUnion (
 -- Container type to hold the ArrayBuildState pointer as it passes through
 -- the geometry array accumulation aggregate.
 --
-CREATEFUNCTION pgis_abs_in(cstring)
-    RETURNS pgis_abs
-    AS 'MODULE_PATHNAME'
-    LANGUAGE 'C' IMMUTABLE STRICT;
+CREATE OR REPLACE FUNCTION pgis_abs_in(cstring)
+       RETURNS pgis_abs
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
-CREATEFUNCTION pgis_abs_out(pgis_abs)
-    RETURNS cstring
-    AS 'MODULE_PATHNAME'
-    LANGUAGE 'C' IMMUTABLE STRICT;
+CREATE OR REPLACE FUNCTION pgis_abs_out(pgis_abs)
+       RETURNS cstring
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C' IMMUTABLE STRICT;
 
 CREATE TYPE pgis_abs (
-   internallength = 8, 
-   input = pgis_abs_in,
-   output = pgis_abs_out,
-   alignment = double
+       internallength = 8, 
+       input = pgis_abs_in,
+       output = pgis_abs_out,
+       alignment = double
 );
 
 -- Availability: 1.4.0
-CREATEFUNCTION pgis_geometry_accum_transfn(pgis_abs, geometry)
-    RETURNS pgis_abs
-    AS 'MODULE_PATHNAME' 
-    LANGUAGE 'C';
-    
+CREATE OR REPLACE FUNCTION pgis_geometry_accum_transfn(pgis_abs, geometry)
+       RETURNS pgis_abs
+       AS 'MODULE_PATHNAME' 
+       LANGUAGE 'C';
+       
 -- Availability: 1.4.0
-CREATEFUNCTION pgis_geometry_accum_finalfn(pgis_abs)
-    RETURNS geometry[]
-    AS 'MODULE_PATHNAME' 
-    LANGUAGE 'C';
+CREATE OR REPLACE FUNCTION pgis_geometry_accum_finalfn(pgis_abs)
+       RETURNS geometry[]
+       AS 'MODULE_PATHNAME' 
+       LANGUAGE 'C';
 
 -- Availability: 1.4.0
-CREATEFUNCTION pgis_geometry_union_finalfn(pgis_abs)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME' 
-    LANGUAGE 'C';
-    
+CREATE OR REPLACE FUNCTION pgis_geometry_union_finalfn(pgis_abs)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME' 
+       LANGUAGE 'C';
+       
 -- Availability: 1.4.0
-CREATEFUNCTION pgis_geometry_collect_finalfn(pgis_abs)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME' 
-    LANGUAGE 'C';
-    
+CREATE OR REPLACE FUNCTION pgis_geometry_collect_finalfn(pgis_abs)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME' 
+       LANGUAGE 'C';
+       
 -- Availability: 1.4.0
-CREATEFUNCTION pgis_geometry_polygonize_finalfn(pgis_abs)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME' 
-    LANGUAGE 'C';
-    
+CREATE OR REPLACE FUNCTION pgis_geometry_polygonize_finalfn(pgis_abs)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME' 
+       LANGUAGE 'C';
+       
 -- Availability: 1.4.0
-CREATEFUNCTION pgis_geometry_makeline_finalfn(pgis_abs)
-    RETURNS geometry
-    AS 'MODULE_PATHNAME' 
-    LANGUAGE 'C';
-    
+CREATE OR REPLACE FUNCTION pgis_geometry_makeline_finalfn(pgis_abs)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME' 
+       LANGUAGE 'C';
+       
 -- Deprecation in: 1.2.3
 CREATE AGGREGATE accum (
-    sfunc = pgis_geometry_accum_transfn,
-    basetype = geometry,
-    stype = pgis_abs,
-    finalfunc = pgis_geometry_accum_finalfn
-    );
+       sfunc = pgis_geometry_accum_transfn,
+       basetype = geometry,
+       stype = pgis_abs,
+       finalfunc = pgis_geometry_accum_finalfn
+       );
 
 -- Availability: 1.2.2
 CREATE AGGREGATE ST_Accum (
-    sfunc = pgis_geometry_accum_transfn,
-    basetype = geometry,
-    stype = pgis_abs,
-    finalfunct = pgis_geometry_accum_finalfn
-    );
+       sfunc = pgis_geometry_accum_transfn,
+       basetype = geometry,
+       stype = pgis_abs,
+       finalfunc = pgis_geometry_accum_finalfn
+       );
 
 -- TO BE REMOVED BEFORE RELEASE
 CREATE AGGREGATE accum_old (
@@ -4137,90 +4137,76 @@ CREATE AGGREGATE ST_accum_old (
        );
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION unite_garray (geometry[])
+CREATE OR REPLACE FUNCTION unite_garray (geometry[])
        RETURNS geometry
-        AS 'MODULE_PATHNAME', 'pgis_union_geometry_array'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable); 
+       AS 'MODULE_PATHNAME', 'pgis_union_geometry_array'
+       LANGUAGE 'C' IMMUTABLE STRICT;  
 
 -- Deprecation in 1.4.0
-CREATEFUNCTION ST_unite_garray (geometry[])
+CREATE OR REPLACE FUNCTION ST_unite_garray (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME','pgis_union_geometry_array'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable); 
+       LANGUAGE 'C' IMMUTABLE STRICT;  
 
-CREATEFUNCTION ST_Union (geometry[])
+-- Availability: 1.4.0
+CREATE OR REPLACE FUNCTION ST_Union (geometry[])
        RETURNS geometry
        AS 'MODULE_PATHNAME','pgis_union_geometry_array'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable); 
-
--- TO BE REMOVED BEFORE RELEASE
-CREATE AGGREGATE GeomUnion_Old (
-       sfunc = geom_accum,
-       basetype = geometry,
-       stype = geometry[],
-       finalfunc = ST_unite_garray
-       );
-
--- TO BE REMOVED BEFORE RELEASE
-CREATE AGGREGATE ST_Union_Old (
-       sfunc = ST_geom_accum,
-       basetype = geometry,
-       stype = geometry[],
-       finalfunc = ST_unite_garray
-       );
+       LANGUAGE 'C' IMMUTABLE STRICT;  
        
+-- Availability: 1.2.2
 CREATE AGGREGATE ST_Union (
-    basetype = geometry,
-    sfunc = pgis_geometry_accum_transfn,
-    stype = pgis_abs,
-    finalfunc = pgis_geometry_union_finalfn
-    );
+       basetype = geometry,
+       sfunc = pgis_geometry_accum_transfn,
+       stype = pgis_abs,
+       finalfunc = pgis_geometry_union_finalfn
+       );
 
 -- Deprecation in 1.2.3
 CREATE AGGREGATE collect (
-    basetype = geometry,
-    sfunc = pgis_geometry_accum_transfn,
-    stype = pgis_abs,
-    finalfunc = pgis_geometry_collect_finalfn
+       basetype = geometry,
+       sfunc = pgis_geometry_accum_transfn,
+       stype = pgis_abs,
+       finalfunc = pgis_geometry_collect_finalfn
 );
 
 -- Availability: 1.2.2
 CREATE AGGREGATE ST_Collect (
-    BASETYPE = geometry,
-    SFUNC = pgis_geometry_accum_transfn,
-    STYPE = pgis_abs,
+       BASETYPE = geometry,
+       SFUNC = pgis_geometry_accum_transfn,
+       STYPE = pgis_abs,
        FINALFUNC = pgis_geometry_collect_finalfn
        );
 
 -- Deprecation in 1.2.3
 CREATE AGGREGATE Polygonize (
-    BASETYPE = geometry,
-    SFUNC = pgis_geometry_accum_transfn,
-    STYPE = pgis_abs,
+       BASETYPE = geometry,
+       SFUNC = pgis_geometry_accum_transfn,
+       STYPE = pgis_abs,
        FINALFUNC = pgis_geometry_polygonize_finalfn
        );
 
 -- Availability: 1.2.2
 CREATE AGGREGATE ST_Polygonize (
-    BASETYPE = geometry,
-    SFUNC = pgis_geometry_accum_transfn,
-    STYPE = pgis_abs,
+       BASETYPE = geometry,
+       SFUNC = pgis_geometry_accum_transfn,
+       STYPE = pgis_abs,
        FINALFUNC = pgis_geometry_polygonize_finalfn
        );
 
 -- Deprecation in 1.2.3
 CREATE AGGREGATE makeline (
-    BASETYPE = geometry,
-    SFUNC = pgis_geometry_accum_transfn,
-    STYPE = pgis_abs,
+       BASETYPE = geometry,
+       SFUNC = pgis_geometry_accum_transfn,
+       STYPE = pgis_abs,
        FINALFUNC = pgis_geometry_makeline_finalfn
        );
 
 -- Availability: 1.2.2
 CREATE AGGREGATE ST_MakeLine (
-    BASETYPE = geometry,
-    SFUNC = pgis_geometry_accum_transfn,
-    STYPE = pgis_abs,
+       BASETYPE = geometry,
+       SFUNC = pgis_geometry_accum_transfn,
+       STYPE = pgis_abs,
        FINALFUNC = pgis_geometry_makeline_finalfn
        );
 
@@ -4229,1013 +4215,1013 @@ CREATE AGGREGATE ST_MakeLine (
 --------------------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION relate(geometry,geometry)
-   RETURNS text
-   AS 'MODULE_PATHNAME','relate_full'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION relate(geometry,geometry)
+       RETURNS text
+       AS 'MODULE_PATHNAME','relate_full'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_relate(geometry,geometry)
-   RETURNS text
-   AS 'MODULE_PATHNAME','relate_full'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_relate(geometry,geometry)
+       RETURNS text
+       AS 'MODULE_PATHNAME','relate_full'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION relate(geometry,geometry,text)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME','relate_pattern'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION relate(geometry,geometry,text)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','relate_pattern'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: relate(geometry,geometry,text)
-CREATEFUNCTION ST_Relate(geometry,geometry,text)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','relate_pattern'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Relate(geometry,geometry,text)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','relate_pattern'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION disjoint(geometry,geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
-   
+CREATE OR REPLACE FUNCTION disjoint(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
+       
 -- PostGIS equivalent function: disjoint(geometry,geometry)
-CREATEFUNCTION ST_Disjoint(geometry,geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','disjoint'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Disjoint(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','disjoint'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION touches(geometry,geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION touches(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: touches(geometry,geometry)
-CREATEFUNCTION _ST_Touches(geometry,geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','touches'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_Touches(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','touches'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
 -- Inlines index magic
-CREATEFUNCTION ST_Touches(geometry,geometry)
-    RETURNS boolean
-    AS 'SELECT $1 && $2 AND _ST_Touches($1,$2)'
-    LANGUAGE 'SQL' _IMMUTABLE; -- WITH (iscachable);
+CREATE OR REPLACE FUNCTION ST_Touches(geometry,geometry)
+       RETURNS boolean
+       AS 'SELECT $1 && $2 AND _ST_Touches($1,$2)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 
 -- Availability: 1.3.4
-CREATEFUNCTION _ST_DWithin(geometry,geometry,float8)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME', 'LWGEOM_dwithin'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_DWithin(geometry,geometry,float8)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME', 'LWGEOM_dwithin'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_DWithin(geometry, geometry, float8)
-    RETURNS boolean
-    AS 'SELECT $1 && ST_Expand($2,$3) AND $2 && ST_Expand($1,$3) AND _ST_DWithin($1, $2, $3)'
-    LANGUAGE 'SQL' _IMMUTABLE; -- WITH (iscachable);
+CREATE OR REPLACE FUNCTION ST_DWithin(geometry, geometry, float8)
+       RETURNS boolean
+       AS 'SELECT $1 && ST_Expand($2,$3) AND $2 && ST_Expand($1,$3) AND _ST_DWithin($1, $2, $3)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION intersects(geometry,geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION intersects(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: intersects(geometry,geometry)
-CREATEFUNCTION _ST_Intersects(geometry,geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','intersects'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_Intersects(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','intersects'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
 -- Inlines index magic
-CREATEFUNCTION ST_Intersects(geometry,geometry)
-    RETURNS boolean
-    AS 'SELECT $1 && $2 AND _ST_Intersects($1,$2)'
-    LANGUAGE 'SQL' _IMMUTABLE; -- WITH (iscachable);
+CREATE OR REPLACE FUNCTION ST_Intersects(geometry,geometry)
+       RETURNS boolean
+       AS 'SELECT $1 && $2 AND _ST_Intersects($1,$2)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 -- Deprecation in 1.2.3
-CREATEFUNCTION crosses(geometry,geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION crosses(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: crosses(geometry,geometry)
-CREATEFUNCTION _ST_Crosses(geometry,geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','crosses'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_Crosses(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','crosses'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
 -- Inlines index magic
-CREATEFUNCTION ST_Crosses(geometry,geometry)
-    RETURNS boolean
-    AS 'SELECT $1 && $2 AND _ST_Crosses($1,$2)'
-    LANGUAGE 'SQL' _IMMUTABLE; -- WITH (iscachable);
+CREATE OR REPLACE FUNCTION ST_Crosses(geometry,geometry)
+       RETURNS boolean
+       AS 'SELECT $1 && $2 AND _ST_Crosses($1,$2)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION within(geometry,geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION within(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: within(geometry,geometry)
-CREATEFUNCTION _ST_Within(geometry,geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','within'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_Within(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','within'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
 -- Inlines index magic
-CREATEFUNCTION ST_Within(geometry,geometry)
-    RETURNS boolean
-    AS 'SELECT $1 && $2 AND _ST_Within($1,$2)'
-    LANGUAGE 'SQL' _IMMUTABLE; -- WITH (iscachable);
+CREATE OR REPLACE FUNCTION ST_Within(geometry,geometry)
+       RETURNS boolean
+       AS 'SELECT $1 && $2 AND _ST_Within($1,$2)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Contains(geometry,geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION Contains(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: contains(geometry,geometry)
-CREATEFUNCTION _ST_Contains(geometry,geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','contains'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_Contains(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','contains'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
 -- Inlines index magic
-CREATEFUNCTION ST_Contains(geometry,geometry)
-    RETURNS boolean
-    AS 'SELECT $1 && $2 AND _ST_Contains($1,$2)'
-    LANGUAGE 'SQL' _IMMUTABLE; -- WITH (iscachable);
+CREATE OR REPLACE FUNCTION ST_Contains(geometry,geometry)
+       RETURNS boolean
+       AS 'SELECT $1 && $2 AND _ST_Contains($1,$2)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 
 #if POSTGIS_GEOS_VERSION >= 30
 -- Availability: 1.2.2
-CREATEFUNCTION _ST_CoveredBy(geometry,geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME', 'coveredby'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_CoveredBy(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME', 'coveredby'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_CoveredBy(geometry,geometry)
-   RETURNS boolean
-   AS 'SELECT $1 && $2 AND _ST_CoveredBy($1,$2)'
-   LANGUAGE 'SQL' _IMMUTABLE; -- WITH(iscachable);
+CREATE OR REPLACE FUNCTION ST_CoveredBy(geometry,geometry)
+       RETURNS boolean
+       AS 'SELECT $1 && $2 AND _ST_CoveredBy($1,$2)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION _ST_Covers(geometry,geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME', 'covers'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_Covers(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME', 'covers'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
 -- Inlines index magic
-CREATEFUNCTION ST_Covers(geometry,geometry)
-   RETURNS boolean
-   AS 'SELECT $1 && $2 AND _ST_Covers($1,$2)'
-   LANGUAGE 'SQL' _IMMUTABLE; -- WITH (iscachable);
+CREATE OR REPLACE FUNCTION ST_Covers(geometry,geometry)
+       RETURNS boolean
+       AS 'SELECT $1 && $2 AND _ST_Covers($1,$2)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 #endif
 
 #if POSTGIS_GEOS_VERSION >= 31
 -- Availability: 1.4.0
-CREATEFUNCTION _ST_ContainsProperly(geometry,geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','containsproperly'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_ContainsProperly(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','containsproperly'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.4.0
 -- Inlines index magic
-CREATEFUNCTION ST_ContainsProperly(geometry,geometry)
-    RETURNS boolean
-    AS 'SELECT $1 && $2 AND _ST_ContainsProperly($1,$2)'
-    LANGUAGE 'SQL' _IMMUTABLE; -- WITH (iscachable);
+CREATE OR REPLACE FUNCTION ST_ContainsProperly(geometry,geometry)
+       RETURNS boolean
+       AS 'SELECT $1 && $2 AND _ST_ContainsProperly($1,$2)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 #endif
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION overlaps(geometry,geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION overlaps(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: overlaps(geometry,geometry)
-CREATEFUNCTION _ST_Overlaps(geometry,geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','overlaps'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_Overlaps(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','overlaps'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
 -- Inlines index magic
-CREATEFUNCTION ST_Overlaps(geometry,geometry)
-    RETURNS boolean
-    AS 'SELECT $1 && $2 AND _ST_Overlaps($1,$2)'
-    LANGUAGE 'SQL' _IMMUTABLE; -- WITH (iscachable);
+CREATE OR REPLACE FUNCTION ST_Overlaps(geometry,geometry)
+       RETURNS boolean
+       AS 'SELECT $1 && $2 AND _ST_Overlaps($1,$2)'
+       LANGUAGE 'SQL' IMMUTABLE; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION IsValid(geometry)
-   RETURNS boolean
-   AS 'MODULE_PATHNAME', 'isvalid'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION IsValid(geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME', 'isvalid'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: IsValid(geometry)
 -- TODO: change null returns to true
-CREATEFUNCTION ST_IsValid(geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME', 'isvalid'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_IsValid(geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME', 'isvalid'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GEOSnoop(geometry)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'GEOSnoop'
-   LANGUAGE 'C' _VOLATILE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION GEOSnoop(geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'GEOSnoop'
+       LANGUAGE 'C' VOLATILE STRICT; 
 
 -- This is also available w/out GEOS 
-CREATEFUNCTION Centroid(geometry)
+CREATE OR REPLACE FUNCTION Centroid(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: Centroid(geometry)
-CREATEFUNCTION ST_Centroid(geometry)
+CREATE OR REPLACE FUNCTION ST_Centroid(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'centroid'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION IsRing(geometry)
+CREATE OR REPLACE FUNCTION IsRing(geometry)
        RETURNS boolean
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: IsRing(geometry)
-CREATEFUNCTION ST_IsRing(geometry)
+CREATE OR REPLACE FUNCTION ST_IsRing(geometry)
        RETURNS boolean
        AS 'MODULE_PATHNAME', 'isring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PointOnSurface(geometry)
+CREATE OR REPLACE FUNCTION PointOnSurface(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: PointOnSurface(geometry)
-CREATEFUNCTION ST_PointOnSurface(geometry)
+CREATE OR REPLACE FUNCTION ST_PointOnSurface(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'pointonsurface'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION IsSimple(geometry)
+CREATE OR REPLACE FUNCTION IsSimple(geometry)
        RETURNS boolean
        AS 'MODULE_PATHNAME', 'issimple'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: IsSimple(geometry)     
-CREATEFUNCTION ST_IsSimple(geometry)
-        RETURNS boolean
-        AS 'MODULE_PATHNAME', 'issimple'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_IsSimple(geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME', 'issimple'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Equals(geometry,geometry)
+CREATE OR REPLACE FUNCTION Equals(geometry,geometry)
        RETURNS boolean
        AS 'MODULE_PATHNAME','geomequals'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: Equals(geometry,geometry)
-CREATEFUNCTION ST_Equals(geometry,geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME','geomequals'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_Equals(geometry,geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME','geomequals'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -----------------------------------------------------------------------
 -- SVG OUTPUT
 -----------------------------------------------------------------------
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsSVG(geometry,int4,int4)
+CREATE OR REPLACE FUNCTION AsSVG(geometry,int4,int4)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','assvg_geometry'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsSVG(geometry,int4,int4)
+CREATE OR REPLACE FUNCTION ST_AsSVG(geometry,int4,int4)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','assvg_geometry'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsSVG(geometry,int4)
+CREATE OR REPLACE FUNCTION AsSVG(geometry,int4)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','assvg_geometry'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsSVG(geometry,int4)
+CREATE OR REPLACE FUNCTION ST_AsSVG(geometry,int4)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','assvg_geometry'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsSVG(geometry)
+CREATE OR REPLACE FUNCTION AsSVG(geometry)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','assvg_geometry'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsSVG(geometry)
+CREATE OR REPLACE FUNCTION ST_AsSVG(geometry)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','assvg_geometry'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -----------------------------------------------------------------------
 -- GML OUTPUT
 -----------------------------------------------------------------------
 -- _ST_AsGML(version, geom, precision, option)
-CREATEFUNCTION _ST_AsGML(int4, geometry, int4, int4)
+CREATE OR REPLACE FUNCTION _ST_AsGML(int4, geometry, int4, int4)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','LWGEOM_asGML'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- AsGML(geom, precision) / version=2
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsGML(geometry, int4)
+CREATE OR REPLACE FUNCTION AsGML(geometry, int4)
        RETURNS TEXT
        AS 'SELECT _ST_AsGML(2, $1, $2, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsGML(geometry, int4)
+CREATE OR REPLACE FUNCTION ST_AsGML(geometry, int4)
        RETURNS TEXT
        AS 'SELECT _ST_AsGML(2, $1, $2, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- AsGML(geom) / precision=15 version=2
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsGML(geometry)
+CREATE OR REPLACE FUNCTION AsGML(geometry)
        RETURNS TEXT
        AS 'SELECT _ST_AsGML(2, $1, 15, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsGML(geometry)
+CREATE OR REPLACE FUNCTION ST_AsGML(geometry)
        RETURNS TEXT
        AS 'SELECT _ST_AsGML(2, $1, 15, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsGML(version, geom) / precision=15 version=2
 -- Availability: 1.3.2
-CREATEFUNCTION ST_AsGML(int4, geometry)
+CREATE OR REPLACE FUNCTION ST_AsGML(int4, geometry)
        RETURNS TEXT
        AS 'SELECT _ST_AsGML($1, $2, 15, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsGML(version, geom, precision)
 -- Availability: 1.3.2
-CREATEFUNCTION ST_AsGML(int4, geometry, int4)
+CREATE OR REPLACE FUNCTION ST_AsGML(int4, geometry, int4)
        RETURNS TEXT
        AS 'SELECT _ST_AsGML($1, $2, $3, 0)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsGML (geom, precision, option) / version=2
 -- Availability: 1.4.0
-CREATEFUNCTION ST_AsGML(geometry, int4, int4)
-        RETURNS TEXT
-        AS 'SELECT _ST_AsGML(2, $1, $2, $3)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_AsGML(geometry, int4, int4)
+       RETURNS TEXT
+       AS 'SELECT _ST_AsGML(2, $1, $2, $3)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsGML(version, geom, precision, option)
 -- Availability: 1.4.0
-CREATEFUNCTION ST_AsGML(int4, geometry, int4, int4)
+CREATE OR REPLACE FUNCTION ST_AsGML(int4, geometry, int4, int4)
        RETURNS TEXT
        AS 'SELECT _ST_AsGML($1, $2, $3, $4)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -----------------------------------------------------------------------
 -- KML OUTPUT
 -----------------------------------------------------------------------
 -- _ST_AsKML(version, geom, precision)
-CREATEFUNCTION _ST_AsKML(int4, geometry, int4)
+CREATE OR REPLACE FUNCTION _ST_AsKML(int4, geometry, int4)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','LWGEOM_asKML'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- AsKML(geom, precision) / version=2
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsKML(geometry, int4)
+CREATE OR REPLACE FUNCTION AsKML(geometry, int4)
        RETURNS TEXT
        AS 'SELECT _ST_AsKML(2, transform($1,4326), $2)' 
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsKML(geometry, int4)
+CREATE OR REPLACE FUNCTION ST_AsKML(geometry, int4)
        RETURNS TEXT
        AS 'SELECT _ST_AsKML(2, ST_Transform($1,4326), $2)' 
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- AsKML(geom) / precision=15 version=2
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsKML(geometry) 
+CREATE OR REPLACE FUNCTION AsKML(geometry) 
        RETURNS TEXT
        AS 'SELECT _ST_AsKML(2, transform($1,4326), 15)' 
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- AsKML(version, geom, precision)
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsKML(int4, geometry, int4) 
+CREATE OR REPLACE FUNCTION AsKML(int4, geometry, int4) 
        RETURNS TEXT
        AS 'SELECT _ST_AsKML($1, transform($2,4326), $3)' 
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsKML(geometry)
+CREATE OR REPLACE FUNCTION ST_AsKML(geometry)
        RETURNS TEXT
        AS 'SELECT _ST_AsKML(2, ST_Transform($1,4326), 15)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsKML(version, geom) / precision=15 version=2
 -- Availability: 1.3.2
-CREATEFUNCTION ST_AsKML(int4, geometry)
+CREATE OR REPLACE FUNCTION ST_AsKML(int4, geometry)
        RETURNS TEXT
        AS 'SELECT _ST_AsKML($1, ST_Transform($2,4326), 15)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsKML(version, geom, precision)
 -- Availability: 1.3.2
-CREATEFUNCTION ST_AsKML(int4, geometry, int4) 
+CREATE OR REPLACE FUNCTION ST_AsKML(int4, geometry, int4) 
        RETURNS TEXT
        AS 'SELECT _ST_AsKML($1, ST_Transform($2,4326), $3)' 
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -----------------------------------------------------------------------
 -- GEOJSON OUTPUT
 -- Availability: 1.3.4
 -----------------------------------------------------------------------
 -- _ST_AsGeoJson(version, geom, precision, options)
-CREATEFUNCTION _ST_AsGeoJson(int4, geometry, int4, int4)
-        RETURNS TEXT
-        AS 'MODULE_PATHNAME','LWGEOM_asGeoJson'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION _ST_AsGeoJson(int4, geometry, int4, int4)
+       RETURNS TEXT
+       AS 'MODULE_PATHNAME','LWGEOM_asGeoJson'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- ST_AsGeoJson(geom, precision) / version=1 options=0
-CREATEFUNCTION ST_AsGeoJson(geometry, int4)
-        RETURNS TEXT
-        AS 'SELECT _ST_AsGeoJson(1, $1, $2, 0)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_AsGeoJson(geometry, int4)
+       RETURNS TEXT
+       AS 'SELECT _ST_AsGeoJson(1, $1, $2, 0)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsGeoJson(geom) / precision=15 version=1 options=0
-CREATEFUNCTION ST_AsGeoJson(geometry)
-        RETURNS TEXT
-        AS 'SELECT _ST_AsGeoJson(1, $1, 15, 0)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_AsGeoJson(geometry)
+       RETURNS TEXT
+       AS 'SELECT _ST_AsGeoJson(1, $1, 15, 0)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsGeoJson(version, geom) / precision=15 options=0
-CREATEFUNCTION ST_AsGeoJson(int4, geometry)
-        RETURNS TEXT
-        AS 'SELECT _ST_AsGeoJson($1, $2, 15, 0)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_AsGeoJson(int4, geometry)
+       RETURNS TEXT
+       AS 'SELECT _ST_AsGeoJson($1, $2, 15, 0)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsGeoJson(version, geom, precision) / options=0
-CREATEFUNCTION ST_AsGeoJson(int4, geometry, int4)
-        RETURNS TEXT
-        AS 'SELECT _ST_AsGeoJson($1, $2, $3, 0)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_AsGeoJson(int4, geometry, int4)
+       RETURNS TEXT
+       AS 'SELECT _ST_AsGeoJson($1, $2, $3, 0)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsGeoJson(geom, precision, options) / version=1
-CREATEFUNCTION ST_AsGeoJson(geometry, int4, int4)
-        RETURNS TEXT
-        AS 'SELECT _ST_AsGeoJson(1, $1, $2, $3)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_AsGeoJson(geometry, int4, int4)
+       RETURNS TEXT
+       AS 'SELECT _ST_AsGeoJson(1, $1, $2, $3)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_AsGeoJson(version, geom, precision,options)
-CREATEFUNCTION ST_AsGeoJson(int4, geometry, int4, int4)
-        RETURNS TEXT
-        AS 'SELECT _ST_AsGeoJson($1, $2, $3, $4)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_AsGeoJson(int4, geometry, int4, int4)
+       RETURNS TEXT
+       AS 'SELECT _ST_AsGeoJson($1, $2, $3, $4)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 ------------------------------------------------------------------------
 -- GeoHash (geohash.org)
 ------------------------------------------------------------------------
 
 -- Availability 1.4.0
-CREATEFUNCTION ST_GeoHash(geometry, int4)
-        RETURNS TEXT
+CREATE OR REPLACE FUNCTION ST_GeoHash(geometry, int4)
+       RETURNS TEXT
            AS 'MODULE_PATHNAME', 'ST_GeoHash'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrictl,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability 1.4.0
-CREATEFUNCTION ST_GeoHash(geometry)
-        RETURNS TEXT
-        AS 'SELECT ST_GeoHash($1, 0)'
-        LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_GeoHash(geometry)
+       RETURNS TEXT
+       AS 'SELECT ST_GeoHash($1, 0)'
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 ------------------------------------------------------------------------
 -- OGC defined
 ------------------------------------------------------------------------
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION NumPoints(geometry)
+CREATE OR REPLACE FUNCTION NumPoints(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_numpoints_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: NumPoints(geometry)
-CREATEFUNCTION ST_NumPoints(geometry)
+CREATE OR REPLACE FUNCTION ST_NumPoints(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_numpoints_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION NumGeometries(geometry)
+CREATE OR REPLACE FUNCTION NumGeometries(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_numgeometries_collection'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: NumGeometries(geometry)
-CREATEFUNCTION ST_NumGeometries(geometry)
+CREATE OR REPLACE FUNCTION ST_NumGeometries(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_numgeometries_collection'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeometryN(geometry,integer)
+CREATE OR REPLACE FUNCTION GeometryN(geometry,integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_geometryn_collection'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: GeometryN(geometry)
-CREATEFUNCTION ST_GeometryN(geometry,integer)
+CREATE OR REPLACE FUNCTION ST_GeometryN(geometry,integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_geometryn_collection'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Dimension(geometry)
+CREATE OR REPLACE FUNCTION Dimension(geometry)
        RETURNS int4
        AS 'MODULE_PATHNAME', 'LWGEOM_dimension'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: Dimension(geometry)
-CREATEFUNCTION ST_Dimension(geometry)
-    RETURNS int4
-    AS 'MODULE_PATHNAME', 'LWGEOM_dimension'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+CREATE OR REPLACE FUNCTION ST_Dimension(geometry)
+       RETURNS int4
+       AS 'MODULE_PATHNAME', 'LWGEOM_dimension'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION ExteriorRing(geometry)
+CREATE OR REPLACE FUNCTION ExteriorRing(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_exteriorring_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: ExteriorRing(geometry)
-CREATEFUNCTION ST_ExteriorRing(geometry)
+CREATE OR REPLACE FUNCTION ST_ExteriorRing(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_exteriorring_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION NumInteriorRings(geometry)
+CREATE OR REPLACE FUNCTION NumInteriorRings(geometry)
        RETURNS integer
        AS 'MODULE_PATHNAME','LWGEOM_numinteriorrings_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: NumInteriorRings(geometry)
-CREATEFUNCTION ST_NumInteriorRings(geometry)
+CREATE OR REPLACE FUNCTION ST_NumInteriorRings(geometry)
        RETURNS integer
        AS 'MODULE_PATHNAME','LWGEOM_numinteriorrings_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION NumInteriorRing(geometry)
+CREATE OR REPLACE FUNCTION NumInteriorRing(geometry)
        RETURNS integer
        AS 'MODULE_PATHNAME','LWGEOM_numinteriorrings_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_NumInteriorRing(geometry)
+CREATE OR REPLACE FUNCTION ST_NumInteriorRing(geometry)
        RETURNS integer
        AS 'MODULE_PATHNAME','LWGEOM_numinteriorrings_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION InteriorRingN(geometry,integer)
+CREATE OR REPLACE FUNCTION InteriorRingN(geometry,integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_interiorringn_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: InteriorRingN(geometry)
-CREATEFUNCTION ST_InteriorRingN(geometry,integer)
+CREATE OR REPLACE FUNCTION ST_InteriorRingN(geometry,integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_interiorringn_polygon'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeometryType(geometry)
+CREATE OR REPLACE FUNCTION GeometryType(geometry)
        RETURNS text
        AS 'MODULE_PATHNAME', 'LWGEOM_getTYPE'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Not quite equivalent to GeometryType
-CREATEFUNCTION ST_GeometryType(geometry)
-    RETURNS text
-    AS $$ 
-    DECLARE
-        gtype text := geometrytype($1);
-    BEGIN
-        IF (gtype IN ('POINT', 'POINTM')) THEN
-            gtype := 'Point';
-        ELSIF (gtype IN ('LINESTRING', 'LINESTRINGM')) THEN
-            gtype := 'LineString';
-        ELSIF (gtype IN ('POLYGON', 'POLYGONM')) THEN
-            gtype := 'Polygon';
-        ELSIF (gtype IN ('MULTIPOINT', 'MULTIPOINTM')) THEN
-            gtype := 'MultiPoint';
-        ELSIF (gtype IN ('MULTILINESTRING', 'MULTILINESTRINGM')) THEN
-            gtype := 'MultiLineString';
-        ELSIF (gtype IN ('MULTIPOLYGON', 'MULTIPOLYGONM')) THEN
-            gtype := 'MultiPolygon';
-        ELSE
-            gtype := 'Geometry';
-        END IF;
-        RETURN 'ST_' || gtype;
-    END
+CREATE OR REPLACE FUNCTION ST_GeometryType(geometry)
+       RETURNS text
+       AS $$ 
+       DECLARE
+       gtype text := geometrytype($1);
+       BEGIN
+       IF (gtype IN ('POINT', 'POINTM')) THEN
+           gtype := 'Point';
+       ELSIF (gtype IN ('LINESTRING', 'LINESTRINGM')) THEN
+           gtype := 'LineString';
+       ELSIF (gtype IN ('POLYGON', 'POLYGONM')) THEN
+           gtype := 'Polygon';
+       ELSIF (gtype IN ('MULTIPOINT', 'MULTIPOINTM')) THEN
+           gtype := 'MultiPoint';
+       ELSIF (gtype IN ('MULTILINESTRING', 'MULTILINESTRINGM')) THEN
+           gtype := 'MultiLineString';
+       ELSIF (gtype IN ('MULTIPOLYGON', 'MULTIPOLYGONM')) THEN
+           gtype := 'MultiPolygon';
+       ELSE
+           gtype := 'Geometry';
+       END IF;
+       RETURN 'ST_' || gtype;
+       END
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PointN(geometry,integer)
+CREATE OR REPLACE FUNCTION PointN(geometry,integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_pointn_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: PointN(geometry,integer)
-CREATEFUNCTION ST_PointN(geometry,integer)
+CREATE OR REPLACE FUNCTION ST_PointN(geometry,integer)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_pointn_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION X(geometry)
+CREATE OR REPLACE FUNCTION X(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_x_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: X(geometry)
-CREATEFUNCTION ST_X(geometry)
+CREATE OR REPLACE FUNCTION ST_X(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_x_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Y(geometry)
+CREATE OR REPLACE FUNCTION Y(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_y_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
-        
+       LANGUAGE 'C' IMMUTABLE STRICT; 
+       
 -- PostGIS equivalent function: Y(geometry)
-CREATEFUNCTION ST_Y(geometry)
+CREATE OR REPLACE FUNCTION ST_Y(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_y_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION Z(geometry)
+CREATE OR REPLACE FUNCTION Z(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_z_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_Z(geometry)
+CREATE OR REPLACE FUNCTION ST_Z(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_z_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION M(geometry)
+CREATE OR REPLACE FUNCTION M(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_m_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_M(geometry)
+CREATE OR REPLACE FUNCTION ST_M(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_m_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION StartPoint(geometry)
+CREATE OR REPLACE FUNCTION StartPoint(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_startpoint_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: StartPoint(geometry))
-CREATEFUNCTION ST_StartPoint(geometry)
+CREATE OR REPLACE FUNCTION ST_StartPoint(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_startpoint_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION EndPoint(geometry)
+CREATE OR REPLACE FUNCTION EndPoint(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_endpoint_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: EndPoint(geometry))
-CREATEFUNCTION ST_EndPoint(geometry)
+CREATE OR REPLACE FUNCTION ST_EndPoint(geometry)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_endpoint_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION IsClosed(geometry)
+CREATE OR REPLACE FUNCTION IsClosed(geometry)
        RETURNS boolean
        AS 'MODULE_PATHNAME', 'LWGEOM_isclosed_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: IsClosed(geometry)
-CREATEFUNCTION ST_IsClosed(geometry)
+CREATE OR REPLACE FUNCTION ST_IsClosed(geometry)
        RETURNS boolean
        AS 'MODULE_PATHNAME', 'LWGEOM_isclosed_linestring'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION IsEmpty(geometry)
+CREATE OR REPLACE FUNCTION IsEmpty(geometry)
        RETURNS boolean
        AS 'MODULE_PATHNAME', 'LWGEOM_isempty'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: IsEmpty(geometry)
-CREATEFUNCTION ST_IsEmpty(geometry)
-    RETURNS boolean
-    AS 'MODULE_PATHNAME', 'LWGEOM_isempty'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+CREATE OR REPLACE FUNCTION ST_IsEmpty(geometry)
+       RETURNS boolean
+       AS 'MODULE_PATHNAME', 'LWGEOM_isempty'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION SRID(geometry) 
+CREATE OR REPLACE FUNCTION SRID(geometry) 
        RETURNS int4
        AS 'MODULE_PATHNAME','LWGEOM_getSRID'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: getSRID(geometry)
-CREATEFUNCTION ST_SRID(geometry) 
-    RETURNS int4
-    AS 'MODULE_PATHNAME','LWGEOM_getSRID'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_SRID(geometry) 
+       RETURNS int4
+       AS 'MODULE_PATHNAME','LWGEOM_getSRID'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION SetSRID(geometry,int4) 
+CREATE OR REPLACE FUNCTION SetSRID(geometry,int4) 
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_setSRID'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);  
+       LANGUAGE 'C' IMMUTABLE STRICT;  
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_SetSRID(geometry,int4) 
+CREATE OR REPLACE FUNCTION ST_SetSRID(geometry,int4) 
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_setSRID'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);  
+       LANGUAGE 'C' IMMUTABLE STRICT;  
        
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsBinary(geometry)
+CREATE OR REPLACE FUNCTION AsBinary(geometry)
        RETURNS bytea
        AS 'MODULE_PATHNAME','LWGEOM_asBinary'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: AsBinary(geometry)
-CREATEFUNCTION ST_AsBinary(geometry)
-    RETURNS bytea
-    AS 'MODULE_PATHNAME','LWGEOM_asBinary'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_AsBinary(geometry)
+       RETURNS bytea
+       AS 'MODULE_PATHNAME','LWGEOM_asBinary'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsBinary(geometry,text)
+CREATE OR REPLACE FUNCTION AsBinary(geometry,text)
        RETURNS bytea
        AS 'MODULE_PATHNAME','LWGEOM_asBinary'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_AsBinary(geometry,text)
+CREATE OR REPLACE FUNCTION ST_AsBinary(geometry,text)
        RETURNS bytea
        AS 'MODULE_PATHNAME','LWGEOM_asBinary'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION AsText(geometry)
+CREATE OR REPLACE FUNCTION AsText(geometry)
        RETURNS TEXT
        AS 'MODULE_PATHNAME','LWGEOM_asText'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: AsText(geometry)
-CREATEFUNCTION ST_AsText(geometry)
-    RETURNS TEXT
-    AS 'MODULE_PATHNAME','LWGEOM_asText'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_AsText(geometry)
+       RETURNS TEXT
+       AS 'MODULE_PATHNAME','LWGEOM_asText'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeometryFromText(text)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','LWGEOM_from_text'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION GeometryFromText(text)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','LWGEOM_from_text'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeometryFromText(text)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','LWGEOM_from_text'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_GeometryFromText(text)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','LWGEOM_from_text'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeometryFromText(text, int4)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','LWGEOM_from_text'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION GeometryFromText(text, int4)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','LWGEOM_from_text'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeometryFromText(text, int4)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','LWGEOM_from_text'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_GeometryFromText(text, int4)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','LWGEOM_from_text'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomFromText(text)
+CREATE OR REPLACE FUNCTION GeomFromText(text)
        RETURNS geometry AS 'SELECT geometryfromtext($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeomFromText(text)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','LWGEOM_from_text'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_GeomFromText(text)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','LWGEOM_from_text'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomFromText(text, int4)
+CREATE OR REPLACE FUNCTION GeomFromText(text, int4)
        RETURNS geometry AS 'SELECT geometryfromtext($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: ST_GeometryFromText(text, int4)
-CREATEFUNCTION ST_GeomFromText(text, int4)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME','LWGEOM_from_text'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_GeomFromText(text, int4)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','LWGEOM_from_text'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PointFromText(text)
+CREATE OR REPLACE FUNCTION PointFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1)) = ''POINT''
        THEN GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_PointFromText(text)
+CREATE OR REPLACE FUNCTION ST_PointFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''POINT''
        THEN ST_GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PointFromText(text, int4)
+CREATE OR REPLACE FUNCTION PointFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1, $2)) = ''POINT''
        THEN GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: PointFromText(text, int4)
 -- TODO: improve this ... by not duplicating constructor time.
-CREATEFUNCTION ST_PointFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_PointFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromText($1, $2)) = ''POINT''
        THEN ST_GeomFromText($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LineFromText(text)
+CREATE OR REPLACE FUNCTION LineFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1)) = ''LINESTRING''
        THEN GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_LineFromText(text)
+CREATE OR REPLACE FUNCTION ST_LineFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''LINESTRING''
        THEN ST_GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LineFromText(text, int4)
+CREATE OR REPLACE FUNCTION LineFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1, $2)) = ''LINESTRING''
        THEN GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: LineFromText(text, int4)
-CREATEFUNCTION ST_LineFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_LineFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1, $2)) = ''LINESTRING''
        THEN GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LineStringFromText(text)
+CREATE OR REPLACE FUNCTION LineStringFromText(text)
        RETURNS geometry
        AS 'SELECT LineFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LineStringFromText(text, int4)
+CREATE OR REPLACE FUNCTION LineStringFromText(text, int4)
        RETURNS geometry
        AS 'SELECT LineFromText($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PolyFromText(text)
+CREATE OR REPLACE FUNCTION PolyFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1)) = ''POLYGON''
        THEN GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_PolyFromText(text)
+CREATE OR REPLACE FUNCTION ST_PolyFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''POLYGON''
        THEN ST_GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PolyFromText(text, int4)
+CREATE OR REPLACE FUNCTION PolyFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1, $2)) = ''POLYGON''
        THEN GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
-        
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
+       
 -- PostGIS equivalent function: ST_PolygonFromText(text, int4)
-CREATEFUNCTION ST_PolyFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_PolyFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromText($1, $2)) = ''POLYGON''
        THEN ST_GeomFromText($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PolygonFromText(text, int4)
+CREATE OR REPLACE FUNCTION PolygonFromText(text, int4)
        RETURNS geometry
        AS 'SELECT PolyFromText($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_PolygonFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_PolygonFromText(text, int4)
        RETURNS geometry
        AS 'SELECT PolyFromText($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PolygonFromText(text)
+CREATE OR REPLACE FUNCTION PolygonFromText(text)
        RETURNS geometry
        AS 'SELECT PolyFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_PolygonFromText(text)
+CREATE OR REPLACE FUNCTION ST_PolygonFromText(text)
        RETURNS geometry
        AS 'SELECT ST_PolyFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MLineFromText(text, int4)
+CREATE OR REPLACE FUNCTION MLineFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5243,10 +5229,10 @@ CREATEFUNCTION MLineFromText(text, int4)
        THEN GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: MLineFromText(text, int4)
-CREATEFUNCTION ST_MLineFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_MLineFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5254,188 +5240,188 @@ CREATEFUNCTION ST_MLineFromText(text, int4)
        THEN GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MLineFromText(text)
+CREATE OR REPLACE FUNCTION MLineFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1)) = ''MULTILINESTRING''
        THEN GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MLineFromText(text)
+CREATE OR REPLACE FUNCTION ST_MLineFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''MULTILINESTRING''
        THEN ST_GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiLineStringFromText(text)
+CREATE OR REPLACE FUNCTION MultiLineStringFromText(text)
        RETURNS geometry
        AS 'SELECT ST_MLineFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiLineStringFromText(text)
+CREATE OR REPLACE FUNCTION ST_MultiLineStringFromText(text)
        RETURNS geometry
        AS 'SELECT ST_MLineFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiLineStringFromText(text, int4)
+CREATE OR REPLACE FUNCTION MultiLineStringFromText(text, int4)
        RETURNS geometry
        AS 'SELECT MLineFromText($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiLineStringFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_MultiLineStringFromText(text, int4)
        RETURNS geometry
        AS 'SELECT MLineFromText($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MPointFromText(text, int4)
+CREATE OR REPLACE FUNCTION MPointFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1,$2)) = ''MULTIPOINT''
        THEN GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: MPointFromText(text, int4)
-CREATEFUNCTION ST_MPointFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_MPointFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1, $2)) = ''MULTIPOINT''
        THEN GeomFromText($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MPointFromText(text)
+CREATE OR REPLACE FUNCTION MPointFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1)) = ''MULTIPOINT''
        THEN GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MPointFromText(text)
+CREATE OR REPLACE FUNCTION ST_MPointFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''MULTIPOINT''
        THEN ST_GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiPointFromText(text, int4)
+CREATE OR REPLACE FUNCTION MultiPointFromText(text, int4)
        RETURNS geometry
        AS 'SELECT MPointFromText($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiPointFromText(text)
+CREATE OR REPLACE FUNCTION MultiPointFromText(text)
        RETURNS geometry
        AS 'SELECT MPointFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiPointFromText(text)
+CREATE OR REPLACE FUNCTION ST_MultiPointFromText(text)
        RETURNS geometry
        AS 'SELECT ST_MPointFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiPointFromText(text)
+CREATE OR REPLACE FUNCTION MultiPointFromText(text)
        RETURNS geometry
        AS 'SELECT MPointFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiPointFromText(text)
+CREATE OR REPLACE FUNCTION ST_MultiPointFromText(text)
        RETURNS geometry
        AS 'SELECT MPointFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MPolyFromText(text, int4)
+CREATE OR REPLACE FUNCTION MPolyFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1, $2)) = ''MULTIPOLYGON''
        THEN GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: MPolyFromText(text, int4)
-CREATEFUNCTION ST_MPolyFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_MPolyFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromText($1, $2)) = ''MULTIPOLYGON''
        THEN ST_GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MPolyFromText(text)
+CREATE OR REPLACE FUNCTION MPolyFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromText($1)) = ''MULTIPOLYGON''
        THEN GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 --Availability: 1.2.2
-CREATEFUNCTION ST_MPolyFromText(text)
+CREATE OR REPLACE FUNCTION ST_MPolyFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromText($1)) = ''MULTIPOLYGON''
        THEN ST_GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiPolygonFromText(text, int4)
+CREATE OR REPLACE FUNCTION MultiPolygonFromText(text, int4)
        RETURNS geometry
        AS 'SELECT MPolyFromText($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiPolygonFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_MultiPolygonFromText(text, int4)
        RETURNS geometry
        AS 'SELECT MPolyFromText($1, $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiPolygonFromText(text)
+CREATE OR REPLACE FUNCTION MultiPolygonFromText(text)
        RETURNS geometry
        AS 'SELECT MPolyFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiPolygonFromText(text)
+CREATE OR REPLACE FUNCTION ST_MultiPolygonFromText(text)
        RETURNS geometry
        AS 'SELECT MPolyFromText($1)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomCollFromText(text, int4)
+CREATE OR REPLACE FUNCTION GeomCollFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5443,10 +5429,10 @@ CREATEFUNCTION GeomCollFromText(text, int4)
        THEN GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeomCollFromText(text, int4)
+CREATE OR REPLACE FUNCTION ST_GeomCollFromText(text, int4)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5454,10 +5440,10 @@ CREATEFUNCTION ST_GeomCollFromText(text, int4)
        THEN ST_GeomFromText($1,$2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomCollFromText(text)
+CREATE OR REPLACE FUNCTION GeomCollFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5465,10 +5451,10 @@ CREATEFUNCTION GeomCollFromText(text)
        THEN GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeomCollFromText(text)
+CREATE OR REPLACE FUNCTION ST_GeomCollFromText(text)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5476,474 +5462,474 @@ CREATEFUNCTION ST_GeomCollFromText(text)
        THEN ST_GeomFromText($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomFromWKB(bytea)
+CREATE OR REPLACE FUNCTION GeomFromWKB(bytea)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_from_WKB'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeomFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_GeomFromWKB(bytea)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_from_WKB'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION GeomFromWKB(bytea, int)
        RETURNS geometry
        AS 'SELECT setSRID(GeomFromWKB($1), $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: GeomFromWKB(bytea, int)
-CREATEFUNCTION ST_GeomFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_GeomFromWKB(bytea, int)
        RETURNS geometry
        AS 'SELECT ST_SetSRID(ST_GeomFromWKB($1), $2)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PointFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION PointFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''POINT''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: PointFromWKB(bytea, int)
-CREATEFUNCTION ST_PointFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_PointFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''POINT''
        THEN ST_GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PointFromWKB(bytea)
+CREATE OR REPLACE FUNCTION PointFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''POINT''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_PointFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_PointFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''POINT''
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LineFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION LineFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''LINESTRING''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: LineFromWKB(bytea, int)
-CREATEFUNCTION ST_LineFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_LineFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''LINESTRING''
        THEN ST_GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LineFromWKB(bytea)
+CREATE OR REPLACE FUNCTION LineFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''LINESTRING''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_LineFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_LineFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''LINESTRING''
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LinestringFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION LinestringFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''LINESTRING''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_LinestringFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_LinestringFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''LINESTRING''
        THEN ST_GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION LinestringFromWKB(bytea)
+CREATE OR REPLACE FUNCTION LinestringFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''LINESTRING''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_LinestringFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_LinestringFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''LINESTRING''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PolyFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION PolyFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''POLYGON''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: PolyFromWKB(text, int)
-CREATEFUNCTION ST_PolyFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_PolyFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''POLYGON''
        THEN ST_GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PolyFromWKB(bytea)
+CREATE OR REPLACE FUNCTION PolyFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''POLYGON''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_PolyFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_PolyFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''POLYGON''
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PolygonFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION PolygonFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1,$2)) = ''POLYGON''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_PolygonFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_PolygonFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1,$2)) = ''POLYGON''
        THEN ST_GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION PolygonFromWKB(bytea)
+CREATE OR REPLACE FUNCTION PolygonFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''POLYGON''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_PolygonFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_PolygonFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''POLYGON''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MPointFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION MPointFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1,$2)) = ''MULTIPOINT''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: MPointFromWKB(text, int)
-CREATEFUNCTION ST_MPointFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_MPointFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''MULTIPOINT''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MPointFromWKB(bytea)
+CREATE OR REPLACE FUNCTION MPointFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''MULTIPOINT''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MPointFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_MPointFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTIPOINT''
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiPointFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION MultiPointFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1,$2)) = ''MULTIPOINT''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiPointFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_MultiPointFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1,$2)) = ''MULTIPOINT''
        THEN ST_GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiPointFromWKB(bytea)
+CREATE OR REPLACE FUNCTION MultiPointFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''MULTIPOINT''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiPointFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_MultiPointFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTIPOINT''
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiLineFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION MultiLineFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''MULTILINESTRING''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION MultiLineFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION MultiLineFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''MULTILINESTRING''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiLineFromWKB(bytea)
+CREATE OR REPLACE FUNCTION MultiLineFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''MULTILINESTRING''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiLineFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_MultiLineFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTILINESTRING''
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MLineFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION MLineFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''MULTILINESTRING''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: MLineFromWKB(text, int)
-CREATEFUNCTION ST_MLineFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_MLineFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''MULTILINESTRING''
        THEN ST_GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MLineFromWKB(bytea)
+CREATE OR REPLACE FUNCTION MLineFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''MULTILINESTRING''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MLineFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_MLineFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTILINESTRING''
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MPolyFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION MPolyFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''MULTIPOLYGON''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: MPolyFromWKB(bytea, int)
-CREATEFUNCTION ST_MPolyFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_MPolyFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''MULTIPOLYGON''
        THEN ST_GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MPolyFromWKB(bytea)
+CREATE OR REPLACE FUNCTION MPolyFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''MULTIPOLYGON''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MPolyFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_MPolyFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTIPOLYGON''
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiPolyFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION MultiPolyFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1, $2)) = ''MULTIPOLYGON''
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiPolyFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_MultiPolyFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1, $2)) = ''MULTIPOLYGON''
        THEN ST_GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION MultiPolyFromWKB(bytea)
+CREATE OR REPLACE FUNCTION MultiPolyFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(GeomFromWKB($1)) = ''MULTIPOLYGON''
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_MultiPolyFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_MultiPolyFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE WHEN geometrytype(ST_GeomFromWKB($1)) = ''MULTIPOLYGON''
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomCollFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION GeomCollFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5951,10 +5937,10 @@ CREATEFUNCTION GeomCollFromWKB(bytea, int)
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeomCollFromWKB(bytea, int)
+CREATE OR REPLACE FUNCTION ST_GeomCollFromWKB(bytea, int)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5962,10 +5948,10 @@ CREATEFUNCTION ST_GeomCollFromWKB(bytea, int)
        THEN GeomFromWKB($1, $2)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Deprecation in 1.2.3
-CREATEFUNCTION GeomCollFromWKB(bytea)
+CREATE OR REPLACE FUNCTION GeomCollFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5973,10 +5959,10 @@ CREATEFUNCTION GeomCollFromWKB(bytea)
        THEN GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_GeomCollFromWKB(bytea)
+CREATE OR REPLACE FUNCTION ST_GeomCollFromWKB(bytea)
        RETURNS geometry
        AS '
        SELECT CASE
@@ -5984,7 +5970,7 @@ CREATEFUNCTION ST_GeomCollFromWKB(bytea)
        THEN ST_GeomFromWKB($1)
        ELSE NULL END
        '
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 --
 -- SFSQL 1.1
@@ -6001,7 +5987,7 @@ CREATEFUNCTION ST_GeomCollFromWKB(bytea)
 -- Also, we profit from plpgsql to RAISE exceptions.
 --
 -- Deprecation in 1.2.3
-CREATEFUNCTION BdPolyFromText(text, integer)
+CREATE OR REPLACE FUNCTION BdPolyFromText(text, integer)
 RETURNS geometry
 AS $$ 
 DECLARE
@@ -6027,10 +6013,10 @@ BEGIN
        RETURN geom;
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; 
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_BdPolyFromText(text, integer)
+CREATE OR REPLACE FUNCTION ST_BdPolyFromText(text, integer)
 RETURNS geometry
 AS $$ 
 DECLARE
@@ -6056,7 +6042,7 @@ BEGIN
        RETURN geom;
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; 
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 --
 -- SFSQL 1.1
@@ -6071,7 +6057,7 @@ LANGUAGE 'plpgsql' _IMMUTABLE_STRICT;
 -- To raise an exception in case of invalid input.
 --
 -- Deprecation in 1.2.3
-CREATEFUNCTION BdMPolyFromText(text, integer)
+CREATE OR REPLACE FUNCTION BdMPolyFromText(text, integer)
 RETURNS geometry
 AS $$ 
 DECLARE
@@ -6092,10 +6078,10 @@ BEGIN
        RETURN geom;
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; 
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 -- Availability: 1.2.2
-CREATEFUNCTION ST_BdMPolyFromText(text, integer)
+CREATE OR REPLACE FUNCTION ST_BdMPolyFromText(text, integer)
 RETURNS geometry
 AS $$ 
 DECLARE
@@ -6116,7 +6102,7 @@ BEGIN
        RETURN geom;
 END;
 $$
-LANGUAGE 'plpgsql' _IMMUTABLE_STRICT; 
+LANGUAGE 'plpgsql' IMMUTABLE STRICT; 
 
 #include "long_xact.sql.in.c"
 #include "sqlmm.sql.in.c"
@@ -6133,10 +6119,10 @@ LANGUAGE 'plpgsql' _IMMUTABLE_STRICT;
 -- Converts a given geometry to a linear geometry.  Each curveed
 -- geometry or segment is converted into a linear approximation using
 -- the given number of segments per quarter circle.
-CREATEFUNCTION ST_CurveToLine(geometry, integer)
-   RETURNS geometry
-   AS 'MODULE_PATHNAME', 'LWGEOM_curve_segmentize'
-   LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_CurveToLine(geometry, integer)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_curve_segmentize'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 --
 -- SQL-MM
 --
@@ -6145,19 +6131,19 @@ CREATEFUNCTION ST_CurveToLine(geometry, integer)
 -- Converts a given geometry to a linear geometry.  Each curveed
 -- geometry or segment is converted into a linear approximation using
 -- the default value of 32 segments per quarter circle
-CREATEFUNCTION ST_CurveToLine(geometry)
+CREATE OR REPLACE FUNCTION ST_CurveToLine(geometry)
        RETURNS geometry AS 'SELECT ST_CurveToLine($1, 32)'
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
-CREATEFUNCTION ST_HasArc(geometry)
+CREATE OR REPLACE FUNCTION ST_HasArc(geometry)
        RETURNS boolean
        AS 'MODULE_PATHNAME', 'LWGEOM_has_arc'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
-CREATEFUNCTION ST_LineToCurve(geometry)
-        RETURNS geometry
-        AS 'MODULE_PATHNAME', 'LWGEOM_line_desegmentize'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; 
+CREATE OR REPLACE FUNCTION ST_LineToCurve(geometry)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME', 'LWGEOM_line_desegmentize'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 ---------------------------------------------------------------
 -- END
 ---------------------------------------------------------------
@@ -6175,27 +6161,27 @@ CREATEFUNCTION ST_LineToCurve(geometry)
 -- Contributed by Bruce Rindahl
 -- Availability: 1.4.0
 -----------------------------------------------------------------------
-CREATEFUNCTION ST_MinimumBoundingCircle(inputgeom geometry, segs_per_quarter integer)
-  RETURNS geometry AS
+CREATE OR REPLACE FUNCTION ST_MinimumBoundingCircle(inputgeom geometry, segs_per_quarter integer)
+       RETURNS geometry AS
 $BODY$
-  DECLARE     
-    hull GEOMETRY;
-    ring GEOMETRY;
-    center GEOMETRY;
-    radius DOUBLE PRECISION;
-    dist DOUBLE PRECISION;
-    d DOUBLE PRECISION;
-    idx1 integer;
-    idx2 integer;
-    l1 GEOMETRY;
-    l2 GEOMETRY;
-    p1 GEOMETRY;
-    p2 GEOMETRY;
-    a1 DOUBLE PRECISION;
-    a2 DOUBLE PRECISION;
-
-    
-  BEGIN
+       DECLARE     
+       hull GEOMETRY;
+       ring GEOMETRY;
+       center GEOMETRY;
+       radius DOUBLE PRECISION;
+       dist DOUBLE PRECISION;
+       d DOUBLE PRECISION;
+       idx1 integer;
+       idx2 integer;
+       l1 GEOMETRY;
+       l2 GEOMETRY;
+       p1 GEOMETRY;
+       p2 GEOMETRY;
+       a1 DOUBLE PRECISION;
+       a2 DOUBLE PRECISION;
+
+       
+       BEGIN
 
        -- First compute the ConvexHull of the geometry
        hull = ST_ConvexHull(inputgeom);
@@ -6271,13 +6257,13 @@ $BODY$
                END IF;
                END LOOP;
        --DONE!!  Return the MBC via the buffer command
-    RETURN ST_Buffer(center,radius,segs_per_quarter);
+       RETURN ST_Buffer(center,radius,segs_per_quarter);
 
-  END;
+       END;
 $BODY$
-  LANGUAGE 'plpgsql' IMMUTABLE STRICT;
-  
-CREATEFUNCTION ST_MinimumBoundingCircle(geometry)
+       LANGUAGE 'plpgsql' IMMUTABLE STRICT;
+       
+CREATE OR REPLACE FUNCTION ST_MinimumBoundingCircle(geometry)
  RETURNS geometry AS
 'SELECT ST_MinimumBoundingCircle($1, 48)'
  LANGUAGE 'sql' IMMUTABLE STRICT;
index 910d6103e7a0ca812f2d9266d43d598d8cc94d48..81dbd079172c026625b3067247450fbfd0603a36 100644 (file)
 #define _POSTGIS_SQL_SELECT_POSTGIS_BUILD_DATE 'SELECT ''@POSTGIS_BUILD_DATE@''::text AS version'
 #define _POSTGIS_SQL_SELECT_POSTGIS_SCRIPTS_VERSION 'SELECT ''@POSTGIS_SCRIPTS_VERSION@''::text AS version'
 
-#define CREATEFUNCTION CREATE OR REPLACE FUNCTION
-
-# define _IMMUTABLE_STRICT IMMUTABLE STRICT
-# define _IMMUTABLE IMMUTABLE
-# define _STABLE_STRICT STABLE STRICT
-# define _STABLE STABLE
-# define _VOLATILE_STRICT VOLATILE STRICT
-# define _VOLATILE VOLATILE
-# define _STRICT STRICT
-# define _SECURITY_DEFINER SECURITY DEFINER
-
 #endif /* _LWPGIS_DEFINES */
index bf8d26309732c7d6e0a4dc69721afee9ccc4d7f9..fb38efd801a4a06224cecfcd7867d7fc8b4c2721 100644 (file)
 
 -- PostGIS equivalent function: ST_GeometryFromText(text)
 -- Note: Defaults to an SRID=-1, not 0 as per SQL/MM specs.
-CREATEFUNCTION ST_WKTToSQL(text)
-       RETURNS geometry
-        AS 'MODULE_PATHNAME','LWGEOM_from_text'
-        LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+CREATE OR REPLACE FUNCTION ST_WKTToSQL(text)
+       RETURNS geometry
+       AS 'MODULE_PATHNAME','LWGEOM_from_text'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- ST_GeomFromText(text, int4) - already defined
 -- ST_PointFromText(text, int4) - already defined
@@ -71,10 +71,10 @@ CREATEFUNCTION ST_WKTToSQL(text)
 -- PostGIS equivalent function: GeomFromWKB(bytea))
 -- Note: Defaults to an SRID=-1, not 0 as per SQL/MM specs.
 
-CREATEFUNCTION ST_WKBToSQL(bytea)
+CREATE OR REPLACE FUNCTION ST_WKBToSQL(bytea)
        RETURNS geometry
        AS 'MODULE_PATHNAME','LWGEOM_from_WKB'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- ST_GeomFromWKB(bytea, int) - already defined
 -- ST_PointFromWKB(bytea, int) - already defined
@@ -118,20 +118,20 @@ CREATEFUNCTION ST_WKBToSQL(bytea)
 -------------------------------------------------------------------------------
 
 -- TODO: SE_AsShape(geometry)
---CREATEFUNCTION SE_AsShape(geometry)
+--CREATE OR REPLACE FUNCTION SE_AsShape(geometry)
 --    RETURNS bytea
 --    AS 'MODULE_PATHNAME','LWGEOM_AsShape'
---    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+--    LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -------------------------------------------------------------------------------
 -- SQL/MM (ArcSDE subset) - SQL Functions on type ST_Geometry
 -------------------------------------------------------------------------------
 
 -- PostGIS equivalent function: ndims(geometry)
-CREATEFUNCTION ST_CoordDim(geometry)
-    RETURNS smallint
-    AS 'MODULE_PATHNAME', 'LWGEOM_ndims'
-    LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+CREATE OR REPLACE FUNCTION ST_CoordDim(geometry)
+       RETURNS smallint
+       AS 'MODULE_PATHNAME', 'LWGEOM_ndims'
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- ST_Dimension(geometry) - already defined.
 -- ST_GeometryType(geometry) - already defined.
@@ -149,40 +149,40 @@ CREATEFUNCTION ST_CoordDim(geometry)
 -- ST_Y(geometry) - already defined.
 
 -- PostGIS equivalent function: ~= 
-CREATEFUNCTION ST_OrderingEquals(geometry, geometry)
-    RETURNS boolean
-    AS $$ 
-    SELECT $1 && $2 AND $1 ~= $2
+CREATE OR REPLACE FUNCTION ST_OrderingEquals(geometry, geometry)
+       RETURNS boolean
+       AS $$ 
+       SELECT $1 && $2 AND $1 ~= $2
        $$      
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: zmflag(geometry)
-CREATEFUNCTION SE_Is3D(geometry)
-    RETURNS boolean
-    AS $$ 
-    SELECT CASE ST_zmflag($1)
-               WHEN 0 THEN false
-               WHEN 1 THEN false
-               WHEN 2 THEN true
-               WHEN 3 THEN true
-               ELSE false
-           END
+CREATE OR REPLACE FUNCTION SE_Is3D(geometry)
+       RETURNS boolean
+       AS $$ 
+       SELECT CASE ST_zmflag($1)
+              WHEN 0 THEN false
+              WHEN 1 THEN false
+              WHEN 2 THEN true
+              WHEN 3 THEN true
+              ELSE false
+          END
        $$      
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: zmflag(geometry)
-CREATEFUNCTION SE_IsMeasured(geometry)
-    RETURNS boolean
-    AS $$ 
-    SELECT CASE ST_zmflag($1)
-               WHEN 0 THEN false
-               WHEN 1 THEN true
-               WHEN 2 THEN false
-               WHEN 3 THEN true
-               ELSE false
-           END
+CREATE OR REPLACE FUNCTION SE_IsMeasured(geometry)
+       RETURNS boolean
+       AS $$ 
+       SELECT CASE ST_zmflag($1)
+              WHEN 0 THEN false
+              WHEN 1 THEN true
+              WHEN 2 THEN false
+              WHEN 3 THEN true
+              ELSE false
+          END
        $$      
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 
 
@@ -193,22 +193,22 @@ CREATEFUNCTION SE_IsMeasured(geometry)
 -------------------------------------------------------------------------------
 
 -- PostGIS equivalent function: makePoint(float8,float8)
-CREATEFUNCTION ST_Point(float8, float8)
+CREATE OR REPLACE FUNCTION ST_Point(float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_makepoint'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (iscachable,isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: Z(geometry)
-CREATEFUNCTION SE_Z(geometry)
+CREATE OR REPLACE FUNCTION SE_Z(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_z_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -- PostGIS equivalent function: M(geometry)
-CREATEFUNCTION SE_M(geometry)
+CREATE OR REPLACE FUNCTION SE_M(geometry)
        RETURNS float8
        AS 'MODULE_PATHNAME','LWGEOM_m_point'
-       LANGUAGE 'C' _IMMUTABLE_STRICT; -- WITH (isstrict);
+       LANGUAGE 'C' IMMUTABLE STRICT; 
 
 -------------------------------------------------------------------------------
 -- SQL/MM (ArcSDE subset) - SQL Functions on type ST_Curve
@@ -241,12 +241,12 @@ CREATEFUNCTION SE_M(geometry)
 -------------------------------------------------------------------------------
 
 -- PostGIS equivalent function: MakePolygon(geometry)
-CREATEFUNCTION ST_Polygon(geometry, int)
+CREATE OR REPLACE FUNCTION ST_Polygon(geometry, int)
        RETURNS geometry
        AS $$ 
        SELECT setSRID(makepolygon($1), $2)
        $$      
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -- ST_ExteriorRing(geometry) - already defined.
 -- ST_NumInteriorRing(geometry) - already defined.
@@ -290,12 +290,12 @@ CREATEFUNCTION ST_Polygon(geometry, int)
 -- ST_Relate(geometry, geometry, text) - already defined.
 
 -- PostGIS equivalent function: none
-CREATEFUNCTION SE_EnvelopesIntersect(geometry,geometry)
-    RETURNS boolean
+CREATE OR REPLACE FUNCTION SE_EnvelopesIntersect(geometry,geometry)
+       RETURNS boolean
        AS $$ 
        SELECT $1 && $2
        $$      
-       LANGUAGE 'SQL' _IMMUTABLE_STRICT; -- WITH (isstrict,iscachable);
+       LANGUAGE 'SQL' IMMUTABLE STRICT; 
 
 -------------------------------------------------------------------------------
 -- SQL/MM (ArcSDE subset) - SQL Functions for distance relationships
@@ -315,16 +315,16 @@ CREATEFUNCTION SE_EnvelopesIntersect(geometry,geometry)
 -- ST_ConvexHull(geometry) already defined.
 
 -- PostGIS equivalent function: locate_along_measure(geometry, float8)
-CREATEFUNCTION SE_LocateAlong(geometry, float8)
+CREATE OR REPLACE FUNCTION SE_LocateAlong(geometry, float8)
        RETURNS geometry
        AS $$ SELECT locate_between_measures($1, $2, $2) $$
-       LANGUAGE 'sql' _IMMUTABLE_STRICT;
+       LANGUAGE 'sql' IMMUTABLE STRICT;
 
 -- PostGIS equivalent function: locate_between_measures(geometry, float8, float8)
-CREATEFUNCTION SE_LocateBetween(geometry, float8, float8)
+CREATE OR REPLACE FUNCTION SE_LocateBetween(geometry, float8, float8)
        RETURNS geometry
        AS 'MODULE_PATHNAME', 'LWGEOM_locate_between_m'
-       LANGUAGE 'C' _IMMUTABLE_STRICT;
+       LANGUAGE 'C' IMMUTABLE STRICT;