| Procedures | 
        
            
            
        
        
            | _st_asgeojson(integer,
                    geography, integer, integer) |  | 
        
            | _st_asgeojson(integer,
                    geometry, integer, integer) |  | 
        
            | _st_asgml(integer,
                    geography, integer, integer) |  | 
        
            | _st_asgml(integer,
                    geometry, integer, integer) |  | 
        
            | _st_askml(integer, geography,
                    integer) |  | 
        
            | _st_askml(integer, geometry,
                    integer) |  | 
        
            | _st_bestsrid(geography) |  | 
        
            | _st_bestsrid(geography,
                    geography) |  | 
        
            | _st_buffer(geometry,
                    double precision, cstring) |  | 
        
            | _st_contains(geometry, geometry) |  | 
        
            | _st_containsproperly(geometry,
                    geometry) |  | 
        
            | _st_coveredby(geometry,
                    geometry) |  | 
        
            | _st_covers(geography, geography) |  | 
        
            | _st_covers(geometry, geometry) |  | 
        
            | _st_crosses(geometry, geometry) |  | 
        
            | _st_dfullywithin(geometry,
                    geometry, double precision) |  | 
        
            | _st_distance(geography,
                    geography, double precision, boolean) |  | 
        
            | _st_dumppoints(the_geom
                    geometry, cur_path integer[]) |  | 
        
            | _st_dwithin(geography,
                    geography, double precision, boolean) |  | 
        
            | _st_dwithin(geometry,
                    geometry, double precision) |  | 
        
            | _st_equals(geometry, geometry) |  | 
        
            | _st_expand(geography, double
                    precision) |  | 
        
            | _st_intersects(geometry,
                    geometry) |  | 
        
            | _st_linecrossingdirection(geometry,
                    geometry) |  | 
        
            | _st_longestline(geometry,
                    geometry) |  | 
        
            | _st_maxdistance(geometry,
                    geometry) |  | 
        
            | _st_orderingequals(geometry,
                    geometry) |  | 
        
            | _st_overlaps(geometry, geometry) |  | 
        
            | _st_pointoutside(geography) |  | 
        
            | _st_touches(geometry, geometry) |  | 
        
            | _st_within(geometry, geometry) |  | 
        
            | accum(geometry) |  | 
        
            | addauth(text) |  | 
        
            | addbbox(geometry) |  | 
        
            | addgeometrycolumn(character
                    varying, character varying, character varying, character varying, integer, character varying,
                    integer) |  | 
        
            | addgeometrycolumn(character
                    varying, character varying, character varying, integer, character varying, integer) |  | 
        
            | addgeometrycolumn(character
                    varying, character varying, integer, character varying, integer) |  | 
        
            | addpoint(geometry, geometry) |  | 
        
            | addpoint(geometry, geometry,
                    integer) |  | 
        
            | affine(geometry,
                    double precision, double precision, double precision, double precision, double precision, double
                    precision) |  | 
        
            | affine(geometry,
                    double precision, double precision, double precision, double precision, double precision, double
                    precision, double precision, double precision, double precision, double precision, double precision,
                    double precision) |  | 
        
            | area(geometry) |  | 
        
            | area2d(geometry) |  | 
        
            | asbinary(geometry) |  | 
        
            | asbinary(geometry, text) |  | 
        
            | asewkb(geometry) |  | 
        
            | asewkb(geometry, text) |  | 
        
            | asewkt(geometry) |  | 
        
            | asgml(geometry) |  | 
        
            | asgml(geometry, integer) |  | 
        
            | ashexewkb(geometry) |  | 
        
            | ashexewkb(geometry, text) |  | 
        
            | askml(geometry) |  | 
        
            | askml(geometry, integer) |  | 
        
            | askml(integer, geometry,
                    integer) |  | 
        
            | assvg(geometry) |  | 
        
            | assvg(geometry, integer) |  | 
        
            | assvg(geometry, integer,
                    integer) |  | 
        
            | astext(geometry) |  | 
        
            | azimuth(geometry, geometry) |  | 
        
            | bdmpolyfromtext(text, integer) |  | 
        
            | bdpolyfromtext(text, integer) |  | 
        
            | boundary(geometry) |  | 
        
            | box(box3d) |  | 
        
            | box(geometry) |  | 
        
            | box2d(box3d) |  | 
        
            | box2d(box3d_extent) |  | 
        
            | box2d(geometry) |  | 
        
            | box2d_in(cstring) |  | 
        
            | box2d_out(box2d) |  | 
        
            | box3d(box2d) |  | 
        
            | box3d(geometry) |  | 
        
            | box3d_extent(box3d_extent) |  | 
        
            | box3d_extent_in(cstring) |  | 
        
            | box3d_extent_out(box3d_extent) |  | 
        
            | box3d_in(cstring) |  | 
        
            | box3d_out(box3d) |  | 
        
            | box3dtobox(box3d) |  | 
        
            | buffer(geometry, double
                    precision) |  | 
        
            | buffer(geometry, double
                    precision, integer) |  | 
        
            | buildarea(geometry) |  | 
        
            | bytea(geometry) |  | 
        
            | centroid(geometry) |  | 
        
            | checkauth(text, text) |  | 
        
            | checkauth(text, text, text) |  | 
        
            | checkauthtrigger() |  | 
        
            | chip_in(cstring) |  | 
        
            | chip_out(chip) |  | 
        
            | collect(geometry) |  | 
        
            | collect(geometry, geometry) |  | 
        
            | combine_bbox(box2d, geometry) |  | 
        
            | combine_bbox(box3d, geometry) |  | 
        
            | combine_bbox(box3d_extent,
                    geometry) |  | 
        
            | compression(chip) |  | 
        
            | contains(geometry, geometry) |  | 
        
            | convexhull(geometry) |  | 
        
            | crosses(geometry, geometry) |  | 
        
            | datatype(chip) |  | 
        
            | difference(geometry, geometry) |  | 
        
            | dimension(geometry) |  | 
        
            | disablelongtransactions() |  | 
        
            | disjoint(geometry, geometry) |  | 
        
            | distance(geometry, geometry) |  | 
        
            | distance_sphere(geometry,
                    geometry) |  | 
        
            | distance_spheroid(geometry,
                    geometry, spheroid) |  | 
        
            | dropbbox(geometry) |  | 
        
            | dropgeometrycolumn(character
                    varying, character varying) |  | 
        
            | dropgeometrycolumn(character
                    varying, character varying, character varying) |  | 
        
            | dropgeometrycolumn(character
                    varying, character varying, character varying, character varying) |  | 
        
            | dropgeometrytable(character
                    varying) |  | 
        
            | dropgeometrytable(character
                    varying, character varying) |  | 
        
            | dropgeometrytable(character
                    varying, character varying, character varying) |  | 
        
            | dump(geometry) |  | 
        
            | dumprings(geometry) |  | 
        
            | enablelongtransactions() |  | 
        
            | endpoint(geometry) |  | 
        
            | envelope(geometry) |  | 
        
            | equals(geometry, geometry) |  | 
        
            | estimated_extent(text, text) |  | 
        
            | estimated_extent(text, text,
                    text) |  | 
        
            | expand(box2d, double precision) |  | 
        
            | expand(box3d, double precision) |  | 
        
            | expand(geometry, double
                    precision) |  | 
        
            | extent(geometry) |  | 
        
            | extent3d(geometry) |  | 
        
            | exteriorring(geometry) |  | 
        
            | factor(chip) |  | 
        
            | find_extent(text, text) |  | 
        
            | find_extent(text, text, text) |  | 
        
            | find_srid(character
                    varying, character varying, character varying) |  | 
        
            | fix_geometry_columns() |  | 
        
            | force_2d(geometry) |  | 
        
            | force_3d(geometry) |  | 
        
            | force_3dm(geometry) |  | 
        
            | force_3dz(geometry) |  | 
        
            | force_4d(geometry) |  | 
        
            | force_collection(geometry) |  | 
        
            | forcerhr(geometry) |  | 
        
            | geography(geography, integer,
                    boolean) |  | 
        
            | geography(geometry) |  | 
        
            | geography_analyze(internal) |  | 
        
            | geography_cmp(geography,
                    geography) |  | 
        
            | geography_eq(geography,
                    geography) |  | 
        
            | geography_ge(geography,
                    geography) |  | 
        
            | geography_gist_compress(internal) |  | 
        
            | geography_gist_consistent(internal,
                    geometry, integer) |  | 
        
            | geography_gist_decompress(internal) |  | 
        
            | geography_gist_join_selectivity(internal,
                    oid, internal, smallint) |  | 
        
            | geography_gist_penalty(internal,
                    internal, internal) |  | 
        
            | geography_gist_picksplit(internal,
                    internal) |  | 
        
            | geography_gist_same(box2d,
                    box2d, internal) |  | 
        
            | geography_gist_selectivity(internal,
                    oid, internal, integer) |  | 
        
            | geography_gist_union(bytea,
                    internal) |  | 
        
            | geography_gt(geography,
                    geography) |  | 
        
            | geography_in(cstring, oid,
                    integer) |  | 
        
            | geography_le(geography,
                    geography) |  | 
        
            | geography_lt(geography,
                    geography) |  | 
        
            | geography_out(geography) |  | 
        
            | geography_overlaps(geography,
                    geography) |  | 
        
            | geography_typmod_dims(integer) |  | 
        
            | geography_typmod_in(cstring[]) |  | 
        
            | geography_typmod_out(integer) |  | 
        
            | geography_typmod_srid(integer) |  | 
        
            | geography_typmod_type(integer) |  | 
        
            | geomcollfromtext(text) |  | 
        
            | geomcollfromtext(text, integer) |  | 
        
            | geomcollfromwkb(bytea) |  | 
        
            | geomcollfromwkb(bytea, integer) |  | 
        
            | geometry(box2d) |  | 
        
            | geometry(box3d) |  | 
        
            | geometry(box3d_extent) |  | 
        
            | geometry(bytea) |  | 
        
            | geometry(chip) |  | 
        
            | geometry(geography) |  | 
        
            | geometry(text) |  | 
        
            | geometry_above(geometry,
                    geometry) |  | 
        
            | geometry_analyze(internal) |  | 
        
            | geometry_below(geometry,
                    geometry) |  | 
        
            | geometry_cmp(geometry, geometry) |  | 
        
            | geometry_contain(geometry,
                    geometry) |  | 
        
            | geometry_contained(geometry,
                    geometry) |  | 
        
            | geometry_eq(geometry, geometry) |  | 
        
            | geometry_ge(geometry, geometry) |  | 
        
            | geometry_gist_joinsel(internal,
                    oid, internal, smallint) |  | 
        
            | geometry_gist_sel(internal,
                    oid, internal, integer) |  | 
        
            | geometry_gt(geometry, geometry) |  | 
        
            | geometry_in(cstring) |  | 
        
            | geometry_le(geometry, geometry) |  | 
        
            | geometry_left(geometry,
                    geometry) |  | 
        
            | geometry_lt(geometry, geometry) |  | 
        
            | geometry_out(geometry) |  | 
        
            | geometry_overabove(geometry,
                    geometry) |  | 
        
            | geometry_overbelow(geometry,
                    geometry) |  | 
        
            | geometry_overlap(geometry,
                    geometry) |  | 
        
            | geometry_overleft(geometry,
                    geometry) |  | 
        
            | geometry_overright(geometry,
                    geometry) |  | 
        
            | geometry_recv(internal) |  | 
        
            | geometry_right(geometry,
                    geometry) |  | 
        
            | geometry_same(geometry,
                    geometry) |  | 
        
            | geometry_samebox(geometry,
                    geometry) |  | 
        
            | geometry_send(geometry) |  | 
        
            | geometryfromtext(text) |  | 
        
            | geometryfromtext(text, integer) |  | 
        
            | geometryn(geometry, integer) |  | 
        
            | geometrytype(geometry) |  | 
        
            | geomfromewkb(bytea) |  | 
        
            | geomfromewkt(text) |  | 
        
            | geomfromtext(text) |  | 
        
            | geomfromtext(text, integer) |  | 
        
            | geomfromwkb(bytea) |  | 
        
            | geomfromwkb(bytea, integer) |  | 
        
            | geomunion(geometry, geometry) |  | 
        
            | get_proj4_from_srid(integer) |  | 
        
            | getbbox(geometry) |  | 
        
            | getnextigsnint(usercode
                    character varying) |  | 
        
            | getsrid(geometry) |  | 
        
            | gettransactionid() |  | 
        
            | gidx_in(cstring) |  | 
        
            | gidx_out(gidx) |  | 
        
            | hasbbox(geometry) |  | 
        
            | height(chip) |  | 
        
            | interiorringn(geometry, integer) |  | 
        
            | intersection(geometry, geometry) |  | 
        
            | intersects(geometry, geometry) |  | 
        
            | isclosed(geometry) |  | 
        
            | isempty(geometry) |  | 
        
            | isring(geometry) |  | 
        
            | issimple(geometry) |  | 
        
            | isvalid(geometry) |  | 
        
            | length(geometry) |  | 
        
            | length2d(geometry) |  | 
        
            | length2d_spheroid(geometry,
                    spheroid) |  | 
        
            | length3d(geometry) |  | 
        
            | length3d_spheroid(geometry,
                    spheroid) |  | 
        
            | length_spheroid(geometry,
                    spheroid) |  | 
        
            | line_interpolate_point(geometry,
                    double precision) |  | 
        
            | line_locate_point(geometry,
                    geometry) |  | 
        
            | line_substring(geometry,
                    double precision, double precision) |  | 
        
            | linefrommultipoint(geometry) |  | 
        
            | linefromtext(text) |  | 
        
            | linefromtext(text, integer) |  | 
        
            | linefromwkb(bytea) |  | 
        
            | linefromwkb(bytea, integer) |  | 
        
            | linemerge(geometry) |  | 
        
            | linestringfromtext(text) |  | 
        
            | linestringfromtext(text,
                    integer) |  | 
        
            | linestringfromwkb(bytea) |  | 
        
            | linestringfromwkb(bytea,
                    integer) |  | 
        
            | locate_along_measure(geometry,
                    double precision) |  | 
        
            | locate_between_measures(geometry,
                    double precision, double precision) |  | 
        
            | lockrow(text, text, text) |  | 
        
            | lockrow(text, text, text, text) |  | 
        
            | lockrow(text,
                    text, text, text, timestamp without time zone) |  | 
        
            | lockrow(text,
                    text, text, timestamp without time zone) |  | 
        
            | longtransactionsenabled() |  | 
        
            | lwgeom_gist_compress(internal) |  | 
        
            | lwgeom_gist_consistent(internal,
                    geometry, integer) |  | 
        
            | lwgeom_gist_decompress(internal) |  | 
        
            | lwgeom_gist_penalty(internal,
                    internal, internal) |  | 
        
            | lwgeom_gist_picksplit(internal,
                    internal) |  | 
        
            | lwgeom_gist_same(box2d,
                    box2d, internal) |  | 
        
            | lwgeom_gist_union(bytea,
                    internal) |  | 
        
            | m(geometry) |  | 
        
            | makebox2d(geometry, geometry) |  | 
        
            | makebox3d(geometry, geometry) |  | 
        
            | makeline(geometry) |  | 
        
            | makeline(geometry, geometry) |  | 
        
            | makeline_garray(geometry[]) |  | 
        
            | makepoint(double
                    precision, double precision) |  | 
        
            | makepoint(double
                    precision, double precision, double precision) |  | 
        
            | makepoint(double
                    precision, double precision, double precision, double precision) |  | 
        
            | makepointm(double
                    precision, double precision, double precision) |  | 
        
            | makepolygon(geometry) |  | 
        
            | makepolygon(geometry,
                    geometry[]) |  | 
        
            | max_distance(geometry, geometry) |  | 
        
            | mem_size(geometry) |  | 
        
            | memcollect(geometry) |  | 
        
            | memgeomunion(geometry) |  | 
        
            | mlinefromtext(text) |  | 
        
            | mlinefromtext(text, integer) |  | 
        
            | mlinefromwkb(bytea) |  | 
        
            | mlinefromwkb(bytea, integer) |  | 
        
            | mpointfromtext(text) |  | 
        
            | mpointfromtext(text, integer) |  | 
        
            | mpointfromwkb(bytea) |  | 
        
            | mpointfromwkb(bytea, integer) |  | 
        
            | mpolyfromtext(text) |  | 
        
            | mpolyfromtext(text, integer) |  | 
        
            | mpolyfromwkb(bytea) |  | 
        
            | mpolyfromwkb(bytea, integer) |  | 
        
            | multi(geometry) |  | 
        
            | multilinefromwkb(bytea) |  | 
        
            | multilinefromwkb(bytea, integer) |  | 
        
            | multilinestringfromtext(text) |  | 
        
            | multilinestringfromtext(text,
                    integer) |  | 
        
            | multipointfromtext(text) |  | 
        
            | multipointfromtext(text,
                    integer) |  | 
        
            | multipointfromwkb(bytea) |  | 
        
            | multipointfromwkb(bytea,
                    integer) |  | 
        
            | multipolyfromwkb(bytea) |  | 
        
            | multipolyfromwkb(bytea, integer) |  | 
        
            | multipolygonfromtext(text) |  | 
        
            | multipolygonfromtext(text,
                    integer) |  | 
        
            | ndims(geometry) |  | 
        
            | noop(geometry) |  | 
        
            | npoints(geometry) |  | 
        
            | nrings(geometry) |  | 
        
            | numgeometries(geometry) |  | 
        
            | numinteriorring(geometry) |  | 
        
            | numinteriorrings(geometry) |  | 
        
            | numpoints(geometry) |  | 
        
            | overlaps(geometry, geometry) |  | 
        
            | perimeter(geometry) |  | 
        
            | perimeter2d(geometry) |  | 
        
            | perimeter3d(geometry) |  | 
        
            | point_inside_circle(geometry,
                    double precision, double precision, double precision) |  | 
        
            | pointfromtext(text) |  | 
        
            | pointfromtext(text, integer) |  | 
        
            | pointfromwkb(bytea) |  | 
        
            | pointfromwkb(bytea, integer) |  | 
        
            | pointn(geometry, integer) |  | 
        
            | pointonsurface(geometry) |  | 
        
            | polyfromtext(text) |  | 
        
            | polyfromtext(text, integer) |  | 
        
            | polyfromwkb(bytea) |  | 
        
            | polyfromwkb(bytea, integer) |  | 
        
            | polygonfromtext(text) |  | 
        
            | polygonfromtext(text, integer) |  | 
        
            | polygonfromwkb(bytea) |  | 
        
            | polygonfromwkb(bytea, integer) |  | 
        
            | polygonize(geometry) |  | 
        
            | polygonize_garray(geometry[]) |  | 
        
            | populate_geometry_columns() |  | 
        
            | populate_geometry_columns(tbl_oid
                    oid) |  | 
        
            | postgis_addbbox(geometry) |  | 
        
            | postgis_cache_bbox() |  | 
        
            | postgis_dropbbox(geometry) |  | 
        
            | postgis_full_version() |  | 
        
            | postgis_geos_version() |  | 
        
            | postgis_getbbox(geometry) |  | 
        
            | postgis_gist_joinsel(internal,
                    oid, internal, smallint) |  | 
        
            | postgis_gist_sel(internal,
                    oid, internal, integer) |  | 
        
            | postgis_hasbbox(geometry) |  | 
        
            | postgis_lib_build_date() |  | 
        
            | postgis_lib_version() |  | 
        
            | postgis_libxml_version() |  | 
        
            | postgis_noop(geometry) |  | 
        
            | postgis_proj_version() |  | 
        
            | postgis_scripts_build_date() |  | 
        
            | postgis_scripts_installed() |  | 
        
            | postgis_scripts_released() |  | 
        
            | postgis_transform_geometry(geometry,
                    text, text, integer) |  | 
        
            | postgis_uses_stats() |  | 
        
            | postgis_version() |  | 
        
            | probe_geometry_columns() |  | 
        
            | relate(geometry, geometry) |  | 
        
            | relate(geometry, geometry, text) |  | 
        
            | removepoint(geometry, integer) |  | 
        
            | rename_geometry_table_constraints() |  | 
        
            | reverse(geometry) |  | 
        
            | rotate(geometry, double
                    precision) |  | 
        
            | rotatex(geometry, double
                    precision) |  | 
        
            | rotatey(geometry, double
                    precision) |  | 
        
            | rotatez(geometry, double
                    precision) |  | 
        
            | sample_trg_aiud() |  | 
        
            | scale(geometry,
                    double precision, double precision) |  | 
        
            | scale(geometry,
                    double precision, double precision, double precision) |  | 
        
            | se_envelopesintersect(geometry,
                    geometry) |  | 
        
            | se_is3d(geometry) |  | 
        
            | se_ismeasured(geometry) |  | 
        
            | se_locatealong(geometry,
                    double precision) |  | 
        
            | se_locatebetween(geometry,
                    double precision, double precision) |  | 
        
            | se_m(geometry) |  | 
        
            | se_z(geometry) |  | 
        
            | segmentize(geometry, double
                    precision) |  | 
        
            | sesar_fill_geom_latlong(sample_id_min
                    integer, sample_id_max integer) |  | 
        
            | sesar_fill_igsn_count() |  | 
        
            | sesar_fixpoly(geometry) |  | 
        
            | sesar_get_count(IN text, IN
                    text) |  | 
        
            | sesar_get_none_odp_count(IN
                    text, IN text) |  | 
        
            | sesar_get_odp_count(IN text, IN
                    text) |  | 
        
            | sesar_sample_geom_latlong() |  | 
        
            | sesar_update_geom_latlong() |  | 
        
            | sesar_update_igsn_count(usercode
                    character varying) |  | 
        
            | setfactor(chip, real) |  | 
        
            | setpoint(geometry, integer,
                    geometry) |  | 
        
            | setsrid(chip, integer) |  | 
        
            | setsrid(geometry, integer) |  | 
        
            | shift_longitude(geometry) |  | 
        
            | simplify(geometry, double
                    precision) |  | 
        
            | snaptogrid(geometry, double
                    precision) |  | 
        
            | snaptogrid(geometry,
                    double precision, double precision) |  | 
        
            | snaptogrid(geometry,
                    double precision, double precision, double precision, double precision) |  | 
        
            | snaptogrid(geometry,
                    geometry, double precision, double precision, double precision, double precision) |  | 
        
            | spheroid_in(cstring) |  | 
        
            | spheroid_out(spheroid) |  | 
        
            | srid(chip) |  | 
        
            | srid(geometry) |  | 
        
            | st_accum(geometry) |  | 
        
            | st_addmeasure(geometry,
                    double precision, double precision) |  | 
        
            | st_addpoint(geometry, geometry) |  | 
        
            | st_addpoint(geometry,
                    geometry, integer) |  | 
        
            | st_affine(geometry,
                    double precision, double precision, double precision, double precision, double precision, double
                    precision) |  | 
        
            | st_affine(geometry,
                    double precision, double precision, double precision, double precision, double precision, double
                    precision, double precision, double precision, double precision, double precision, double precision,
                    double precision) |  | 
        
            | st_area(geography) |  | 
        
            | st_area(geography, boolean) |  | 
        
            | st_area(geometry) |  | 
        
            | st_area(text) |  | 
        
            | st_area2d(geometry) |  | 
        
            | st_asbinary(geography) |  | 
        
            | st_asbinary(geometry) |  | 
        
            | st_asbinary(geometry, text) |  | 
        
            | st_asbinary(text) |  | 
        
            | st_asewkb(geometry) |  | 
        
            | st_asewkb(geometry, text) |  | 
        
            | st_asewkt(geometry) |  | 
        
            | st_asgeojson(geography) |  | 
        
            | st_asgeojson(geography, integer) |  | 
        
            | st_asgeojson(geography,
                    integer, integer) |  | 
        
            | st_asgeojson(geometry) |  | 
        
            | st_asgeojson(geometry, integer) |  | 
        
            | st_asgeojson(geometry,
                    integer, integer) |  | 
        
            | st_asgeojson(integer, geography) |  | 
        
            | st_asgeojson(integer,
                    geography, integer) |  | 
        
            | st_asgeojson(integer,
                    geography, integer, integer) |  | 
        
            | st_asgeojson(integer, geometry) |  | 
        
            | st_asgeojson(integer,
                    geometry, integer) |  | 
        
            | st_asgeojson(integer,
                    geometry, integer, integer) |  | 
        
            | st_asgeojson(text) |  | 
        
            | st_asgml(geography) |  | 
        
            | st_asgml(geography, integer) |  | 
        
            | st_asgml(geography, integer,
                    integer) |  | 
        
            | st_asgml(geometry) |  | 
        
            | st_asgml(geometry, integer) |  | 
        
            | st_asgml(geometry, integer,
                    integer) |  | 
        
            | st_asgml(integer, geography) |  | 
        
            | st_asgml(integer, geography,
                    integer) |  | 
        
            | st_asgml(integer,
                    geography, integer, integer) |  | 
        
            | st_asgml(integer, geometry) |  | 
        
            | st_asgml(integer, geometry,
                    integer) |  | 
        
            | st_asgml(integer,
                    geometry, integer, integer) |  | 
        
            | st_asgml(text) |  | 
        
            | st_ashexewkb(geometry) |  | 
        
            | st_ashexewkb(geometry, text) |  | 
        
            | st_askml(geography) |  | 
        
            | st_askml(geography, integer) |  | 
        
            | st_askml(geometry) |  | 
        
            | st_askml(geometry, integer) |  | 
        
            | st_askml(integer, geography) |  | 
        
            | st_askml(integer, geography,
                    integer) |  | 
        
            | st_askml(integer, geometry) |  | 
        
            | st_askml(integer, geometry,
                    integer) |  | 
        
            | st_askml(text) |  | 
        
            | st_assvg(geography) |  | 
        
            | st_assvg(geography, integer) |  | 
        
            | st_assvg(geography, integer,
                    integer) |  | 
        
            | st_assvg(geometry) |  | 
        
            | st_assvg(geometry, integer) |  | 
        
            | st_assvg(geometry, integer,
                    integer) |  | 
        
            | st_assvg(text) |  | 
        
            | st_astext(geography) |  | 
        
            | st_astext(geometry) |  | 
        
            | st_astext(text) |  | 
        
            | st_azimuth(geometry, geometry) |  | 
        
            | st_bdmpolyfromtext(text,
                    integer) |  | 
        
            | st_bdpolyfromtext(text, integer) |  | 
        
            | st_boundary(geometry) |  | 
        
            | st_box(box3d) |  | 
        
            | st_box(geometry) |  | 
        
            | st_box2d(box3d) |  | 
        
            | st_box2d(box3d_extent) |  | 
        
            | st_box2d(geometry) |  | 
        
            | st_box2d_in(cstring) |  | 
        
            | st_box2d_out(box2d) |  | 
        
            | st_box3d(box2d) |  | 
        
            | st_box3d(geometry) |  | 
        
            | st_box3d_extent(box3d_extent) |  | 
        
            | st_box3d_in(cstring) |  | 
        
            | st_box3d_out(box3d) |  | 
        
            | st_buffer(geography, double
                    precision) |  | 
        
            | st_buffer(geometry, double
                    precision) |  | 
        
            | st_buffer(geometry,
                    double precision, integer) |  | 
        
            | st_buffer(geometry, double
                    precision, text) |  | 
        
            | st_buffer(text, double
                    precision) |  | 
        
            | st_buildarea(geometry) |  | 
        
            | st_bytea(geometry) |  | 
        
            | st_centroid(geometry) |  | 
        
            | st_chip_in(cstring) |  | 
        
            | st_chip_out(chip) |  | 
        
            | st_closestpoint(geometry,
                    geometry) |  | 
        
            | st_collect(geometry) |  | 
        
            | st_collect(geometry, geometry) |  | 
        
            | st_collect(geometry[]) |  | 
        
            | st_collectionextract(geometry,
                    integer) |  | 
        
            | st_combine_bbox(box2d, geometry) |  | 
        
            | st_combine_bbox(box3d, geometry) |  | 
        
            | st_combine_bbox(box3d_extent,
                    geometry) |  | 
        
            | st_compression(chip) |  | 
        
            | st_contains(geometry, geometry) |  | 
        
            | st_containsproperly(geometry,
                    geometry) |  | 
        
            | st_convexhull(geometry) |  | 
        
            | st_coorddim(geometry) |  | 
        
            | st_coveredby(geography,
                    geography) |  | 
        
            | st_coveredby(geometry, geometry) |  | 
        
            | st_coveredby(text, text) |  | 
        
            | st_covers(geography, geography) |  | 
        
            | st_covers(geometry, geometry) |  | 
        
            | st_covers(text, text) |  | 
        
            | st_crosses(geometry, geometry) |  | 
        
            | st_curvetoline(geometry) |  | 
        
            | st_curvetoline(geometry,
                    integer) |  | 
        
            | st_datatype(chip) |  | 
        
            | st_dfullywithin(geometry,
                    geometry, double precision) |  | 
        
            | st_difference(geometry,
                    geometry) |  | 
        
            | st_dimension(geometry) |  | 
        
            | st_disjoint(geometry, geometry) |  | 
        
            | st_distance(geography,
                    geography) |  | 
        
            | st_distance(geography,
                    geography, boolean) |  | 
        
            | st_distance(geometry, geometry) |  | 
        
            | st_distance(text, text) |  | 
        
            | st_distance_sphere(geometry,
                    geometry) |  | 
        
            | st_distance_spheroid(geometry,
                    geometry, spheroid) |  | 
        
            | st_dump(geometry) |  | 
        
            | st_dumppoints(geometry) |  | 
        
            | st_dumprings(geometry) |  | 
        
            | st_dwithin(geography,
                    geography, double precision) |  | 
        
            | st_dwithin(geography,
                    geography, double precision, boolean) |  | 
        
            | st_dwithin(geometry,
                    geometry, double precision) |  | 
        
            | st_dwithin(text, text, double
                    precision) |  | 
        
            | st_endpoint(geometry) |  | 
        
            | st_envelope(geometry) |  | 
        
            | st_equals(geometry, geometry) |  | 
        
            | st_estimated_extent(text, text) |  | 
        
            | st_estimated_extent(text, text,
                    text) |  | 
        
            | st_expand(box2d, double
                    precision) |  | 
        
            | st_expand(box3d, double
                    precision) |  | 
        
            | st_expand(geometry, double
                    precision) |  | 
        
            | st_extent(geometry) |  | 
        
            | st_extent3d(geometry) |  | 
        
            | st_exteriorring(geometry) |  | 
        
            | st_factor(chip) |  | 
        
            | st_find_extent(text, text) |  | 
        
            | st_find_extent(text, text, text) |  | 
        
            | st_force_2d(geometry) |  | 
        
            | st_force_3d(geometry) |  | 
        
            | st_force_3dm(geometry) |  | 
        
            | st_force_3dz(geometry) |  | 
        
            | st_force_4d(geometry) |  | 
        
            | st_force_collection(geometry) |  | 
        
            | st_forcerhr(geometry) |  | 
        
            | st_geogfromtext(text) |  | 
        
            | st_geogfromwkb(bytea) |  | 
        
            | st_geographyfromtext(text) |  | 
        
            | st_geohash(geometry) |  | 
        
            | st_geohash(geometry, integer) |  | 
        
            | st_geomcollfromtext(text) |  | 
        
            | st_geomcollfromtext(text,
                    integer) |  | 
        
            | st_geomcollfromwkb(bytea) |  | 
        
            | st_geomcollfromwkb(bytea,
                    integer) |  | 
        
            | st_geometry(box2d) |  | 
        
            | st_geometry(box3d) |  | 
        
            | st_geometry(box3d_extent) |  | 
        
            | st_geometry(bytea) |  | 
        
            | st_geometry(chip) |  | 
        
            | st_geometry(text) |  | 
        
            | st_geometry_above(geometry,
                    geometry) |  | 
        
            | st_geometry_analyze(internal) |  | 
        
            | st_geometry_below(geometry,
                    geometry) |  | 
        
            | st_geometry_cmp(geometry,
                    geometry) |  | 
        
            | st_geometry_contain(geometry,
                    geometry) |  | 
        
            | st_geometry_contained(geometry,
                    geometry) |  | 
        
            | st_geometry_eq(geometry,
                    geometry) |  | 
        
            | st_geometry_ge(geometry,
                    geometry) |  | 
        
            | st_geometry_gt(geometry,
                    geometry) |  | 
        
            | st_geometry_in(cstring) |  | 
        
            | st_geometry_le(geometry,
                    geometry) |  | 
        
            | st_geometry_left(geometry,
                    geometry) |  | 
        
            | st_geometry_lt(geometry,
                    geometry) |  | 
        
            | st_geometry_out(geometry) |  | 
        
            | st_geometry_overabove(geometry,
                    geometry) |  | 
        
            | st_geometry_overbelow(geometry,
                    geometry) |  | 
        
            | st_geometry_overlap(geometry,
                    geometry) |  | 
        
            | st_geometry_overleft(geometry,
                    geometry) |  | 
        
            | st_geometry_overright(geometry,
                    geometry) |  | 
        
            | st_geometry_recv(internal) |  | 
        
            | st_geometry_right(geometry,
                    geometry) |  | 
        
            | st_geometry_same(geometry,
                    geometry) |  | 
        
            | st_geometry_send(geometry) |  | 
        
            | st_geometryfromtext(text) |  | 
        
            | st_geometryfromtext(text,
                    integer) |  | 
        
            | st_geometryn(geometry, integer) |  | 
        
            | st_geometrytype(geometry) |  | 
        
            | st_geomfromewkb(bytea) |  | 
        
            | st_geomfromewkt(text) |  | 
        
            | st_geomfromgml(text) |  | 
        
            | st_geomfromkml(text) |  | 
        
            | st_geomfromtext(text) |  | 
        
            | st_geomfromtext(text, integer) |  | 
        
            | st_geomfromwkb(bytea) |  | 
        
            | st_geomfromwkb(bytea, integer) |  | 
        
            | st_gmltosql(text) |  | 
        
            | st_hasarc(geometry) |  | 
        
            | st_height(chip) |  | 
        
            | st_interiorringn(geometry,
                    integer) |  | 
        
            | st_intersection(geography,
                    geography) |  | 
        
            | st_intersection(geometry,
                    geometry) |  | 
        
            | st_intersection(text, text) |  | 
        
            | st_intersects(geography,
                    geography) |  | 
        
            | st_intersects(geometry,
                    geometry) |  | 
        
            | st_intersects(text, text) |  | 
        
            | st_isclosed(geometry) |  | 
        
            | st_isempty(geometry) |  | 
        
            | st_isring(geometry) |  | 
        
            | st_issimple(geometry) |  | 
        
            | st_isvalid(geometry) |  | 
        
            | st_isvalidreason(geometry) |  | 
        
            | st_length(geography) |  | 
        
            | st_length(geography, boolean) |  | 
        
            | st_length(geometry) |  | 
        
            | st_length(text) |  | 
        
            | st_length2d(geometry) |  | 
        
            | st_length2d_spheroid(geometry,
                    spheroid) |  | 
        
            | st_length3d(geometry) |  | 
        
            | st_length3d_spheroid(geometry,
                    spheroid) |  | 
        
            | st_length_spheroid(geometry,
                    spheroid) |  | 
        
            | st_line_interpolate_point(geometry,
                    double precision) |  | 
        
            | st_line_locate_point(geometry,
                    geometry) |  | 
        
            | st_line_substring(geometry,
                    double precision, double precision) |  | 
        
            | st_linecrossingdirection(geometry,
                    geometry) |  | 
        
            | st_linefrommultipoint(geometry) |  | 
        
            | st_linefromtext(text) |  | 
        
            | st_linefromtext(text, integer) |  | 
        
            | st_linefromwkb(bytea) |  | 
        
            | st_linefromwkb(bytea, integer) |  | 
        
            | st_linemerge(geometry) |  | 
        
            | st_linestringfromwkb(bytea) |  | 
        
            | st_linestringfromwkb(bytea,
                    integer) |  | 
        
            | st_linetocurve(geometry) |  | 
        
            | st_locate_along_measure(geometry,
                    double precision) |  | 
        
            | st_locate_between_measures(geometry,
                    double precision, double precision) |  | 
        
            | st_locatebetweenelevations(geometry,
                    double precision, double precision) |  | 
        
            | st_longestline(geometry,
                    geometry) |  | 
        
            | st_m(geometry) |  | 
        
            | st_makebox2d(geometry, geometry) |  | 
        
            | st_makebox3d(geometry, geometry) |  | 
        
            | st_makeenvelope(double
                    precision, double precision, double precision, double precision, integer) |  | 
        
            | st_makeline(geometry) |  | 
        
            | st_makeline(geometry, geometry) |  | 
        
            | st_makeline(geometry[]) |  | 
        
            | st_makeline_garray(geometry[]) |  | 
        
            | st_makepoint(double
                    precision, double precision) |  | 
        
            | st_makepoint(double
                    precision, double precision, double precision) |  | 
        
            | st_makepoint(double
                    precision, double precision, double precision, double precision) |  | 
        
            | st_makepointm(double
                    precision, double precision, double precision) |  | 
        
            | st_makepolygon(geometry) |  | 
        
            | st_makepolygon(geometry,
                    geometry[]) |  | 
        
            | st_maxdistance(geometry,
                    geometry) |  | 
        
            | st_mem_size(geometry) |  | 
        
            | st_memcollect(geometry) |  | 
        
            | st_memunion(geometry) |  | 
        
            | st_minimumboundingcircle(geometry) |  | 
        
            | st_minimumboundingcircle(inputgeom
                    geometry, segs_per_quarter integer) |  | 
        
            | st_mlinefromtext(text) |  | 
        
            | st_mlinefromtext(text, integer) |  | 
        
            | st_mlinefromwkb(bytea) |  | 
        
            | st_mlinefromwkb(bytea, integer) |  | 
        
            | st_mpointfromtext(text) |  | 
        
            | st_mpointfromtext(text, integer) |  | 
        
            | st_mpointfromwkb(bytea) |  | 
        
            | st_mpointfromwkb(bytea, integer) |  | 
        
            | st_mpolyfromtext(text) |  | 
        
            | st_mpolyfromtext(text, integer) |  | 
        
            | st_mpolyfromwkb(bytea) |  | 
        
            | st_mpolyfromwkb(bytea, integer) |  | 
        
            | st_multi(geometry) |  | 
        
            | st_multilinefromwkb(bytea) |  | 
        
            | st_multilinestringfromtext(text) |  | 
        
            | st_multilinestringfromtext(text,
                    integer) |  | 
        
            | st_multipointfromtext(text) |  | 
        
            | st_multipointfromwkb(bytea) |  | 
        
            | st_multipointfromwkb(bytea,
                    integer) |  | 
        
            | st_multipolyfromwkb(bytea) |  | 
        
            | st_multipolyfromwkb(bytea,
                    integer) |  | 
        
            | st_multipolygonfromtext(text) |  | 
        
            | st_multipolygonfromtext(text,
                    integer) |  | 
        
            | st_ndims(geometry) |  | 
        
            | st_npoints(geometry) |  | 
        
            | st_nrings(geometry) |  | 
        
            | st_numgeometries(geometry) |  | 
        
            | st_numinteriorring(geometry) |  | 
        
            | st_numinteriorrings(geometry) |  | 
        
            | st_numpoints(geometry) |  | 
        
            | st_orderingequals(geometry,
                    geometry) |  | 
        
            | st_overlaps(geometry, geometry) |  | 
        
            | st_perimeter(geometry) |  | 
        
            | st_perimeter2d(geometry) |  | 
        
            | st_perimeter3d(geometry) |  | 
        
            | st_point(double
                    precision, double precision) |  | 
        
            | st_point_inside_circle(geometry,
                    double precision, double precision, double precision) |  | 
        
            | st_pointfromtext(text) |  | 
        
            | st_pointfromtext(text, integer) |  | 
        
            | st_pointfromwkb(bytea) |  | 
        
            | st_pointfromwkb(bytea, integer) |  | 
        
            | st_pointn(geometry, integer) |  | 
        
            | st_pointonsurface(geometry) |  | 
        
            | st_polyfromtext(text) |  | 
        
            | st_polyfromtext(text, integer) |  | 
        
            | st_polyfromwkb(bytea) |  | 
        
            | st_polyfromwkb(bytea, integer) |  | 
        
            | st_polygon(geometry, integer) |  | 
        
            | st_polygonfromtext(text) |  | 
        
            | st_polygonfromtext(text,
                    integer) |  | 
        
            | st_polygonfromwkb(bytea) |  | 
        
            | st_polygonfromwkb(bytea,
                    integer) |  | 
        
            | st_polygonize(geometry) |  | 
        
            | st_polygonize(geometry[]) |  | 
        
            | st_polygonize_garray(geometry[]) |  | 
        
            | st_postgis_gist_joinsel(internal,
                    oid, internal, smallint) |  | 
        
            | st_postgis_gist_sel(internal,
                    oid, internal, integer) |  | 
        
            | st_relate(geometry, geometry) |  | 
        
            | st_relate(geometry, geometry,
                    text) |  | 
        
            | st_removepoint(geometry,
                    integer) |  | 
        
            | st_reverse(geometry) |  | 
        
            | st_rotate(geometry, double
                    precision) |  | 
        
            | st_rotatex(geometry, double
                    precision) |  | 
        
            | st_rotatey(geometry, double
                    precision) |  | 
        
            | st_rotatez(geometry, double
                    precision) |  | 
        
            | st_scale(geometry,
                    double precision, double precision) |  | 
        
            | st_scale(geometry,
                    double precision, double precision, double precision) |  | 
        
            | st_segmentize(geometry,
                    double precision) |  | 
        
            | st_setfactor(chip, real) |  | 
        
            | st_setpoint(geometry,
                    integer, geometry) |  | 
        
            | st_setsrid(geometry, integer) |  | 
        
            | st_shift_longitude(geometry) |  | 
        
            | st_shortestline(geometry,
                    geometry) |  | 
        
            | st_simplify(geometry, double
                    precision) |  | 
        
            | st_simplifypreservetopology(geometry,
                    double precision) |  | 
        
            | st_snaptogrid(geometry,
                    double precision) |  | 
        
            | st_snaptogrid(geometry,
                    double precision, double precision) |  | 
        
            | st_snaptogrid(geometry,
                    double precision, double precision, double precision, double precision) |  | 
        
            | st_snaptogrid(geometry,
                    geometry, double precision, double precision, double precision, double precision) |  | 
        
            | st_spheroid_in(cstring) |  | 
        
            | st_spheroid_out(spheroid) |  | 
        
            | st_srid(chip) |  | 
        
            | st_srid(geometry) |  | 
        
            | st_startpoint(geometry) |  | 
        
            | st_summary(geometry) |  | 
        
            | st_symdifference(geometry,
                    geometry) |  | 
        
            | st_symmetricdifference(geometry,
                    geometry) |  | 
        
            | st_text(geometry) |  | 
        
            | st_touches(geometry, geometry) |  | 
        
            | st_transform(geometry, integer) |  | 
        
            | st_translate(geometry,
                    double precision, double precision) |  | 
        
            | st_translate(geometry,
                    double precision, double precision, double precision) |  | 
        
            | st_transscale(geometry,
                    double precision, double precision, double precision, double precision) |  | 
        
            | st_union(geometry) |  | 
        
            | st_union(geometry, geometry) |  | 
        
            | st_union(geometry[]) |  | 
        
            | st_unite_garray(geometry[]) |  | 
        
            | st_width(chip) |  | 
        
            | st_within(geometry, geometry) |  | 
        
            | st_wkbtosql(bytea) |  | 
        
            | st_wkttosql(text) |  | 
        
            | st_x(geometry) |  | 
        
            | st_xmax(box3d) |  | 
        
            | st_xmin(box3d) |  | 
        
            | st_y(geometry) |  | 
        
            | st_ymax(box3d) |  | 
        
            | st_ymin(box3d) |  | 
        
            | st_z(geometry) |  | 
        
            | st_zmax(box3d) |  | 
        
            | st_zmflag(geometry) |  | 
        
            | st_zmin(box3d) |  | 
        
            | startpoint(geometry) |  | 
        
            | summary(geometry) |  | 
        
            | symdifference(geometry,
                    geometry) |  | 
        
            | symmetricdifference(geometry,
                    geometry) |  | 
        
            | text(geometry) |  | 
        
            | touches(geometry, geometry) |  | 
        
            | transform(geometry, integer) |  | 
        
            | translate(geometry,
                    double precision, double precision) |  | 
        
            | translate(geometry,
                    double precision, double precision, double precision) |  | 
        
            | transscale(geometry,
                    double precision, double precision, double precision, double precision) |  | 
        
            | unite_garray(geometry[]) |  | 
        
            | unlockrows(text) |  | 
        
            | update_current_archive() |  | 
        
            | updategeometrysrid(character
                    varying, character varying, character varying, character varying, integer) |  | 
        
            | updategeometrysrid(character
                    varying, character varying, character varying, integer) |  | 
        
            | updategeometrysrid(character
                    varying, character varying, integer) |  | 
        
            | width(chip) |  | 
        
            | within(geometry, geometry) |  | 
        
            | x(geometry) |  | 
        
            | xmax(box3d) |  | 
        
            | xmin(box3d) |  | 
        
            | y(geometry) |  | 
        
            | ymax(box3d) |  | 
        
            | ymin(box3d) |  | 
        
            | z(geometry) |  | 
        
            | zmax(box3d) |  | 
        
            | zmflag(geometry) |  | 
        
            | zmin(box3d) |  |