diff --git a/server/extension/Makefile b/server/extension/Makefile index 40e6163..487a79c 100644 --- a/server/extension/Makefile +++ b/server/extension/Makefile @@ -13,11 +13,11 @@ OLD_VERSIONS = $(wildcard old_versions/*.sql) # @see http://www.postgresql.org/docs/current/static/extend-pgxs.html DATA = $(NEW_EXTENSION_ARTIFACT) \ $(OLD_VERSIONS) \ - cdb_dataservices_server--0.5.1--0.5.0.sql \ - cdb_dataservices_server--0.5.0--0.5.1.sql + cdb_dataservices_server--0.5.2--0.5.1.sql \ + cdb_dataservices_server--0.5.1--0.5.2.sql -REGRESS = $(notdir $(basename $(wildcard test/$(EXTVERSION)/sql/*test.sql))) -TEST_DIR = test/$(EXTVERSION) +REGRESS = $(notdir $(basename $(wildcard test/sql/*test.sql))) +TEST_DIR = test/ REGRESS_OPTS = --inputdir='$(TEST_DIR)' --outputdir='$(TEST_DIR)' # postgres build stuff @@ -25,9 +25,9 @@ PG_CONFIG = pg_config PGXS := $(shell $(PG_CONFIG) --pgxs) include $(PGXS) -SOURCES_DATA_DIR = sql/$(EXTVERSION) +SOURCES_DATA_DIR = sql/ -SOURCES_DATA = $(wildcard sql/$(EXTVERSION)/*.sql) +SOURCES_DATA = $(wildcard sql/*.sql) $(NEW_EXTENSION_ARTIFACT): $(SOURCES_DATA) rm -f $@ diff --git a/server/extension/cdb_dataservices_server--0.5.1--0.5.2.sql b/server/extension/cdb_dataservices_server--0.5.1--0.5.2.sql new file mode 100644 index 0000000..07f413e --- /dev/null +++ b/server/extension/cdb_dataservices_server--0.5.1--0.5.2.sql @@ -0,0 +1,61 @@ +--DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES +-- Complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "ALTER EXTENSION cdb_dataservices_server UPDATE TO '0.5.2'" to load this file. \quit +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_mapzen_route_point_to_point( + username TEXT, + orgname TEXT, + origin geometry(Point, 4326), + destination geometry(Point, 4326), + mode TEXT, + options text[] DEFAULT ARRAY[]::text[], + units text DEFAULT 'kilometers') +RETURNS cdb_dataservices_server.simple_route AS $$ + import json + from cartodb_services.mapzen import MapzenRouting, MapzenRoutingResponse + from cartodb_services.mapzen.types import polyline_to_linestring + from cartodb_services.metrics import QuotaService + from cartodb_services.tools import Coordinate + + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + user_routing_config = GD["user_routing_config_{0}".format(username)] + + quota_service = QuotaService(user_routing_config, redis_conn) + + try: + client = MapzenRouting(user_routing_config.mapzen_app_key) + + if not origin or not destination: + plpy.notice("Empty origin or destination") + quota_service.increment_empty_service_use() + return [None, None, None] + + orig_lat = plpy.execute("SELECT ST_Y('%s') AS lat" % origin)[0]['lat'] + orig_lon = plpy.execute("SELECT ST_X('%s') AS lon" % origin)[0]['lon'] + origin_coordinates = Coordinate(orig_lon, orig_lat) + dest_lat = plpy.execute("SELECT ST_Y('%s') AS lat" % destination)[0]['lat'] + dest_lon = plpy.execute("SELECT ST_X('%s') AS lon" % destination)[0]['lon'] + dest_coordinates = Coordinate(dest_lon, dest_lat) + + resp = client.calculate_route_point_to_point(origin_coordinates, dest_coordinates, mode, options, units) + + if resp and resp.shape: + shape_linestring = polyline_to_linestring(resp.shape) + if shape_linestring: + quota_service.increment_success_service_use() + return [shape_linestring, resp.length, resp.duration] + else: + quota_service.increment_empty_service_use() + return [None, None, None] + else: + quota_service.increment_empty_service_use() + return [None, None, None] + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to obtain route using mapzen provider: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.5.1/100_routing_helper.sql b/server/extension/cdb_dataservices_server--0.5.2--0.5.1.sql similarity index 87% rename from server/extension/sql/0.5.1/100_routing_helper.sql rename to server/extension/cdb_dataservices_server--0.5.2--0.5.1.sql index 26a8880..1a93f61 100644 --- a/server/extension/sql/0.5.1/100_routing_helper.sql +++ b/server/extension/cdb_dataservices_server--0.5.2--0.5.1.sql @@ -1,10 +1,6 @@ -CREATE TYPE cdb_dataservices_server.simple_route AS ( - shape geometry(LineString,4326), - length real, - duration integer -); - - +--DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES +-- Complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "ALTER EXTENSION cdb_dataservices_server UPDATE TO '0.5.1'" to load this file. \quit CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_mapzen_route_point_to_point( username TEXT, orgname TEXT, @@ -52,4 +48,4 @@ RETURNS cdb_dataservices_server.simple_route AS $$ plpy.error(error_msg) finally: quota_service.increment_total_service_use() -$$ LANGUAGE plpythonu SECURITY DEFINER; +$$ LANGUAGE plpythonu SECURITY DEFINER; \ No newline at end of file diff --git a/server/extension/cdb_dataservices_server--0.5.2.sql b/server/extension/cdb_dataservices_server--0.5.2.sql new file mode 100644 index 0000000..d2906fb --- /dev/null +++ b/server/extension/cdb_dataservices_server--0.5.2.sql @@ -0,0 +1,980 @@ +--DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES +-- Complain if script is sourced in psql, rather than via CREATE EXTENSION +\echo Use "CREATE EXTENSION cdb_dataservices_server" to load this file. \quit +CREATE TYPE cdb_dataservices_server.simple_route AS ( + shape geometry(LineString,4326), + length real, + duration integer +); + + +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_mapzen_route_point_to_point( + username TEXT, + orgname TEXT, + origin geometry(Point, 4326), + destination geometry(Point, 4326), + mode TEXT, + options text[] DEFAULT ARRAY[]::text[], + units text DEFAULT 'kilometers') +RETURNS cdb_dataservices_server.simple_route AS $$ + import json + from cartodb_services.mapzen import MapzenRouting, MapzenRoutingResponse + from cartodb_services.mapzen.types import polyline_to_linestring + from cartodb_services.metrics import QuotaService + from cartodb_services.tools import Coordinate + + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + user_routing_config = GD["user_routing_config_{0}".format(username)] + + quota_service = QuotaService(user_routing_config, redis_conn) + + try: + client = MapzenRouting(user_routing_config.mapzen_app_key) + + if not origin or not destination: + plpy.notice("Empty origin or destination") + quota_service.increment_empty_service_use() + return [None, None, None] + + orig_lat = plpy.execute("SELECT ST_Y('%s') AS lat" % origin)[0]['lat'] + orig_lon = plpy.execute("SELECT ST_X('%s') AS lon" % origin)[0]['lon'] + origin_coordinates = Coordinate(orig_lon, orig_lat) + dest_lat = plpy.execute("SELECT ST_Y('%s') AS lat" % destination)[0]['lat'] + dest_lon = plpy.execute("SELECT ST_X('%s') AS lon" % destination)[0]['lon'] + dest_coordinates = Coordinate(dest_lon, dest_lat) + + resp = client.calculate_route_point_to_point(origin_coordinates, dest_coordinates, mode, options, units) + + if resp and resp.shape: + shape_linestring = polyline_to_linestring(resp.shape) + if shape_linestring: + quota_service.increment_success_service_use() + return [shape_linestring, resp.length, resp.duration] + else: + quota_service.increment_empty_service_use() + return [None, None, None] + else: + quota_service.increment_empty_service_use() + return [None, None, None] + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to obtain route using mapzen provider: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu SECURITY DEFINER; +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_route_point_to_point( + username TEXT, + orgname TEXT, + origin geometry(Point, 4326), + destination geometry(Point, 4326), + mode TEXT, + options text[] DEFAULT ARRAY[]::text[], + units text DEFAULT 'kilometers') +RETURNS cdb_dataservices_server.simple_route AS $$ + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_routing_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_routing_config = GD["user_routing_config_{0}".format(username)] + + mapzen_plan = plpy.prepare("SELECT * FROM cdb_dataservices_server._cdb_mapzen_route_point_to_point($1, $2, $3, $4, $5, $6, $7) as route;", ["text", "text", "geometry(Point, 4326)", "geometry(Point, 4326)", "text", "text[]", "text"]) + result = plpy.execute(mapzen_plan, [username, orgname, origin, destination, mode, options, units]) + return [result[0]['shape'],result[0]['length'], result[0]['duration']] +$$ LANGUAGE plpythonu; +-- Get the connection to redis from cache or create a new one +CREATE OR REPLACE FUNCTION cdb_dataservices_server._connect_to_redis(user_id text) +RETURNS boolean AS $$ + cache_key = "redis_connection_{0}".format(user_id) + if cache_key in GD: + return False + else: + from cartodb_services.tools import RedisConnection, RedisDBConfig + metadata_config = RedisDBConfig('redis_metadata_config', plpy) + metrics_config = RedisDBConfig('redis_metrics_config', plpy) + redis_metadata_connection = RedisConnection(metadata_config).redis_connection() + redis_metrics_connection = RedisConnection(metrics_config).redis_connection() + GD[cache_key] = { + 'redis_metadata_connection': redis_metadata_connection, + 'redis_metrics_connection': redis_metrics_connection, + } + return True +$$ LANGUAGE plpythonu SECURITY DEFINER; +-- Get the Redis configuration from the _conf table -- +CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_geocoder_config(username text, orgname text) +RETURNS boolean AS $$ + cache_key = "user_geocoder_config_{0}".format(username) + if cache_key in GD: + return False + else: + from cartodb_services.metrics import GeocoderConfig + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] + geocoder_config = GeocoderConfig(redis_conn, plpy, username, orgname) + GD[cache_key] = geocoder_config + return True +$$ LANGUAGE plpythonu SECURITY DEFINER; + +-- Get the Redis configuration from the _conf table -- +CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_internal_geocoder_config(username text, orgname text) +RETURNS boolean AS $$ + cache_key = "user_internal_geocoder_config_{0}".format(username) + if cache_key in GD: + return False + else: + from cartodb_services.metrics import InternalGeocoderConfig + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] + geocoder_config = InternalGeocoderConfig(redis_conn, plpy, username, orgname) + GD[cache_key] = geocoder_config + return True +$$ LANGUAGE plpythonu SECURITY DEFINER; + +-- Get the Redis configuration from the _conf table -- +CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_isolines_routing_config(username text, orgname text) +RETURNS boolean AS $$ + cache_key = "user_isolines_routing_config_{0}".format(username) + if cache_key in GD: + return False + else: + from cartodb_services.metrics import IsolinesRoutingConfig + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] + isolines_routing_config = IsolinesRoutingConfig(redis_conn, plpy, username, orgname) + GD[cache_key] = isolines_routing_config + return True +$$ LANGUAGE plpythonu SECURITY DEFINER; + +-- Get the Redis configuration from the _conf table -- +CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_routing_config(username text, orgname text) +RETURNS boolean AS $$ + cache_key = "user_routing_config_{0}".format(username) + if cache_key in GD: + return False + else: + from cartodb_services.metrics import RoutingConfig + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] + routing_config = RoutingConfig(redis_conn, plpy, username, orgname) + GD[cache_key] = routing_config + return True +$$ LANGUAGE plpythonu SECURITY DEFINER; +-- Geocodes a street address given a searchtext and a state and/or country +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) +RETURNS Geometry AS $$ + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] + + if user_geocoder_config.heremaps_geocoder: + here_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_here_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) + return plpy.execute(here_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] + elif user_geocoder_config.google_geocoder: + google_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_google_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) + return plpy.execute(google_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] + else: + plpy.error('Requested geocoder is not available') + +$$ LANGUAGE plpythonu; + +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_here_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) +RETURNS Geometry AS $$ + from cartodb_services.here import HereMapsGeocoder + from cartodb_services.metrics import QuotaService + + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] + + # -- Check the quota + quota_service = QuotaService(user_geocoder_config, redis_conn) + if not quota_service.check_user_quota(): + plpy.error('You have reach the limit of your quota') + + try: + geocoder = HereMapsGeocoder(user_geocoder_config.heremaps_app_id, user_geocoder_config.heremaps_app_code) + coordinates = geocoder.geocode(searchtext=searchtext, city=city, state=state_province, country=country) + if coordinates: + quota_service.increment_success_service_use() + plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) + point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] + return point['st_setsrid'] + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using here maps geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_google_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) +RETURNS Geometry AS $$ + from cartodb_services.google import GoogleMapsGeocoder + from cartodb_services.metrics import QuotaService + + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] + quota_service = QuotaService(user_geocoder_config, redis_conn) + + try: + geocoder = GoogleMapsGeocoder(user_geocoder_config.google_client_id, user_geocoder_config.google_api_key) + coordinates = geocoder.geocode(searchtext=searchtext, city=city, state=state_province, country=country) + if coordinates: + quota_service.increment_success_service_use() + plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) + point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] + return point['st_setsrid'] + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using google maps geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin0_polygon(username text, orgname text, country_name text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin0_polygon(trim($1)) AS mypolygon", ["text"]) + rv = plpy.execute(plan, [country_name], 1) + result = rv[0]["mypolygon"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + + +-------------------------------------------------------------------------------- + +-- Implementation of the server extension +-- Note: these functions depend on the cdb_geocoder extension +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin0_polygon(country_name text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + SELECT n.the_geom as geom INTO ret + FROM (SELECT q, lower(regexp_replace(q, '[^a-zA-Z\u00C0-\u00ff]+', '', 'g'))::text x + FROM (SELECT country_name q) g) d + LEFT OUTER JOIN admin0_synonyms s ON name_ = d.x + LEFT OUTER JOIN ne_admin0_v3 n ON s.adm0_a3 = n.adm0_a3 GROUP BY d.q, n.the_geom, s.adm0_a3; + + RETURN ret; + END +$$ LANGUAGE plpgsql; +---- cdb_geocode_admin1_polygon(admin1_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon(trim($1)) AS mypolygon", ["text"]) + rv = plpy.execute(plan, [admin1_name], 1) + result = rv[0]["mypolygon"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +---- cdb_geocode_admin1_polygon(admin1_name text, country_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text, country_name text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon(trim($1), trim($2)) AS mypolygon", ["text", "text"]) + rv = plpy.execute(plan, [admin1_name, country_name], 1) + result = rv[0]["mypolygon"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +-------------------------------------------------------------------------------- + +-- Implementation of the server extension +-- Note: these functions depend on the cdb_geocoder extension + +---- cdb_geocode_admin1_polygon(admin1_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + SELECT geom INTO ret + FROM ( + SELECT q, ( + SELECT the_geom + FROM global_province_polygons + WHERE d.c = ANY (synonyms) + ORDER BY frequency DESC LIMIT 1 + ) geom + FROM ( + SELECT + trim(replace(lower(admin1_name),'.',' ')) c, admin1_name q + ) d + ) v; + + RETURN ret; + END +$$ LANGUAGE plpgsql; + +---- cdb_geocode_admin1_polygon(admin1_name text, country_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text, country_name text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + WITH p AS (SELECT r.c, r.q, (SELECT iso3 FROM country_decoder WHERE lower(country_name) = ANY (synonyms)) i FROM (SELECT trim(replace(lower(admin1_name),'.',' ')) c, country_name q) r) + SELECT + geom INTO ret + FROM ( + SELECT + q, ( + SELECT the_geom + FROM global_province_polygons + WHERE p.c = ANY (synonyms) + AND iso3 = p.i + ORDER BY frequency DESC LIMIT 1 + ) geom + FROM p) n; + + RETURN ret; + END +$$ LANGUAGE plpgsql; + +---- cdb_geocode_namedplace_point(city_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point(trim($1)) AS mypoint", ["text"]) + rv = plpy.execute(plan, [city_name], 1) + result = rv[0]["mypoint"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +---- cdb_geocode_namedplace_point(city_name text, country_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, country_name text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point(trim($1), trim($2)) AS mypoint", ["text", "text"]) + rv = plpy.execute(plan, [city_name, country_name], 1) + result = rv[0]["mypoint"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +---- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, admin1_name text, country_name text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point(trim($1), trim($2), trim($3)) AS mypoint", ["text", "text", "text"]) + rv = plpy.execute(plan, [city_name, admin1_name, country_name], 1) + result = rv[0]["mypoint"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +-------------------------------------------------------------------------------- + +-- Implementation of the server extension +-- Note: these functions depend on the cdb_geocoder extension + +---- cdb_geocode_namedplace_point(city_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + SELECT geom INTO ret + FROM ( + WITH best AS (SELECT s AS q, (SELECT the_geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) ORDER BY population DESC LIMIT 1) AS geom FROM (SELECT city_name as s) p), + next AS (SELECT p.s AS q, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM (SELECT city_name as s) p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) + SELECT q, geom, TRUE AS success FROM best WHERE geom IS NOT NULL + UNION ALL + SELECT q, geom, CASE WHEN geom IS NULL THEN FALSE ELSE TRUE END AS success FROM next + ) v; + + RETURN ret; + END +$$ LANGUAGE plpgsql; + +---- cdb_geocode_namedplace_point(city_name text, country_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, country_name text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + SELECT geom INTO ret + FROM ( + WITH p AS (SELECT r.s, r.c, (SELECT iso2 FROM country_decoder WHERE lower(r.c) = ANY (synonyms)) i FROM (SELECT city_name AS s, country_name::text AS c) r), + best AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.iso2 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), + next AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND gp.iso2 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE c = p.c AND geom IS NOT NULL)) + SELECT geom FROM best WHERE geom IS NOT NULL + UNION ALL + SELECT geom FROM next + ) v; + + RETURN ret; + END +$$ LANGUAGE plpgsql; + +---- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + SELECT geom INTO ret + FROM ( + WITH inputcountry AS ( + SELECT iso2 as isoTwo FROM country_decoder WHERE lower(country_name) = ANY (synonyms) LIMIT 1 + ), + p AS ( + SELECT r.s, r.a1, (SELECT admin1 FROM admin1_decoder, inputcountry WHERE lower(r.a1) = ANY (synonyms) AND admin1_decoder.iso2 = inputcountry.isoTwo LIMIT 1) i FROM (SELECT city_name AS s, admin1_name::text AS a1) r), + best AS (SELECT p.s AS q, p.a1 as a1, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.admin1 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), + next AS (SELECT p.s AS q, p.a1 AS a1, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.admin1 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) + SELECT geom FROM best WHERE geom IS NOT NULL + UNION ALL + SELECT geom FROM next + ) v; + + RETURN ret; + END +$$ LANGUAGE plpgsql; + +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point(trim($1)) AS mypoint", ["text"]) + rv = plpy.execute(plan, [code], 1) + result = rv[0]["mypoint"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text, country text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point(trim($1), trim($2)) AS mypoint", ["TEXT", "TEXT"]) + rv = plpy.execute(plan, [code, country], 1) + result = rv[0]["mypoint"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon(trim($1)) AS mypolygon", ["text"]) + rv = plpy.execute(plan, [code], 1) + result = rv[0]["mypolygon"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text, country text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon(trim($1), trim($2)) AS mypolygon", ["TEXT", "TEXT"]) + rv = plpy.execute(plan, [code, country], 1) + result = rv[0]["mypolygon"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +-------------------------------------------------------------------------------- + +-- Implementation of the server extension +-- Note: these functions depend on the cdb_geocoder extension +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + SELECT geom INTO ret + FROM ( + SELECT + q, ( + SELECT the_geom + FROM global_postal_code_points + WHERE postal_code = upper(d.q) + LIMIT 1 + ) geom + FROM (SELECT code q) d + ) v; + + RETURN ret; +END +$$ LANGUAGE plpgsql; + +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text, country text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + SELECT geom INTO ret + FROM ( + SELECT + q, ( + SELECT the_geom + FROM global_postal_code_points + WHERE postal_code = upper(d.q) + AND iso3 = ( + SELECT iso3 FROM country_decoder WHERE + lower(country) = ANY (synonyms) LIMIT 1 + ) + LIMIT 1 + ) geom + FROM (SELECT code q) d + ) v; + + RETURN ret; +END +$$ LANGUAGE plpgsql; + +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + SELECT geom INTO ret + FROM ( + SELECT + q, ( + SELECT the_geom + FROM global_postal_code_polygons + WHERE postal_code = upper(d.q) + LIMIT 1 + ) geom + FROM (SELECT code q) d + ) v; + + RETURN ret; +END +$$ LANGUAGE plpgsql; + +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text, country text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + BEGIN + SELECT geom INTO ret + FROM ( + SELECT + q, ( + SELECT the_geom + FROM global_postal_code_polygons + WHERE postal_code = upper(d.q) + AND iso3 = ( + SELECT iso3 FROM country_decoder WHERE + lower(country) = ANY (synonyms) LIMIT 1 + ) + LIMIT 1 + ) geom + FROM (SELECT code q) d + ) v; + + RETURN ret; +END +$$ LANGUAGE plpgsql; +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_ipaddress_point(username text, orgname text, ip text) +RETURNS Geometry AS $$ + from cartodb_services.metrics import QuotaService + from cartodb_services.metrics import InternalGeocoderConfig + + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_internal_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_geocoder_config = GD["user_internal_geocoder_config_{0}".format(username)] + + quota_service = QuotaService(user_geocoder_config, redis_conn) + try: + plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_ipaddress_point(trim($1)) AS mypoint", ["TEXT"]) + rv = plpy.execute(plan, [ip], 1) + result = rv[0]["mypoint"] + if result: + quota_service.increment_success_service_use() + return result + else: + quota_service.increment_empty_service_use() + return None + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu; + +-------------------------------------------------------------------------------- + +-- Implementation of the server extension +-- Note: these functions depend on the cdb_geocoder extension +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_ipaddress_point(ip text) +RETURNS Geometry AS $$ + DECLARE + ret Geometry; + + new_ip INET; + BEGIN + BEGIN + IF family(ip::inet) = 6 THEN + new_ip := ip::inet; + ELSE + new_ip := ('::ffff:' || ip)::inet; + END IF; + EXCEPTION WHEN OTHERS THEN + SELECT NULL as geom INTO ret; + RETURN ret; + END; + + WITH + ips AS (SELECT ip s, new_ip net), + matches AS (SELECT s, (SELECT the_geom FROM ip_address_locations WHERE network_start_ip <= ips.net ORDER BY network_start_ip DESC LIMIT 1) geom FROM ips) + SELECT geom INTO ret + FROM matches; + RETURN ret; +END +$$ LANGUAGE plpgsql; +CREATE TYPE cdb_dataservices_server.isoline AS (center geometry(Geometry,4326), data_range integer, the_geom geometry(Multipolygon,4326)); + +CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_here_routing_isolines(username TEXT, orgname TEXT, type TEXT, source geometry(Geometry, 4326), mode TEXT, data_range integer[], options text[]) +RETURNS SETOF cdb_dataservices_server.isoline AS $$ + import json + from cartodb_services.here import HereMapsRoutingIsoline + from cartodb_services.metrics import QuotaService + from cartodb_services.here.types import geo_polyline_to_multipolygon + + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + user_isolines_routing_config = GD["user_isolines_routing_config_{0}".format(username)] + + # -- Check the quota + quota_service = QuotaService(user_isolines_routing_config, redis_conn) + if not quota_service.check_user_quota(): + plpy.error('You have reach the limit of your quota') + + try: + client = HereMapsRoutingIsoline(user_isolines_routing_config.heremaps_app_id, user_isolines_routing_config.heremaps_app_code, base_url = HereMapsRoutingIsoline.PRODUCTION_ROUTING_BASE_URL) + + if source: + lat = plpy.execute("SELECT ST_Y('%s') AS lat" % source)[0]['lat'] + lon = plpy.execute("SELECT ST_X('%s') AS lon" % source)[0]['lon'] + source_str = 'geo!%f,%f' % (lat, lon) + else: + source_str = None + + if type == 'isodistance': + resp = client.calculate_isodistance(source_str, mode, data_range, options) + elif type == 'isochrone': + resp = client.calculate_isochrone(source_str, mode, data_range, options) + + if resp: + result = [] + for isoline in resp: + data_range_n = isoline['range'] + polyline = isoline['geom'] + multipolygon = geo_polyline_to_multipolygon(polyline) + result.append([source, data_range_n, multipolygon]) + quota_service.increment_success_service_use() + quota_service.increment_isolines_service_use(len(resp)) + return result + else: + quota_service.increment_empty_service_use() + except BaseException as e: + import sys, traceback + type_, value_, traceback_ = sys.exc_info() + quota_service.increment_failed_service_use() + error_msg = 'There was an error trying to obtain isodistances using here maps geocoder: {0}'.format(e) + plpy.notice(traceback.format_tb(traceback_)) + plpy.error(error_msg) + finally: + quota_service.increment_total_service_use() +$$ LANGUAGE plpythonu SECURITY DEFINER; +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_isodistance(username TEXT, orgname TEXT, source geometry(Geometry, 4326), mode TEXT, range integer[], options text[] DEFAULT array[]::text[]) +RETURNS SETOF cdb_dataservices_server.isoline AS $$ + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_isolines_routing_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_isolines_config = GD["user_isolines_routing_config_{0}".format(username)] + type = 'isodistance' + + if user_isolines_config.google_services_user: + plpy.error('This service is not available for google service users.') + + here_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_here_routing_isolines($1, $2, $3, $4, $5, $6, $7) as isoline; ", ["text", "text", "text", "geometry(Geometry, 4326)", "text", "integer[]", "text[]"]) + result = plpy.execute(here_plan, [username, orgname, type, source, mode, range, options]) + isolines = [] + for element in result: + isoline = element['isoline'] + isoline = isoline.translate(None, "()").split(',') + isolines.append(isoline) + + return isolines +$$ LANGUAGE plpythonu; +CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_isochrone(username TEXT, orgname TEXT, source geometry(Geometry, 4326), mode TEXT, range integer[], options text[] DEFAULT array[]::text[]) +RETURNS SETOF cdb_dataservices_server.isoline AS $$ + plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) + redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] + plpy.execute("SELECT cdb_dataservices_server._get_isolines_routing_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) + user_isolines_config = GD["user_isolines_routing_config_{0}".format(username)] + type = 'isochrone' + + if user_isolines_config.google_services_user: + plpy.error('This service is not available for google service users.') + + here_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_here_routing_isolines($1, $2, $3, $4, $5, $6, $7) as isoline; ", ["text", "text", "text", "geometry(Geometry, 4326)", "text", "integer[]", "text[]"]) + result = plpy.execute(here_plan, [username, orgname, type, source, mode, range, options]) + isolines = [] + for element in result: + isoline = element['isoline'] + isoline = isoline.translate(None, "()").split(',') + isolines.append(isoline) + + return isolines +$$ LANGUAGE plpythonu; +DO $$ +BEGIN + IF NOT EXISTS ( + SELECT * + FROM pg_catalog.pg_user + WHERE usename = 'geocoder_api') THEN + + CREATE USER geocoder_api; + END IF; + GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server TO geocoder_api; + GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO geocoder_api; + GRANT USAGE ON SCHEMA cdb_dataservices_server TO geocoder_api; + GRANT USAGE ON SCHEMA public TO geocoder_api; + GRANT SELECT ON ALL TABLES IN SCHEMA public TO geocoder_api; +END$$; diff --git a/server/extension/cdb_dataservices_server.control b/server/extension/cdb_dataservices_server.control index bbae55f..f225b8c 100644 --- a/server/extension/cdb_dataservices_server.control +++ b/server/extension/cdb_dataservices_server.control @@ -1,5 +1,5 @@ comment = 'CartoDB dataservices server extension' -default_version = '0.5.1' +default_version = '0.5.2' requires = 'plpythonu, postgis, cdb_geocoder' superuser = true schema = cdb_dataservices_server diff --git a/server/extension/cdb_dataservices_server--0.5.0--0.5.1.sql b/server/extension/old_versions/cdb_dataservices_server--0.5.0--0.5.1.sql similarity index 100% rename from server/extension/cdb_dataservices_server--0.5.0--0.5.1.sql rename to server/extension/old_versions/cdb_dataservices_server--0.5.0--0.5.1.sql diff --git a/server/extension/cdb_dataservices_server--0.5.1--0.5.0.sql b/server/extension/old_versions/cdb_dataservices_server--0.5.1--0.5.0.sql similarity index 100% rename from server/extension/cdb_dataservices_server--0.5.1--0.5.0.sql rename to server/extension/old_versions/cdb_dataservices_server--0.5.1--0.5.0.sql diff --git a/server/extension/cdb_dataservices_server--0.5.1.sql b/server/extension/old_versions/cdb_dataservices_server--0.5.1.sql similarity index 100% rename from server/extension/cdb_dataservices_server--0.5.1.sql rename to server/extension/old_versions/cdb_dataservices_server--0.5.1.sql diff --git a/server/extension/sql/0.0.1/10_redis_helper.sql b/server/extension/sql/0.0.1/10_redis_helper.sql deleted file mode 100644 index 76f5459..0000000 --- a/server/extension/sql/0.0.1/10_redis_helper.sql +++ /dev/null @@ -1,44 +0,0 @@ -CREATE TYPE cdb_dataservices_server._redis_conf_params AS ( - sentinel_host text, - sentinel_port int, - sentinel_master_id text, - redis_db text, - timeout float -); - --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_redis_conf() -RETURNS cdb_dataservices_server._redis_conf_params AS $$ - conf = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('redis_conf') conf")[0]['conf'] - if conf is None: - plpy.error("There is no redis configuration defined") - else: - import json - params = json.loads(conf) - return { - "sentinel_host": params['sentinel_host'], - "sentinel_port": params['sentinel_port'], - "sentinel_master_id": params['sentinel_master_id'], - "timeout": params['timeout'], - "redis_db": params['redis_db'] - } -$$ LANGUAGE plpythonu; - --- Get the connection to redis from cache or create a new one -CREATE OR REPLACE FUNCTION cdb_dataservices_server._connect_to_redis(user_id text) -RETURNS boolean AS $$ - if user_id in GD and 'redis_connection' in GD[user_id]: - return False - else: - from cartodb_geocoder import redis_helper - config_params = plpy.execute("""select c.sentinel_host, c.sentinel_port, - c.sentinel_master_id, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf() c;""")[0] - redis_connection = redis_helper.RedisHelper(config_params['sentinel_host'], - config_params['sentinel_port'], - config_params['sentinel_master_id'], - timeout=config_params['timeout'], - redis_db=config_params['redis_db']).redis_connection() - GD[user_id] = {'redis_connection': redis_connection} - return True -$$ LANGUAGE plpythonu; diff --git a/server/extension/sql/0.0.1/20_geocode_street.sql b/server/extension/sql/0.0.1/20_geocode_street.sql deleted file mode 100644 index d9bced8..0000000 --- a/server/extension/sql/0.0.1/20_geocode_street.sql +++ /dev/null @@ -1,22 +0,0 @@ --- Geocodes a street address given a searchtext and a state and/or country -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_street_point(searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) - RETURNS Geometry -AS $$ - import json - from heremaps import heremapsgeocoder - - heremaps_conf = json.loads(plpy.execute("SELECT cdb_dataservices_server._get_conf('heremaps')", 1)[0]['get_conf']) - - app_id = heremaps_conf['geocoder']['app_id'] - app_code = heremaps_conf['geocoder']['app_code'] - - geocoder = heremapsgeocoder.Geocoder(app_id, app_code) - - results = geocoder.geocode_address(searchtext=searchtext, city=city, state=state_province, country=country) - coordinates = geocoder.extract_lng_lat_from_result(results[0]) - - plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) - point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] - - return point['st_setsrid'] -$$ LANGUAGE plpythonu; diff --git a/server/extension/sql/0.0.1/30_admin0.sql b/server/extension/sql/0.0.1/30_admin0.sql deleted file mode 100644 index b071feb..0000000 --- a/server/extension/sql/0.0.1/30_admin0.sql +++ /dev/null @@ -1,37 +0,0 @@ --- Interface of the server extension - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin0_polygon(username text, orgname text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_admin0_polygons') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin0_polygon($1) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [country_name], 1) - - plpy.debug('Returning from Returning from cdb_geocode_admin0_polygons') - return rv[0]["mypolygon"] -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin0_polygon(country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT n.the_geom as geom INTO ret - FROM (SELECT q, lower(regexp_replace(q, '[^a-zA-Z\u00C0-\u00ff]+', '', 'g'))::text x - FROM (SELECT country_name q) g) d - LEFT OUTER JOIN admin0_synonyms s ON name_ = d.x - LEFT OUTER JOIN ne_admin0_v3 n ON s.adm0_a3 = n.adm0_a3 GROUP BY d.q, n.the_geom, s.adm0_a3; - - RETURN ret; - END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.0.1/40_admin1.sql b/server/extension/sql/0.0.1/40_admin1.sql deleted file mode 100644 index 8a5e4dc..0000000 --- a/server/extension/sql/0.0.1/40_admin1.sql +++ /dev/null @@ -1,89 +0,0 @@ --- Interfacess of the server extension - ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_admin1_polygon(admin1_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon($1) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [admin1_name], 1) - - plpy.debug('Returning from Returning from cdb_geocode_admin1_polygons') - return rv[0]["mypolygon"] -$$ LANGUAGE plpythonu; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_admin1_polygon(admin1_name text, country_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon($1, $2) AS mypolygon", ["text", "text"]) - rv = plpy.execute(plan, [admin1_name, country_name], 1) - - plpy.debug('Returning from Returning from cdb_geocode_admin1_polygon(admin1_name text, country_name text)') - return rv[0]["mypolygon"] -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT q, ( - SELECT the_geom - FROM global_province_polygons - WHERE d.c = ANY (synonyms) - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM ( - SELECT - trim(replace(lower(admin1_name),'.',' ')) c, admin1_name q - ) d - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - WITH p AS (SELECT r.c, r.q, (SELECT iso3 FROM country_decoder WHERE lower(country_name) = ANY (synonyms)) i FROM (SELECT trim(replace(lower(admin1_name),'.',' ')) c, country_name q) r) - SELECT - geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_province_polygons - WHERE p.c = ANY (synonyms) - AND iso3 = p.i - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM p) n; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.0.1/50_namedplaces.sql b/server/extension/sql/0.0.1/50_namedplaces.sql deleted file mode 100644 index 8a993cc..0000000 --- a/server/extension/sql/0.0.1/50_namedplaces.sql +++ /dev/null @@ -1,121 +0,0 @@ --- Interfacess of the server extension - ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_namedplace_point(city_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point($1) AS mypoint", ["text"]) - rv = plpy.execute(plan, [city_name], 1) - - plpy.debug('Returning from Returning from geocode_namedplace') - return rv[0]["mypoint"] -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_namedplace_point(city_name text, country_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point($1, $2) AS mypoint", ["text", "text"]) - rv = plpy.execute(plan, [city_name, country_name], 1) - - plpy.debug('Returning from Returning from geocode_namedplace') - return rv[0]["mypoint"] -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point($1, $2, $3) AS mypoint", ["text", "text", "text"]) - rv = plpy.execute(plan, [city_name, admin1_name, country_name], 1) - - plpy.debug('Returning from Returning from geocode_namedplace') - return rv[0]["mypoint"] -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH best AS (SELECT s AS q, (SELECT the_geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) ORDER BY population DESC LIMIT 1) AS geom FROM (SELECT city_name as s) p), - next AS (SELECT p.s AS q, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM (SELECT city_name as s) p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT q, geom, TRUE AS success FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT q, geom, CASE WHEN geom IS NULL THEN FALSE ELSE TRUE END AS success FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH p AS (SELECT r.s, r.c, (SELECT iso2 FROM country_decoder WHERE lower(r.c) = ANY (synonyms)) i FROM (SELECT city_name AS s, country_name::text AS c) r), - best AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.iso2 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND gp.iso2 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE c = p.c AND geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH inputcountry AS ( - SELECT iso2 as isoTwo FROM country_decoder WHERE lower(country_name) = ANY (synonyms) LIMIT 1 - ), - p AS ( - SELECT r.s, r.a1, (SELECT admin1 FROM admin1_decoder, inputcountry WHERE lower(r.a1) = ANY (synonyms) AND admin1_decoder.iso2 = inputcountry.isoTwo LIMIT 1) i FROM (SELECT city_name AS s, admin1_name::text AS a1) r), - best AS (SELECT p.s AS q, p.a1 as a1, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.admin1 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.a1 AS a1, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.admin1 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.0.1/60_postalcodes.sql b/server/extension/sql/0.0.1/60_postalcodes.sql deleted file mode 100644 index 3d5b872..0000000 --- a/server/extension/sql/0.0.1/60_postalcodes.sql +++ /dev/null @@ -1,162 +0,0 @@ --- Interface of the server extension - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point($1) AS point", ["text"]) - rv = plpy.execute(plan, [code], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_point') - return rv[0]["point"] -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point($1, $2) AS point", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_point') - return rv[0]["point"] -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_polygon') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon($1) AS polygon", ["text"]) - rv = plpy.execute(plan, [code], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_polygon') - return rv[0]["polygon"] -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon($1, $2) AS polygon", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_point') - return rv[0]["polygon"] -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.0.1/70_ips.sql b/server/extension/sql/0.0.1/70_ips.sql deleted file mode 100644 index c0ec43a..0000000 --- a/server/extension/sql/0.0.1/70_ips.sql +++ /dev/null @@ -1,49 +0,0 @@ --- Interface of the server extension - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_ipaddress_point(username text, orgname text, ip text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_ipaddress_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_ipaddress_point($1) AS point", ["TEXT"]) - rv = plpy.execute(plan, [ip], 1) - - plpy.debug('Returning from _cdb_geocode_ipaddress_point') - return rv[0]["point"] -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_ipaddress_point(ip text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - - new_ip INET; - BEGIN - BEGIN - IF family(ip::inet) = 6 THEN - new_ip := ip::inet; - ELSE - new_ip := ('::ffff:' || ip)::inet; - END IF; - EXCEPTION WHEN OTHERS THEN - SELECT NULL as geom INTO ret; - RETURN ret; - END; - - WITH - ips AS (SELECT ip s, new_ip net), - matches AS (SELECT s, (SELECT the_geom FROM ip_address_locations WHERE network_start_ip <= ips.net ORDER BY network_start_ip DESC LIMIT 1) geom FROM ips) - SELECT geom INTO ret - FROM matches; - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.0.1/90_geocoder_server_user.sql b/server/extension/sql/0.0.1/90_geocoder_server_user.sql deleted file mode 100644 index e011682..0000000 --- a/server/extension/sql/0.0.1/90_geocoder_server_user.sql +++ /dev/null @@ -1,15 +0,0 @@ -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT * - FROM pg_catalog.pg_user - WHERE usename = 'geocoder_api') THEN - - CREATE USER geocoder_api; - END IF; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO geocoder_api; - GRANT USAGE ON SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT USAGE ON SCHEMA public TO geocoder_api; - GRANT SELECT ON ALL TABLES IN SCHEMA public TO geocoder_api; -END$$; diff --git a/server/extension/sql/0.1.0/00_header.sql b/server/extension/sql/0.1.0/00_header.sql deleted file mode 100644 index 2c8035c..0000000 --- a/server/extension/sql/0.1.0/00_header.sql +++ /dev/null @@ -1,3 +0,0 @@ ---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES --- Complain if script is sourced in psql, rather than via CREATE EXTENSION -\echo Use "CREATE EXTENSION cdb_dataservices_server" to load this file. \quit diff --git a/server/extension/sql/0.1.0/10_redis_helper.sql b/server/extension/sql/0.1.0/10_redis_helper.sql deleted file mode 100644 index fc397e8..0000000 --- a/server/extension/sql/0.1.0/10_redis_helper.sql +++ /dev/null @@ -1,57 +0,0 @@ -CREATE TYPE cdb_dataservices_server._redis_conf_params AS ( - sentinel_host text, - sentinel_port int, - sentinel_master_id text, - redis_db text, - timeout float -); - --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_redis_conf_v2(config_key text) -RETURNS cdb_dataservices_server._redis_conf_params AS $$ - conf_query = "SELECT cartodb.CDB_Conf_GetConf('{0}') as conf".format(config_key) - conf = plpy.execute(conf_query)[0]['conf'] - if conf is None: - plpy.error("There is no redis configuration defined") - else: - import json - params = json.loads(conf) - return { - "sentinel_host": params['sentinel_host'], - "sentinel_port": params['sentinel_port'], - "sentinel_master_id": params['sentinel_master_id'], - "timeout": params['timeout'], - "redis_db": params['redis_db'] - } -$$ LANGUAGE plpythonu; - --- Get the connection to redis from cache or create a new one -CREATE OR REPLACE FUNCTION cdb_dataservices_server._connect_to_redis(user_id text) -RETURNS boolean AS $$ - cache_key = "redis_connection_{0}".format(user_id) - if cache_key in GD: - return False - else: - from cartodb_geocoder import redis_helper - metadata_config_params = plpy.execute("""select c.sentinel_host, c.sentinel_port, - c.sentinel_master_id, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metadata_config') c;""")[0] - metrics_config_params = plpy.execute("""select c.sentinel_host, c.sentinel_port, - c.sentinel_master_id, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metrics_config') c;""")[0] - redis_metadata_connection = redis_helper.RedisHelper(metadata_config_params['sentinel_host'], - metadata_config_params['sentinel_port'], - metadata_config_params['sentinel_master_id'], - timeout=metadata_config_params['timeout'], - redis_db=metadata_config_params['redis_db']).redis_connection() - redis_metrics_connection = redis_helper.RedisHelper(metrics_config_params['sentinel_host'], - metrics_config_params['sentinel_port'], - metrics_config_params['sentinel_master_id'], - timeout=metrics_config_params['timeout'], - redis_db=metrics_config_params['redis_db']).redis_connection() - GD[cache_key] = { - 'redis_metadata_connection': redis_metadata_connection, - 'redis_metrics_connection': redis_metrics_connection, - } - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.1.0/15_config_helper.sql b/server/extension/sql/0.1.0/15_config_helper.sql deleted file mode 100644 index 39b0c3d..0000000 --- a/server/extension/sql/0.1.0/15_config_helper.sql +++ /dev/null @@ -1,25 +0,0 @@ --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_geocoder_config(username text, orgname text) -RETURNS boolean AS $$ - cache_key = "user_geocoder_config_{0}".format(username) - if cache_key in GD: - return False - else: - import json - from cartodb_geocoder import config_helper - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] - heremaps_conf_json = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('heremaps_conf') as heremaps_conf", 1)[0]['heremaps_conf'] - if not heremaps_conf_json: - heremaps_app_id = None - heremaps_app_code = None - else: - heremaps_conf = json.loads(heremaps_conf_json) - heremaps_app_id = heremaps_conf['app_id'] - heremaps_app_code = heremaps_conf['app_code'] - geocoder_config = config_helper.GeocoderConfig(redis_conn, username, orgname, heremaps_app_id, heremaps_app_code) - # --Think about the security concerns with this kind of global cache, it should be only available - # --for this user session but... - GD[cache_key] = geocoder_config - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.1.0/20_geocode_street.sql b/server/extension/sql/0.1.0/20_geocode_street.sql deleted file mode 100644 index fc589c2..0000000 --- a/server/extension/sql/0.1.0/20_geocode_street.sql +++ /dev/null @@ -1,58 +0,0 @@ --- Geocodes a street address given a searchtext and a state and/or country -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - plpy.execute("SELECT cdb_dataservices_server._get_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - - if user_geocoder_config.heremaps_geocoder: - here_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_here_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) - return plpy.execute(here_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] - elif user_geocoder_config.google_geocoder: - google_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_google_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) - return plpy.execute(google_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] - else: - plpy.error('Requested geocoder is not available') - -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_here_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - from heremaps import heremapsgeocoder - from cartodb_geocoder import quota_service - - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - - # -- Check the quota - quota_service = quota_service.QuotaService(user_geocoder_config, redis_conn) - if not quota_service.check_user_quota(): - plpy.error('You have reach the limit of your quota') - - try: - geocoder = heremapsgeocoder.Geocoder(user_geocoder_config.heremaps_app_id, user_geocoder_config.heremaps_app_code) - results = geocoder.geocode_address(searchtext=searchtext, city=city, state=state_province, country=country) - coordinates = geocoder.extract_lng_lat_from_result(results[0]) - quota_service.increment_success_geocoder_use() - plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) - point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] - return point['st_setsrid'] - except heremapsgeocoder.EmptyGeocoderResponse: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using here maps geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_google_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - plpy.error('Google geocoder is not available yet') - return None -$$ LANGUAGE plpythonu; diff --git a/server/extension/sql/0.1.0/30_admin0.sql b/server/extension/sql/0.1.0/30_admin0.sql deleted file mode 100644 index b071feb..0000000 --- a/server/extension/sql/0.1.0/30_admin0.sql +++ /dev/null @@ -1,37 +0,0 @@ --- Interface of the server extension - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin0_polygon(username text, orgname text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_admin0_polygons') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin0_polygon($1) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [country_name], 1) - - plpy.debug('Returning from Returning from cdb_geocode_admin0_polygons') - return rv[0]["mypolygon"] -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin0_polygon(country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT n.the_geom as geom INTO ret - FROM (SELECT q, lower(regexp_replace(q, '[^a-zA-Z\u00C0-\u00ff]+', '', 'g'))::text x - FROM (SELECT country_name q) g) d - LEFT OUTER JOIN admin0_synonyms s ON name_ = d.x - LEFT OUTER JOIN ne_admin0_v3 n ON s.adm0_a3 = n.adm0_a3 GROUP BY d.q, n.the_geom, s.adm0_a3; - - RETURN ret; - END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.1.0/40_admin1.sql b/server/extension/sql/0.1.0/40_admin1.sql deleted file mode 100644 index 8a5e4dc..0000000 --- a/server/extension/sql/0.1.0/40_admin1.sql +++ /dev/null @@ -1,89 +0,0 @@ --- Interfacess of the server extension - ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_admin1_polygon(admin1_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon($1) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [admin1_name], 1) - - plpy.debug('Returning from Returning from cdb_geocode_admin1_polygons') - return rv[0]["mypolygon"] -$$ LANGUAGE plpythonu; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_admin1_polygon(admin1_name text, country_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon($1, $2) AS mypolygon", ["text", "text"]) - rv = plpy.execute(plan, [admin1_name, country_name], 1) - - plpy.debug('Returning from Returning from cdb_geocode_admin1_polygon(admin1_name text, country_name text)') - return rv[0]["mypolygon"] -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT q, ( - SELECT the_geom - FROM global_province_polygons - WHERE d.c = ANY (synonyms) - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM ( - SELECT - trim(replace(lower(admin1_name),'.',' ')) c, admin1_name q - ) d - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - WITH p AS (SELECT r.c, r.q, (SELECT iso3 FROM country_decoder WHERE lower(country_name) = ANY (synonyms)) i FROM (SELECT trim(replace(lower(admin1_name),'.',' ')) c, country_name q) r) - SELECT - geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_province_polygons - WHERE p.c = ANY (synonyms) - AND iso3 = p.i - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM p) n; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.1.0/50_namedplaces.sql b/server/extension/sql/0.1.0/50_namedplaces.sql deleted file mode 100644 index 8a993cc..0000000 --- a/server/extension/sql/0.1.0/50_namedplaces.sql +++ /dev/null @@ -1,121 +0,0 @@ --- Interfacess of the server extension - ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_namedplace_point(city_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point($1) AS mypoint", ["text"]) - rv = plpy.execute(plan, [city_name], 1) - - plpy.debug('Returning from Returning from geocode_namedplace') - return rv[0]["mypoint"] -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_namedplace_point(city_name text, country_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point($1, $2) AS mypoint", ["text", "text"]) - rv = plpy.execute(plan, [city_name, country_name], 1) - - plpy.debug('Returning from Returning from geocode_namedplace') - return rv[0]["mypoint"] -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point($1, $2, $3) AS mypoint", ["text", "text", "text"]) - rv = plpy.execute(plan, [city_name, admin1_name, country_name], 1) - - plpy.debug('Returning from Returning from geocode_namedplace') - return rv[0]["mypoint"] -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH best AS (SELECT s AS q, (SELECT the_geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) ORDER BY population DESC LIMIT 1) AS geom FROM (SELECT city_name as s) p), - next AS (SELECT p.s AS q, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM (SELECT city_name as s) p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT q, geom, TRUE AS success FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT q, geom, CASE WHEN geom IS NULL THEN FALSE ELSE TRUE END AS success FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH p AS (SELECT r.s, r.c, (SELECT iso2 FROM country_decoder WHERE lower(r.c) = ANY (synonyms)) i FROM (SELECT city_name AS s, country_name::text AS c) r), - best AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.iso2 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND gp.iso2 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE c = p.c AND geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH inputcountry AS ( - SELECT iso2 as isoTwo FROM country_decoder WHERE lower(country_name) = ANY (synonyms) LIMIT 1 - ), - p AS ( - SELECT r.s, r.a1, (SELECT admin1 FROM admin1_decoder, inputcountry WHERE lower(r.a1) = ANY (synonyms) AND admin1_decoder.iso2 = inputcountry.isoTwo LIMIT 1) i FROM (SELECT city_name AS s, admin1_name::text AS a1) r), - best AS (SELECT p.s AS q, p.a1 as a1, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.admin1 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.a1 AS a1, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.admin1 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.1.0/60_postalcodes.sql b/server/extension/sql/0.1.0/60_postalcodes.sql deleted file mode 100644 index 3d5b872..0000000 --- a/server/extension/sql/0.1.0/60_postalcodes.sql +++ /dev/null @@ -1,162 +0,0 @@ --- Interface of the server extension - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point($1) AS point", ["text"]) - rv = plpy.execute(plan, [code], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_point') - return rv[0]["point"] -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point($1, $2) AS point", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_point') - return rv[0]["point"] -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_polygon') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon($1) AS polygon", ["text"]) - rv = plpy.execute(plan, [code], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_polygon') - return rv[0]["polygon"] -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon($1, $2) AS polygon", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_point') - return rv[0]["polygon"] -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.1.0/70_ips.sql b/server/extension/sql/0.1.0/70_ips.sql deleted file mode 100644 index c0ec43a..0000000 --- a/server/extension/sql/0.1.0/70_ips.sql +++ /dev/null @@ -1,49 +0,0 @@ --- Interface of the server extension - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_ipaddress_point(username text, orgname text, ip text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_ipaddress_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_ipaddress_point($1) AS point", ["TEXT"]) - rv = plpy.execute(plan, [ip], 1) - - plpy.debug('Returning from _cdb_geocode_ipaddress_point') - return rv[0]["point"] -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_ipaddress_point(ip text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - - new_ip INET; - BEGIN - BEGIN - IF family(ip::inet) = 6 THEN - new_ip := ip::inet; - ELSE - new_ip := ('::ffff:' || ip)::inet; - END IF; - EXCEPTION WHEN OTHERS THEN - SELECT NULL as geom INTO ret; - RETURN ret; - END; - - WITH - ips AS (SELECT ip s, new_ip net), - matches AS (SELECT s, (SELECT the_geom FROM ip_address_locations WHERE network_start_ip <= ips.net ORDER BY network_start_ip DESC LIMIT 1) geom FROM ips) - SELECT geom INTO ret - FROM matches; - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.1.0/90_geocoder_server_user.sql b/server/extension/sql/0.1.0/90_geocoder_server_user.sql deleted file mode 100644 index e011682..0000000 --- a/server/extension/sql/0.1.0/90_geocoder_server_user.sql +++ /dev/null @@ -1,15 +0,0 @@ -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT * - FROM pg_catalog.pg_user - WHERE usename = 'geocoder_api') THEN - - CREATE USER geocoder_api; - END IF; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO geocoder_api; - GRANT USAGE ON SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT USAGE ON SCHEMA public TO geocoder_api; - GRANT SELECT ON ALL TABLES IN SCHEMA public TO geocoder_api; -END$$; diff --git a/server/extension/sql/0.2.0/00_header.sql b/server/extension/sql/0.2.0/00_header.sql deleted file mode 100644 index 2c8035c..0000000 --- a/server/extension/sql/0.2.0/00_header.sql +++ /dev/null @@ -1,3 +0,0 @@ ---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES --- Complain if script is sourced in psql, rather than via CREATE EXTENSION -\echo Use "CREATE EXTENSION cdb_dataservices_server" to load this file. \quit diff --git a/server/extension/sql/0.2.0/10_redis_helper.sql b/server/extension/sql/0.2.0/10_redis_helper.sql deleted file mode 100644 index 371ba32..0000000 --- a/server/extension/sql/0.2.0/10_redis_helper.sql +++ /dev/null @@ -1,57 +0,0 @@ -CREATE TYPE cdb_dataservices_server._redis_conf_params AS ( - sentinel_host text, - sentinel_port int, - sentinel_master_id text, - redis_db text, - timeout float -); - --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_redis_conf_v2(config_key text) -RETURNS cdb_dataservices_server._redis_conf_params AS $$ - conf_query = "SELECT cartodb.CDB_Conf_GetConf('{0}') as conf".format(config_key) - conf = plpy.execute(conf_query)[0]['conf'] - if conf is None: - plpy.error("There is no redis configuration defined") - else: - import json - params = json.loads(conf) - return { - "sentinel_host": params['sentinel_host'], - "sentinel_port": params['sentinel_port'], - "sentinel_master_id": params['sentinel_master_id'], - "timeout": params['timeout'], - "redis_db": params['redis_db'] - } -$$ LANGUAGE plpythonu; - --- Get the connection to redis from cache or create a new one -CREATE OR REPLACE FUNCTION cdb_dataservices_server._connect_to_redis(user_id text) -RETURNS boolean AS $$ - cache_key = "redis_connection_{0}".format(user_id) - if cache_key in GD: - return False - else: - from cartodb_services.tools import RedisConnection - metadata_config_params = plpy.execute("""select c.sentinel_host, c.sentinel_port, - c.sentinel_master_id, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metadata_config') c;""")[0] - metrics_config_params = plpy.execute("""select c.sentinel_host, c.sentinel_port, - c.sentinel_master_id, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metrics_config') c;""")[0] - redis_metadata_connection = RedisConnection(metadata_config_params['sentinel_host'], - metadata_config_params['sentinel_port'], - metadata_config_params['sentinel_master_id'], - timeout=metadata_config_params['timeout'], - redis_db=metadata_config_params['redis_db']).redis_connection() - redis_metrics_connection = RedisConnection(metrics_config_params['sentinel_host'], - metrics_config_params['sentinel_port'], - metrics_config_params['sentinel_master_id'], - timeout=metrics_config_params['timeout'], - redis_db=metrics_config_params['redis_db']).redis_connection() - GD[cache_key] = { - 'redis_metadata_connection': redis_metadata_connection, - 'redis_metrics_connection': redis_metrics_connection, - } - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.2.0/15_config_helper.sql b/server/extension/sql/0.2.0/15_config_helper.sql deleted file mode 100644 index 0edd87e..0000000 --- a/server/extension/sql/0.2.0/15_config_helper.sql +++ /dev/null @@ -1,25 +0,0 @@ --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_geocoder_config(username text, orgname text) -RETURNS boolean AS $$ - cache_key = "user_geocoder_config_{0}".format(username) - if cache_key in GD: - return False - else: - import json - from cartodb_services.metrics import GeocoderConfig - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] - heremaps_conf_json = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('heremaps_conf') as heremaps_conf", 1)[0]['heremaps_conf'] - if not heremaps_conf_json: - heremaps_app_id = None - heremaps_app_code = None - else: - heremaps_conf = json.loads(heremaps_conf_json) - heremaps_app_id = heremaps_conf['app_id'] - heremaps_app_code = heremaps_conf['app_code'] - geocoder_config = GeocoderConfig(redis_conn, username, orgname, heremaps_app_id, heremaps_app_code) - # --Think about the security concerns with this kind of global cache, it should be only available - # --for this user session but... - GD[cache_key] = geocoder_config - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.2.0/20_geocode_street.sql b/server/extension/sql/0.2.0/20_geocode_street.sql deleted file mode 100644 index de77f62..0000000 --- a/server/extension/sql/0.2.0/20_geocode_street.sql +++ /dev/null @@ -1,84 +0,0 @@ --- Geocodes a street address given a searchtext and a state and/or country -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - plpy.execute("SELECT cdb_dataservices_server._get_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - - if user_geocoder_config.heremaps_geocoder: - here_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_here_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) - return plpy.execute(here_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] - elif user_geocoder_config.google_geocoder: - google_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_google_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) - return plpy.execute(google_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] - else: - plpy.error('Requested geocoder is not available') - -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_here_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - from cartodb_services.here import HereMapsGeocoder - from cartodb_services.metrics import QuotaService - - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - - # -- Check the quota - quota_service = QuotaService(user_geocoder_config, redis_conn) - if not quota_service.check_user_quota(): - plpy.error('You have reach the limit of your quota') - - try: - geocoder = HereMapsGeocoder(user_geocoder_config.heremaps_app_id, user_geocoder_config.heremaps_app_code) - coordinates = geocoder.geocode(searchtext=searchtext, city=city, state=state_province, country=country) - if coordinates: - quota_service.increment_success_geocoder_use() - plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) - point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] - return point['st_setsrid'] - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using here maps geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_google_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - from cartodb_services.google import GoogleMapsGeocoder - from cartodb_services.metrics import QuotaService - - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - quota_service = QuotaService(user_geocoder_config, redis_conn) - - try: - geocoder = GoogleMapsGeocoder(user_geocoder_config.google_client_id, user_geocoder_config.google_api_key) - coordinates = geocoder.geocode(searchtext=searchtext, city=city, state=state_province, country=country) - if coordinates: - quota_service.increment_success_geocoder_use() - plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) - point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] - return point['st_setsrid'] - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using google maps geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; diff --git a/server/extension/sql/0.2.0/30_admin0.sql b/server/extension/sql/0.2.0/30_admin0.sql deleted file mode 100644 index b071feb..0000000 --- a/server/extension/sql/0.2.0/30_admin0.sql +++ /dev/null @@ -1,37 +0,0 @@ --- Interface of the server extension - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin0_polygon(username text, orgname text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_admin0_polygons') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin0_polygon($1) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [country_name], 1) - - plpy.debug('Returning from Returning from cdb_geocode_admin0_polygons') - return rv[0]["mypolygon"] -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin0_polygon(country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT n.the_geom as geom INTO ret - FROM (SELECT q, lower(regexp_replace(q, '[^a-zA-Z\u00C0-\u00ff]+', '', 'g'))::text x - FROM (SELECT country_name q) g) d - LEFT OUTER JOIN admin0_synonyms s ON name_ = d.x - LEFT OUTER JOIN ne_admin0_v3 n ON s.adm0_a3 = n.adm0_a3 GROUP BY d.q, n.the_geom, s.adm0_a3; - - RETURN ret; - END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.2.0/40_admin1.sql b/server/extension/sql/0.2.0/40_admin1.sql deleted file mode 100644 index 8a5e4dc..0000000 --- a/server/extension/sql/0.2.0/40_admin1.sql +++ /dev/null @@ -1,89 +0,0 @@ --- Interfacess of the server extension - ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_admin1_polygon(admin1_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon($1) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [admin1_name], 1) - - plpy.debug('Returning from Returning from cdb_geocode_admin1_polygons') - return rv[0]["mypolygon"] -$$ LANGUAGE plpythonu; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_admin1_polygon(admin1_name text, country_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon($1, $2) AS mypolygon", ["text", "text"]) - rv = plpy.execute(plan, [admin1_name, country_name], 1) - - plpy.debug('Returning from Returning from cdb_geocode_admin1_polygon(admin1_name text, country_name text)') - return rv[0]["mypolygon"] -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT q, ( - SELECT the_geom - FROM global_province_polygons - WHERE d.c = ANY (synonyms) - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM ( - SELECT - trim(replace(lower(admin1_name),'.',' ')) c, admin1_name q - ) d - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - WITH p AS (SELECT r.c, r.q, (SELECT iso3 FROM country_decoder WHERE lower(country_name) = ANY (synonyms)) i FROM (SELECT trim(replace(lower(admin1_name),'.',' ')) c, country_name q) r) - SELECT - geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_province_polygons - WHERE p.c = ANY (synonyms) - AND iso3 = p.i - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM p) n; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.2.0/50_namedplaces.sql b/server/extension/sql/0.2.0/50_namedplaces.sql deleted file mode 100644 index 8a993cc..0000000 --- a/server/extension/sql/0.2.0/50_namedplaces.sql +++ /dev/null @@ -1,121 +0,0 @@ --- Interfacess of the server extension - ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_namedplace_point(city_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point($1) AS mypoint", ["text"]) - rv = plpy.execute(plan, [city_name], 1) - - plpy.debug('Returning from Returning from geocode_namedplace') - return rv[0]["mypoint"] -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_namedplace_point(city_name text, country_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point($1, $2) AS mypoint", ["text", "text"]) - rv = plpy.execute(plan, [city_name, country_name], 1) - - plpy.debug('Returning from Returning from geocode_namedplace') - return rv[0]["mypoint"] -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - plpy.debug('Entering cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text)') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point($1, $2, $3) AS mypoint", ["text", "text", "text"]) - rv = plpy.execute(plan, [city_name, admin1_name, country_name], 1) - - plpy.debug('Returning from Returning from geocode_namedplace') - return rv[0]["mypoint"] -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH best AS (SELECT s AS q, (SELECT the_geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) ORDER BY population DESC LIMIT 1) AS geom FROM (SELECT city_name as s) p), - next AS (SELECT p.s AS q, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM (SELECT city_name as s) p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT q, geom, TRUE AS success FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT q, geom, CASE WHEN geom IS NULL THEN FALSE ELSE TRUE END AS success FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH p AS (SELECT r.s, r.c, (SELECT iso2 FROM country_decoder WHERE lower(r.c) = ANY (synonyms)) i FROM (SELECT city_name AS s, country_name::text AS c) r), - best AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.iso2 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND gp.iso2 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE c = p.c AND geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH inputcountry AS ( - SELECT iso2 as isoTwo FROM country_decoder WHERE lower(country_name) = ANY (synonyms) LIMIT 1 - ), - p AS ( - SELECT r.s, r.a1, (SELECT admin1 FROM admin1_decoder, inputcountry WHERE lower(r.a1) = ANY (synonyms) AND admin1_decoder.iso2 = inputcountry.isoTwo LIMIT 1) i FROM (SELECT city_name AS s, admin1_name::text AS a1) r), - best AS (SELECT p.s AS q, p.a1 as a1, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.admin1 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.a1 AS a1, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.admin1 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.2.0/60_postalcodes.sql b/server/extension/sql/0.2.0/60_postalcodes.sql deleted file mode 100644 index 3d5b872..0000000 --- a/server/extension/sql/0.2.0/60_postalcodes.sql +++ /dev/null @@ -1,162 +0,0 @@ --- Interface of the server extension - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point($1) AS point", ["text"]) - rv = plpy.execute(plan, [code], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_point') - return rv[0]["point"] -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point($1, $2) AS point", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_point') - return rv[0]["point"] -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_polygon') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon($1) AS polygon", ["text"]) - rv = plpy.execute(plan, [code], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_polygon') - return rv[0]["polygon"] -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_postalcode_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon($1, $2) AS polygon", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - - plpy.debug('Returning from _cdb_geocode_postalcode_point') - return rv[0]["polygon"] -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.2.0/70_ips.sql b/server/extension/sql/0.2.0/70_ips.sql deleted file mode 100644 index c0ec43a..0000000 --- a/server/extension/sql/0.2.0/70_ips.sql +++ /dev/null @@ -1,49 +0,0 @@ --- Interface of the server extension - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_ipaddress_point(username text, orgname text, ip text) -RETURNS Geometry AS $$ - plpy.debug('Entering _cdb_geocode_ipaddress_point') - plpy.debug('user = %s' % username) - - #--TODO: rate limiting check - #--TODO: quota check - - #-- Copied from the doc, see http://www.postgresql.org/docs/9.4/static/plpython-database.html - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_ipaddress_point($1) AS point", ["TEXT"]) - rv = plpy.execute(plan, [ip], 1) - - plpy.debug('Returning from _cdb_geocode_ipaddress_point') - return rv[0]["point"] -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_ipaddress_point(ip text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - - new_ip INET; - BEGIN - BEGIN - IF family(ip::inet) = 6 THEN - new_ip := ip::inet; - ELSE - new_ip := ('::ffff:' || ip)::inet; - END IF; - EXCEPTION WHEN OTHERS THEN - SELECT NULL as geom INTO ret; - RETURN ret; - END; - - WITH - ips AS (SELECT ip s, new_ip net), - matches AS (SELECT s, (SELECT the_geom FROM ip_address_locations WHERE network_start_ip <= ips.net ORDER BY network_start_ip DESC LIMIT 1) geom FROM ips) - SELECT geom INTO ret - FROM matches; - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.2.0/90_geocoder_server_user.sql b/server/extension/sql/0.2.0/90_geocoder_server_user.sql deleted file mode 100644 index e011682..0000000 --- a/server/extension/sql/0.2.0/90_geocoder_server_user.sql +++ /dev/null @@ -1,15 +0,0 @@ -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT * - FROM pg_catalog.pg_user - WHERE usename = 'geocoder_api') THEN - - CREATE USER geocoder_api; - END IF; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO geocoder_api; - GRANT USAGE ON SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT USAGE ON SCHEMA public TO geocoder_api; - GRANT SELECT ON ALL TABLES IN SCHEMA public TO geocoder_api; -END$$; diff --git a/server/extension/sql/0.3.0/00_header.sql b/server/extension/sql/0.3.0/00_header.sql deleted file mode 100644 index 2c8035c..0000000 --- a/server/extension/sql/0.3.0/00_header.sql +++ /dev/null @@ -1,3 +0,0 @@ ---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES --- Complain if script is sourced in psql, rather than via CREATE EXTENSION -\echo Use "CREATE EXTENSION cdb_dataservices_server" to load this file. \quit diff --git a/server/extension/sql/0.3.0/10_redis_helper.sql b/server/extension/sql/0.3.0/10_redis_helper.sql deleted file mode 100644 index 371ba32..0000000 --- a/server/extension/sql/0.3.0/10_redis_helper.sql +++ /dev/null @@ -1,57 +0,0 @@ -CREATE TYPE cdb_dataservices_server._redis_conf_params AS ( - sentinel_host text, - sentinel_port int, - sentinel_master_id text, - redis_db text, - timeout float -); - --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_redis_conf_v2(config_key text) -RETURNS cdb_dataservices_server._redis_conf_params AS $$ - conf_query = "SELECT cartodb.CDB_Conf_GetConf('{0}') as conf".format(config_key) - conf = plpy.execute(conf_query)[0]['conf'] - if conf is None: - plpy.error("There is no redis configuration defined") - else: - import json - params = json.loads(conf) - return { - "sentinel_host": params['sentinel_host'], - "sentinel_port": params['sentinel_port'], - "sentinel_master_id": params['sentinel_master_id'], - "timeout": params['timeout'], - "redis_db": params['redis_db'] - } -$$ LANGUAGE plpythonu; - --- Get the connection to redis from cache or create a new one -CREATE OR REPLACE FUNCTION cdb_dataservices_server._connect_to_redis(user_id text) -RETURNS boolean AS $$ - cache_key = "redis_connection_{0}".format(user_id) - if cache_key in GD: - return False - else: - from cartodb_services.tools import RedisConnection - metadata_config_params = plpy.execute("""select c.sentinel_host, c.sentinel_port, - c.sentinel_master_id, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metadata_config') c;""")[0] - metrics_config_params = plpy.execute("""select c.sentinel_host, c.sentinel_port, - c.sentinel_master_id, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metrics_config') c;""")[0] - redis_metadata_connection = RedisConnection(metadata_config_params['sentinel_host'], - metadata_config_params['sentinel_port'], - metadata_config_params['sentinel_master_id'], - timeout=metadata_config_params['timeout'], - redis_db=metadata_config_params['redis_db']).redis_connection() - redis_metrics_connection = RedisConnection(metrics_config_params['sentinel_host'], - metrics_config_params['sentinel_port'], - metrics_config_params['sentinel_master_id'], - timeout=metrics_config_params['timeout'], - redis_db=metrics_config_params['redis_db']).redis_connection() - GD[cache_key] = { - 'redis_metadata_connection': redis_metadata_connection, - 'redis_metrics_connection': redis_metrics_connection, - } - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.3.0/15_config_helper.sql b/server/extension/sql/0.3.0/15_config_helper.sql deleted file mode 100644 index 0edd87e..0000000 --- a/server/extension/sql/0.3.0/15_config_helper.sql +++ /dev/null @@ -1,25 +0,0 @@ --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_geocoder_config(username text, orgname text) -RETURNS boolean AS $$ - cache_key = "user_geocoder_config_{0}".format(username) - if cache_key in GD: - return False - else: - import json - from cartodb_services.metrics import GeocoderConfig - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] - heremaps_conf_json = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('heremaps_conf') as heremaps_conf", 1)[0]['heremaps_conf'] - if not heremaps_conf_json: - heremaps_app_id = None - heremaps_app_code = None - else: - heremaps_conf = json.loads(heremaps_conf_json) - heremaps_app_id = heremaps_conf['app_id'] - heremaps_app_code = heremaps_conf['app_code'] - geocoder_config = GeocoderConfig(redis_conn, username, orgname, heremaps_app_id, heremaps_app_code) - # --Think about the security concerns with this kind of global cache, it should be only available - # --for this user session but... - GD[cache_key] = geocoder_config - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.3.0/20_geocode_street.sql b/server/extension/sql/0.3.0/20_geocode_street.sql deleted file mode 100644 index de77f62..0000000 --- a/server/extension/sql/0.3.0/20_geocode_street.sql +++ /dev/null @@ -1,84 +0,0 @@ --- Geocodes a street address given a searchtext and a state and/or country -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - plpy.execute("SELECT cdb_dataservices_server._get_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - - if user_geocoder_config.heremaps_geocoder: - here_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_here_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) - return plpy.execute(here_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] - elif user_geocoder_config.google_geocoder: - google_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_google_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) - return plpy.execute(google_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] - else: - plpy.error('Requested geocoder is not available') - -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_here_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - from cartodb_services.here import HereMapsGeocoder - from cartodb_services.metrics import QuotaService - - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - - # -- Check the quota - quota_service = QuotaService(user_geocoder_config, redis_conn) - if not quota_service.check_user_quota(): - plpy.error('You have reach the limit of your quota') - - try: - geocoder = HereMapsGeocoder(user_geocoder_config.heremaps_app_id, user_geocoder_config.heremaps_app_code) - coordinates = geocoder.geocode(searchtext=searchtext, city=city, state=state_province, country=country) - if coordinates: - quota_service.increment_success_geocoder_use() - plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) - point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] - return point['st_setsrid'] - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using here maps geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_google_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - from cartodb_services.google import GoogleMapsGeocoder - from cartodb_services.metrics import QuotaService - - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - quota_service = QuotaService(user_geocoder_config, redis_conn) - - try: - geocoder = GoogleMapsGeocoder(user_geocoder_config.google_client_id, user_geocoder_config.google_api_key) - coordinates = geocoder.geocode(searchtext=searchtext, city=city, state=state_province, country=country) - if coordinates: - quota_service.increment_success_geocoder_use() - plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) - point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] - return point['st_setsrid'] - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using google maps geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; diff --git a/server/extension/sql/0.3.0/30_admin0.sql b/server/extension/sql/0.3.0/30_admin0.sql deleted file mode 100644 index ec8fe5c..0000000 --- a/server/extension/sql/0.3.0/30_admin0.sql +++ /dev/null @@ -1,50 +0,0 @@ -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin0_polygon(username text, orgname text, country_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin0_polygon(trim($1)) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [country_name], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin0_polygon(country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT n.the_geom as geom INTO ret - FROM (SELECT q, lower(regexp_replace(q, '[^a-zA-Z\u00C0-\u00ff]+', '', 'g'))::text x - FROM (SELECT country_name q) g) d - LEFT OUTER JOIN admin0_synonyms s ON name_ = d.x - LEFT OUTER JOIN ne_admin0_v3 n ON s.adm0_a3 = n.adm0_a3 GROUP BY d.q, n.the_geom, s.adm0_a3; - - RETURN ret; - END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.3.0/40_admin1.sql b/server/extension/sql/0.3.0/40_admin1.sql deleted file mode 100644 index dc8e037..0000000 --- a/server/extension/sql/0.3.0/40_admin1.sql +++ /dev/null @@ -1,117 +0,0 @@ ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon(trim($1)) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [admin1_name], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon(trim($1), trim($2)) AS mypolygon", ["text", "text"]) - rv = plpy.execute(plan, [admin1_name, country_name], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT q, ( - SELECT the_geom - FROM global_province_polygons - WHERE d.c = ANY (synonyms) - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM ( - SELECT - trim(replace(lower(admin1_name),'.',' ')) c, admin1_name q - ) d - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - WITH p AS (SELECT r.c, r.q, (SELECT iso3 FROM country_decoder WHERE lower(country_name) = ANY (synonyms)) i FROM (SELECT trim(replace(lower(admin1_name),'.',' ')) c, country_name q) r) - SELECT - geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_province_polygons - WHERE p.c = ANY (synonyms) - AND iso3 = p.i - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM p) n; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.3.0/50_namedplaces.sql b/server/extension/sql/0.3.0/50_namedplaces.sql deleted file mode 100644 index 80306cb..0000000 --- a/server/extension/sql/0.3.0/50_namedplaces.sql +++ /dev/null @@ -1,164 +0,0 @@ ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point(trim($1)) AS mypoint", ["text"]) - rv = plpy.execute(plan, [city_name], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, country_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point(trim($1), trim($2)) AS mypoint", ["text", "text"]) - rv = plpy.execute(plan, [city_name, country_name], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point(trim($1), trim($2), trim($3)) AS mypoint", ["text", "text", "text"]) - rv = plpy.execute(plan, [city_name, admin1_name, country_name], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH best AS (SELECT s AS q, (SELECT the_geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) ORDER BY population DESC LIMIT 1) AS geom FROM (SELECT city_name as s) p), - next AS (SELECT p.s AS q, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM (SELECT city_name as s) p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT q, geom, TRUE AS success FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT q, geom, CASE WHEN geom IS NULL THEN FALSE ELSE TRUE END AS success FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH p AS (SELECT r.s, r.c, (SELECT iso2 FROM country_decoder WHERE lower(r.c) = ANY (synonyms)) i FROM (SELECT city_name AS s, country_name::text AS c) r), - best AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.iso2 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND gp.iso2 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE c = p.c AND geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH inputcountry AS ( - SELECT iso2 as isoTwo FROM country_decoder WHERE lower(country_name) = ANY (synonyms) LIMIT 1 - ), - p AS ( - SELECT r.s, r.a1, (SELECT admin1 FROM admin1_decoder, inputcountry WHERE lower(r.a1) = ANY (synonyms) AND admin1_decoder.iso2 = inputcountry.isoTwo LIMIT 1) i FROM (SELECT city_name AS s, admin1_name::text AS a1) r), - best AS (SELECT p.s AS q, p.a1 as a1, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.admin1 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.a1 AS a1, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.admin1 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.3.0/60_postalcodes.sql b/server/extension/sql/0.3.0/60_postalcodes.sql deleted file mode 100644 index 4ba321b..0000000 --- a/server/extension/sql/0.3.0/60_postalcodes.sql +++ /dev/null @@ -1,219 +0,0 @@ -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point(trim($1)) AS mypoint", ["text"]) - rv = plpy.execute(plan, [code], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point(trim($1), trim($2)) AS mypoint", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon(trim($1)) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [code], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon(trim($1), trim($2)) AS mypolygon", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.3.0/70_ips.sql b/server/extension/sql/0.3.0/70_ips.sql deleted file mode 100644 index f76190f..0000000 --- a/server/extension/sql/0.3.0/70_ips.sql +++ /dev/null @@ -1,61 +0,0 @@ -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_ipaddress_point(username text, orgname text, ip text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_ipaddress_point(trim($1)) AS mypoint", ["TEXT"]) - rv = plpy.execute(plan, [ip], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_ipaddress_point(ip text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - - new_ip INET; - BEGIN - BEGIN - IF family(ip::inet) = 6 THEN - new_ip := ip::inet; - ELSE - new_ip := ('::ffff:' || ip)::inet; - END IF; - EXCEPTION WHEN OTHERS THEN - SELECT NULL as geom INTO ret; - RETURN ret; - END; - - WITH - ips AS (SELECT ip s, new_ip net), - matches AS (SELECT s, (SELECT the_geom FROM ip_address_locations WHERE network_start_ip <= ips.net ORDER BY network_start_ip DESC LIMIT 1) geom FROM ips) - SELECT geom INTO ret - FROM matches; - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.3.0/90_geocoder_server_user.sql b/server/extension/sql/0.3.0/90_geocoder_server_user.sql deleted file mode 100644 index e011682..0000000 --- a/server/extension/sql/0.3.0/90_geocoder_server_user.sql +++ /dev/null @@ -1,15 +0,0 @@ -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT * - FROM pg_catalog.pg_user - WHERE usename = 'geocoder_api') THEN - - CREATE USER geocoder_api; - END IF; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO geocoder_api; - GRANT USAGE ON SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT USAGE ON SCHEMA public TO geocoder_api; - GRANT SELECT ON ALL TABLES IN SCHEMA public TO geocoder_api; -END$$; diff --git a/server/extension/sql/0.4.0/00_header.sql b/server/extension/sql/0.4.0/00_header.sql deleted file mode 100644 index 2c8035c..0000000 --- a/server/extension/sql/0.4.0/00_header.sql +++ /dev/null @@ -1,3 +0,0 @@ ---DO NOT MODIFY THIS FILE, IT IS GENERATED AUTOMATICALLY FROM SOURCES --- Complain if script is sourced in psql, rather than via CREATE EXTENSION -\echo Use "CREATE EXTENSION cdb_dataservices_server" to load this file. \quit diff --git a/server/extension/sql/0.4.0/10_redis_helper.sql b/server/extension/sql/0.4.0/10_redis_helper.sql deleted file mode 100644 index 371ba32..0000000 --- a/server/extension/sql/0.4.0/10_redis_helper.sql +++ /dev/null @@ -1,57 +0,0 @@ -CREATE TYPE cdb_dataservices_server._redis_conf_params AS ( - sentinel_host text, - sentinel_port int, - sentinel_master_id text, - redis_db text, - timeout float -); - --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_redis_conf_v2(config_key text) -RETURNS cdb_dataservices_server._redis_conf_params AS $$ - conf_query = "SELECT cartodb.CDB_Conf_GetConf('{0}') as conf".format(config_key) - conf = plpy.execute(conf_query)[0]['conf'] - if conf is None: - plpy.error("There is no redis configuration defined") - else: - import json - params = json.loads(conf) - return { - "sentinel_host": params['sentinel_host'], - "sentinel_port": params['sentinel_port'], - "sentinel_master_id": params['sentinel_master_id'], - "timeout": params['timeout'], - "redis_db": params['redis_db'] - } -$$ LANGUAGE plpythonu; - --- Get the connection to redis from cache or create a new one -CREATE OR REPLACE FUNCTION cdb_dataservices_server._connect_to_redis(user_id text) -RETURNS boolean AS $$ - cache_key = "redis_connection_{0}".format(user_id) - if cache_key in GD: - return False - else: - from cartodb_services.tools import RedisConnection - metadata_config_params = plpy.execute("""select c.sentinel_host, c.sentinel_port, - c.sentinel_master_id, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metadata_config') c;""")[0] - metrics_config_params = plpy.execute("""select c.sentinel_host, c.sentinel_port, - c.sentinel_master_id, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metrics_config') c;""")[0] - redis_metadata_connection = RedisConnection(metadata_config_params['sentinel_host'], - metadata_config_params['sentinel_port'], - metadata_config_params['sentinel_master_id'], - timeout=metadata_config_params['timeout'], - redis_db=metadata_config_params['redis_db']).redis_connection() - redis_metrics_connection = RedisConnection(metrics_config_params['sentinel_host'], - metrics_config_params['sentinel_port'], - metrics_config_params['sentinel_master_id'], - timeout=metrics_config_params['timeout'], - redis_db=metrics_config_params['redis_db']).redis_connection() - GD[cache_key] = { - 'redis_metadata_connection': redis_metadata_connection, - 'redis_metrics_connection': redis_metrics_connection, - } - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.4.0/15_config_helper.sql b/server/extension/sql/0.4.0/15_config_helper.sql deleted file mode 100644 index c49ef50..0000000 --- a/server/extension/sql/0.4.0/15_config_helper.sql +++ /dev/null @@ -1,51 +0,0 @@ --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_geocoder_config(username text, orgname text) -RETURNS boolean AS $$ - cache_key = "user_geocoder_config_{0}".format(username) - if cache_key in GD: - return False - else: - import json - from cartodb_services.metrics import GeocoderConfig - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] - heremaps_conf_json = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('heremaps_conf') as heremaps_conf", 1)[0]['heremaps_conf'] - if not heremaps_conf_json: - heremaps_app_id = None - heremaps_app_code = None - else: - heremaps_conf = json.loads(heremaps_conf_json) - heremaps_app_id = heremaps_conf['app_id'] - heremaps_app_code = heremaps_conf['app_code'] - geocoder_config = GeocoderConfig(redis_conn, username, orgname, heremaps_app_id, heremaps_app_code) - # --Think about the security concerns with this kind of global cache, it should be only available - # --for this user session but... - GD[cache_key] = geocoder_config - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; - --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_isolines_routing_config(username text, orgname text) -RETURNS boolean AS $$ - cache_key = "user_isolines_routing_config_{0}".format(username) - if cache_key in GD: - return False - else: - import json - from cartodb_services.metrics import IsolinesRoutingConfig - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] - heremaps_conf_json = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('heremaps_conf') as heremaps_conf", 1)[0]['heremaps_conf'] - if not heremaps_conf_json: - heremaps_app_id = None - heremaps_app_code = None - else: - heremaps_conf = json.loads(heremaps_conf_json) - heremaps_app_id = heremaps_conf['app_id'] - heremaps_app_code = heremaps_conf['app_code'] - isolines_routing_config = IsolinesRoutingConfig(redis_conn, username, orgname, heremaps_app_id, heremaps_app_code) - # --Think about the security concerns with this kind of global cache, it should be only available - # --for this user session but... - GD[cache_key] = isolines_routing_config - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.4.0/20_geocode_street.sql b/server/extension/sql/0.4.0/20_geocode_street.sql deleted file mode 100644 index de77f62..0000000 --- a/server/extension/sql/0.4.0/20_geocode_street.sql +++ /dev/null @@ -1,84 +0,0 @@ --- Geocodes a street address given a searchtext and a state and/or country -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - plpy.execute("SELECT cdb_dataservices_server._get_geocoder_config({0}, {1})".format(plpy.quote_nullable(username), plpy.quote_nullable(orgname))) - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - - if user_geocoder_config.heremaps_geocoder: - here_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_here_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) - return plpy.execute(here_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] - elif user_geocoder_config.google_geocoder: - google_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_google_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"]) - return plpy.execute(google_plan, [username, orgname, searchtext, city, state_province, country], 1)[0]['point'] - else: - plpy.error('Requested geocoder is not available') - -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_here_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - from cartodb_services.here import HereMapsGeocoder - from cartodb_services.metrics import QuotaService - - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - - # -- Check the quota - quota_service = QuotaService(user_geocoder_config, redis_conn) - if not quota_service.check_user_quota(): - plpy.error('You have reach the limit of your quota') - - try: - geocoder = HereMapsGeocoder(user_geocoder_config.heremaps_app_id, user_geocoder_config.heremaps_app_code) - coordinates = geocoder.geocode(searchtext=searchtext, city=city, state=state_province, country=country) - if coordinates: - quota_service.increment_success_geocoder_use() - plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) - point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] - return point['st_setsrid'] - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using here maps geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_google_geocode_street_point(username TEXT, orgname TEXT, searchtext TEXT, city TEXT DEFAULT NULL, state_province TEXT DEFAULT NULL, country TEXT DEFAULT NULL) -RETURNS Geometry AS $$ - from cartodb_services.google import GoogleMapsGeocoder - from cartodb_services.metrics import QuotaService - - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = GD["user_geocoder_config_{0}".format(username)] - quota_service = QuotaService(user_geocoder_config, redis_conn) - - try: - geocoder = GoogleMapsGeocoder(user_geocoder_config.google_client_id, user_geocoder_config.google_api_key) - coordinates = geocoder.geocode(searchtext=searchtext, city=city, state=state_province, country=country) - if coordinates: - quota_service.increment_success_geocoder_use() - plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326); ", ["double precision", "double precision"]) - point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0] - return point['st_setsrid'] - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using google maps geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; diff --git a/server/extension/sql/0.4.0/30_admin0.sql b/server/extension/sql/0.4.0/30_admin0.sql deleted file mode 100644 index ec8fe5c..0000000 --- a/server/extension/sql/0.4.0/30_admin0.sql +++ /dev/null @@ -1,50 +0,0 @@ -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin0_polygon(username text, orgname text, country_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin0_polygon(trim($1)) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [country_name], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin0_polygon(country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT n.the_geom as geom INTO ret - FROM (SELECT q, lower(regexp_replace(q, '[^a-zA-Z\u00C0-\u00ff]+', '', 'g'))::text x - FROM (SELECT country_name q) g) d - LEFT OUTER JOIN admin0_synonyms s ON name_ = d.x - LEFT OUTER JOIN ne_admin0_v3 n ON s.adm0_a3 = n.adm0_a3 GROUP BY d.q, n.the_geom, s.adm0_a3; - - RETURN ret; - END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.4.0/40_admin1.sql b/server/extension/sql/0.4.0/40_admin1.sql deleted file mode 100644 index dc8e037..0000000 --- a/server/extension/sql/0.4.0/40_admin1.sql +++ /dev/null @@ -1,117 +0,0 @@ ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon(trim($1)) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [admin1_name], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_admin1_polygon(username text, orgname text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_admin1_polygon(trim($1), trim($2)) AS mypolygon", ["text", "text"]) - rv = plpy.execute(plan, [admin1_name, country_name], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_admin1_polygon(admin1_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT q, ( - SELECT the_geom - FROM global_province_polygons - WHERE d.c = ANY (synonyms) - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM ( - SELECT - trim(replace(lower(admin1_name),'.',' ')) c, admin1_name q - ) d - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_admin1_polygon(admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_admin1_polygon(admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - WITH p AS (SELECT r.c, r.q, (SELECT iso3 FROM country_decoder WHERE lower(country_name) = ANY (synonyms)) i FROM (SELECT trim(replace(lower(admin1_name),'.',' ')) c, country_name q) r) - SELECT - geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_province_polygons - WHERE p.c = ANY (synonyms) - AND iso3 = p.i - ORDER BY frequency DESC LIMIT 1 - ) geom - FROM p) n; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.4.0/50_namedplaces.sql b/server/extension/sql/0.4.0/50_namedplaces.sql deleted file mode 100644 index 80306cb..0000000 --- a/server/extension/sql/0.4.0/50_namedplaces.sql +++ /dev/null @@ -1,164 +0,0 @@ ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point(trim($1)) AS mypoint", ["text"]) - rv = plpy.execute(plan, [city_name], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, country_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point(trim($1), trim($2)) AS mypoint", ["text", "text"]) - rv = plpy.execute(plan, [city_name, country_name], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_namedplace_point(username text, orgname text, city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_namedplace_point(trim($1), trim($2), trim($3)) AS mypoint", ["text", "text", "text"]) - rv = plpy.execute(plan, [city_name, admin1_name, country_name], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension - ----- cdb_geocode_namedplace_point(city_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH best AS (SELECT s AS q, (SELECT the_geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) ORDER BY population DESC LIMIT 1) AS geom FROM (SELECT city_name as s) p), - next AS (SELECT p.s AS q, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM (SELECT city_name as s) p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT q, geom, TRUE AS success FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT q, geom, CASE WHEN geom IS NULL THEN FALSE ELSE TRUE END AS success FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH p AS (SELECT r.s, r.c, (SELECT iso2 FROM country_decoder WHERE lower(r.c) = ANY (synonyms)) i FROM (SELECT city_name AS s, country_name::text AS c) r), - best AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.iso2 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.c AS c, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND gp.iso2 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE c = p.c AND geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - ----- cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_namedplace_point(city_name text, admin1_name text, country_name text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - WITH inputcountry AS ( - SELECT iso2 as isoTwo FROM country_decoder WHERE lower(country_name) = ANY (synonyms) LIMIT 1 - ), - p AS ( - SELECT r.s, r.a1, (SELECT admin1 FROM admin1_decoder, inputcountry WHERE lower(r.a1) = ANY (synonyms) AND admin1_decoder.iso2 = inputcountry.isoTwo LIMIT 1) i FROM (SELECT city_name AS s, admin1_name::text AS a1) r), - best AS (SELECT p.s AS q, p.a1 as a1, (SELECT gp.the_geom AS geom FROM global_cities_points_limited gp WHERE gp.lowername = lower(p.s) AND gp.admin1 = p.i ORDER BY population DESC LIMIT 1) AS geom FROM p), - next AS (SELECT p.s AS q, p.a1 AS a1, (SELECT gp.the_geom FROM global_cities_points_limited gp, global_cities_alternates_limited ga WHERE lower(p.s) = ga.lowername AND ga.admin1 = p.i AND ga.geoname_id = gp.geoname_id ORDER BY preferred DESC LIMIT 1) geom FROM p WHERE p.s NOT IN (SELECT q FROM best WHERE geom IS NOT NULL)) - SELECT geom FROM best WHERE geom IS NOT NULL - UNION ALL - SELECT geom FROM next - ) v; - - RETURN ret; - END -$$ LANGUAGE plpgsql; - diff --git a/server/extension/sql/0.4.0/60_postalcodes.sql b/server/extension/sql/0.4.0/60_postalcodes.sql deleted file mode 100644 index 4ba321b..0000000 --- a/server/extension/sql/0.4.0/60_postalcodes.sql +++ /dev/null @@ -1,219 +0,0 @@ -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point(trim($1)) AS mypoint", ["text"]) - rv = plpy.execute(plan, [code], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_point(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_point(trim($1), trim($2)) AS mypoint", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon(trim($1)) AS mypolygon", ["text"]) - rv = plpy.execute(plan, [code], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_postalcode_polygon(username text, orgname text, code text, country text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_postalcode_polygon(trim($1), trim($2)) AS mypolygon", ["TEXT", "TEXT"]) - rv = plpy.execute(plan, [code, country], 1) - result = rv[0]["mypolygon"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_point(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_points - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_postalcode_polygon(code text, country text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - BEGIN - SELECT geom INTO ret - FROM ( - SELECT - q, ( - SELECT the_geom - FROM global_postal_code_polygons - WHERE postal_code = upper(d.q) - AND iso3 = ( - SELECT iso3 FROM country_decoder WHERE - lower(country) = ANY (synonyms) LIMIT 1 - ) - LIMIT 1 - ) geom - FROM (SELECT code q) d - ) v; - - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.4.0/70_ips.sql b/server/extension/sql/0.4.0/70_ips.sql deleted file mode 100644 index f76190f..0000000 --- a/server/extension/sql/0.4.0/70_ips.sql +++ /dev/null @@ -1,61 +0,0 @@ -CREATE OR REPLACE FUNCTION cdb_dataservices_server.cdb_geocode_ipaddress_point(username text, orgname text, ip text) -RETURNS Geometry AS $$ - from cartodb_services.metrics import QuotaService - from cartodb_services.metrics import InternalGeocoderConfig - - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_geocoder_config = InternalGeocoderConfig(redis_conn, username, orgname) - - quota_service = QuotaService(user_geocoder_config, redis_conn) - try: - plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_geocode_ipaddress_point(trim($1)) AS mypoint", ["TEXT"]) - rv = plpy.execute(plan, [ip], 1) - result = rv[0]["mypoint"] - if result: - quota_service.increment_success_geocoder_use() - return result - else: - quota_service.increment_empty_geocoder_use() - return None - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to geocode using admin0 geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu; - --------------------------------------------------------------------------------- - --- Implementation of the server extension --- Note: these functions depend on the cdb_geocoder extension -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_geocode_ipaddress_point(ip text) -RETURNS Geometry AS $$ - DECLARE - ret Geometry; - - new_ip INET; - BEGIN - BEGIN - IF family(ip::inet) = 6 THEN - new_ip := ip::inet; - ELSE - new_ip := ('::ffff:' || ip)::inet; - END IF; - EXCEPTION WHEN OTHERS THEN - SELECT NULL as geom INTO ret; - RETURN ret; - END; - - WITH - ips AS (SELECT ip s, new_ip net), - matches AS (SELECT s, (SELECT the_geom FROM ip_address_locations WHERE network_start_ip <= ips.net ORDER BY network_start_ip DESC LIMIT 1) geom FROM ips) - SELECT geom INTO ret - FROM matches; - RETURN ret; -END -$$ LANGUAGE plpgsql; diff --git a/server/extension/sql/0.4.0/80_isolines_helper.sql b/server/extension/sql/0.4.0/80_isolines_helper.sql deleted file mode 100644 index eb15963..0000000 --- a/server/extension/sql/0.4.0/80_isolines_helper.sql +++ /dev/null @@ -1,54 +0,0 @@ -CREATE TYPE cdb_dataservices_server.isoline AS (center geometry(Geometry,4326), data_range integer, the_geom geometry(Multipolygon,4326)); - -CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_here_routing_isolines(username TEXT, orgname TEXT, type TEXT, source geometry(Geometry, 4326), mode TEXT, data_range integer[], options text[]) -RETURNS SETOF cdb_dataservices_server.isoline AS $$ - import json - from cartodb_services.here import HereMapsRoutingIsoline - from cartodb_services.metrics import QuotaService - from cartodb_services.here.types import geo_polyline_to_multipolygon - - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metrics_connection'] - user_isolines_routing_config = GD["user_isolines_routing_config_{0}".format(username)] - - # -- Check the quota - quota_service = QuotaService(user_isolines_routing_config, redis_conn) - if not quota_service.check_user_quota(): - plpy.error('You have reach the limit of your quota') - - try: - client = HereMapsRoutingIsoline(user_isolines_routing_config.heremaps_app_id, user_isolines_routing_config.heremaps_app_code, base_url = HereMapsRoutingIsoline.PRODUCTION_ROUTING_BASE_URL) - - if source: - lat = plpy.execute("SELECT ST_Y('%s') AS lat" % source)[0]['lat'] - lon = plpy.execute("SELECT ST_X('%s') AS lon" % source)[0]['lon'] - source_str = 'geo!%f,%f' % (lat, lon) - else: - source_str = None - - if type == 'isodistance': - resp = client.calculate_isodistance(source_str, mode, data_range, options) - elif type == 'isochrone': - resp = client.calculate_isochrone(source_str, mode, data_range, options) - - if resp: - result = [] - for isoline in resp: - data_range_n = isoline['range'] - polyline = isoline['geom'] - multipolygon = geo_polyline_to_multipolygon(polyline) - result.append([source, data_range_n, multipolygon]) - quota_service.increment_success_geocoder_use() - quota_service.increment_isolines_service_use(len(resp)) - return result - else: - quota_service.increment_empty_geocoder_use() - except BaseException as e: - import sys, traceback - type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() - error_msg = 'There was an error trying to obtain isodistances using here maps geocoder: {0}'.format(e) - plpy.notice(traceback.format_tb(traceback_)) - plpy.error(error_msg) - finally: - quota_service.increment_total_geocoder_use() -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.4.0/99_geocoder_server_user.sql b/server/extension/sql/0.4.0/99_geocoder_server_user.sql deleted file mode 100644 index e011682..0000000 --- a/server/extension/sql/0.4.0/99_geocoder_server_user.sql +++ /dev/null @@ -1,15 +0,0 @@ -DO $$ -BEGIN - IF NOT EXISTS ( - SELECT * - FROM pg_catalog.pg_user - WHERE usename = 'geocoder_api') THEN - - CREATE USER geocoder_api; - END IF; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public TO geocoder_api; - GRANT USAGE ON SCHEMA cdb_dataservices_server TO geocoder_api; - GRANT USAGE ON SCHEMA public TO geocoder_api; - GRANT SELECT ON ALL TABLES IN SCHEMA public TO geocoder_api; -END$$; diff --git a/server/extension/sql/0.5.0/00_header.sql b/server/extension/sql/0.5.0/00_header.sql deleted file mode 120000 index 6d12de2..0000000 --- a/server/extension/sql/0.5.0/00_header.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/00_header.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.0/10_redis_helper.sql b/server/extension/sql/0.5.0/10_redis_helper.sql deleted file mode 100644 index 77f3b01..0000000 --- a/server/extension/sql/0.5.0/10_redis_helper.sql +++ /dev/null @@ -1,62 +0,0 @@ -CREATE TYPE cdb_dataservices_server._redis_conf_params AS ( - sentinel_master_id text, - redis_host text, - redis_port int, - redis_db text, - timeout float -); - --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_redis_conf_v2(config_key text) -RETURNS cdb_dataservices_server._redis_conf_params AS $$ - conf_query = "SELECT cartodb.CDB_Conf_GetConf('{0}') as conf".format(config_key) - conf = plpy.execute(conf_query)[0]['conf'] - if conf is None: - plpy.error("There is no redis configuration defined") - else: - import json - params = json.loads(conf) - redis_conf_params = { - "redis_host": params['redis_host'], - "redis_port": params['redis_port'], - "timeout": params['timeout'], - "redis_db": params['redis_db'] - } - if "sentinel_master_id" in params: - redis_conf_params["sentinel_master_id"] = params["sentinel_master_id"] - else: - redis_conf_params["sentinel_master_id"] = None - - return redis_conf_params -$$ LANGUAGE plpythonu; - --- Get the connection to redis from cache or create a new one -CREATE OR REPLACE FUNCTION cdb_dataservices_server._connect_to_redis(user_id text) -RETURNS boolean AS $$ - cache_key = "redis_connection_{0}".format(user_id) - if cache_key in GD: - return False - else: - from cartodb_services.tools import RedisConnection - metadata_config_params = plpy.execute("""select c.sentinel_master_id, c.redis_host, - c.redis_port, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metadata_config') c;""")[0] - metrics_config_params = plpy.execute("""select c.sentinel_master_id, c.redis_host, - c.redis_port, c.timeout, c.redis_db - from cdb_dataservices_server._get_redis_conf_v2('redis_metrics_config') c;""")[0] - redis_metadata_connection = RedisConnection(metadata_config_params['sentinel_master_id'], - metadata_config_params['redis_host'], - metadata_config_params['redis_port'], - timeout=metadata_config_params['timeout'], - redis_db=metadata_config_params['redis_db']).redis_connection() - redis_metrics_connection = RedisConnection(metrics_config_params['sentinel_master_id'], - metrics_config_params['redis_host'], - metrics_config_params['redis_port'], - timeout=metrics_config_params['timeout'], - redis_db=metrics_config_params['redis_db']).redis_connection() - GD[cache_key] = { - 'redis_metadata_connection': redis_metadata_connection, - 'redis_metrics_connection': redis_metrics_connection, - } - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.5.0/15_config_helper.sql b/server/extension/sql/0.5.0/15_config_helper.sql deleted file mode 100644 index b70d63a..0000000 --- a/server/extension/sql/0.5.0/15_config_helper.sql +++ /dev/null @@ -1,75 +0,0 @@ --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_geocoder_config(username text, orgname text) -RETURNS boolean AS $$ - cache_key = "user_geocoder_config_{0}".format(username) - if cache_key in GD: - return False - else: - import json - from cartodb_services.metrics import GeocoderConfig - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] - heremaps_conf_json = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('heremaps_conf') as heremaps_conf", 1)[0]['heremaps_conf'] - if not heremaps_conf_json: - heremaps_app_id = None - heremaps_app_code = None - else: - heremaps_conf = json.loads(heremaps_conf_json) - heremaps_app_id = heremaps_conf['app_id'] - heremaps_app_code = heremaps_conf['app_code'] - geocoder_config = GeocoderConfig(redis_conn, username, orgname, heremaps_app_id, heremaps_app_code) - # --Think about the security concerns with this kind of global cache, it should be only available - # --for this user session but... - GD[cache_key] = geocoder_config - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; - --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_isolines_routing_config(username text, orgname text) -RETURNS boolean AS $$ - cache_key = "user_isolines_routing_config_{0}".format(username) - if cache_key in GD: - return False - else: - import json - from cartodb_services.metrics import IsolinesRoutingConfig - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] - heremaps_conf_json = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('heremaps_conf') as heremaps_conf", 1)[0]['heremaps_conf'] - if not heremaps_conf_json: - heremaps_app_id = None - heremaps_app_code = None - else: - heremaps_conf = json.loads(heremaps_conf_json) - heremaps_app_id = heremaps_conf['app_id'] - heremaps_app_code = heremaps_conf['app_code'] - isolines_routing_config = IsolinesRoutingConfig(redis_conn, username, orgname, heremaps_app_id, heremaps_app_code) - # --Think about the security concerns with this kind of global cache, it should be only available - # --for this user session but... - GD[cache_key] = isolines_routing_config - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; - --- Get the Redis configuration from the _conf table -- -CREATE OR REPLACE FUNCTION cdb_dataservices_server._get_routing_config(username text, orgname text) -RETURNS boolean AS $$ - cache_key = "user_routing_config_{0}".format(username) - if cache_key in GD: - return False - else: - import json - from cartodb_services.metrics import RoutingConfig - plpy.execute("SELECT cdb_dataservices_server._connect_to_redis('{0}')".format(username)) - redis_conn = GD["redis_connection_{0}".format(username)]['redis_metadata_connection'] - mapzen_conf_json = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('mapzen_conf') as mapzen_conf", 1)[0]['mapzen_conf'] - if not mapzen_conf_json: - mapzen_app_key = None - else: - mapzen_conf = json.loads(mapzen_conf_json) - mapzen_app_key = mapzen_conf['routing_app_key'] - routing_config = RoutingConfig(redis_conn, username, orgname, mapzen_app_key) - # --Think about the security concerns with this kind of global cache, it should be only available - # --for this user session but... - GD[cache_key] = routing_config - return True -$$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.5.0/20_geocode_street.sql b/server/extension/sql/0.5.0/20_geocode_street.sql deleted file mode 120000 index 30ce5a4..0000000 --- a/server/extension/sql/0.5.0/20_geocode_street.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/20_geocode_street.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.0/30_admin0.sql b/server/extension/sql/0.5.0/30_admin0.sql deleted file mode 120000 index 5b199e6..0000000 --- a/server/extension/sql/0.5.0/30_admin0.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/30_admin0.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.0/40_admin1.sql b/server/extension/sql/0.5.0/40_admin1.sql deleted file mode 120000 index 40dbd30..0000000 --- a/server/extension/sql/0.5.0/40_admin1.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/40_admin1.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.0/50_namedplaces.sql b/server/extension/sql/0.5.0/50_namedplaces.sql deleted file mode 120000 index eb4d63f..0000000 --- a/server/extension/sql/0.5.0/50_namedplaces.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/50_namedplaces.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.0/60_postalcodes.sql b/server/extension/sql/0.5.0/60_postalcodes.sql deleted file mode 120000 index 176dd6c..0000000 --- a/server/extension/sql/0.5.0/60_postalcodes.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/60_postalcodes.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.0/70_ips.sql b/server/extension/sql/0.5.0/70_ips.sql deleted file mode 120000 index f96f249..0000000 --- a/server/extension/sql/0.5.0/70_ips.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/70_ips.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.0/80_isolines_helper.sql b/server/extension/sql/0.5.0/80_isolines_helper.sql deleted file mode 120000 index b665362..0000000 --- a/server/extension/sql/0.5.0/80_isolines_helper.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/80_isolines_helper.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.0/85_isodistance.sql b/server/extension/sql/0.5.0/85_isodistance.sql deleted file mode 120000 index 3b2e4dc..0000000 --- a/server/extension/sql/0.5.0/85_isodistance.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/85_isodistance.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.0/90_isochrone.sql b/server/extension/sql/0.5.0/90_isochrone.sql deleted file mode 120000 index 59276d2..0000000 --- a/server/extension/sql/0.5.0/90_isochrone.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/90_isochrone.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.1/00_header.sql b/server/extension/sql/0.5.1/00_header.sql deleted file mode 120000 index 6d12de2..0000000 --- a/server/extension/sql/0.5.1/00_header.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/00_header.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.1/105_route_point_to_point.sql b/server/extension/sql/0.5.1/105_route_point_to_point.sql deleted file mode 120000 index 049f5df..0000000 --- a/server/extension/sql/0.5.1/105_route_point_to_point.sql +++ /dev/null @@ -1 +0,0 @@ -../0.5.0/105_route_point_to_point.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.1/85_isodistance.sql b/server/extension/sql/0.5.1/85_isodistance.sql deleted file mode 120000 index 3b2e4dc..0000000 --- a/server/extension/sql/0.5.1/85_isodistance.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/85_isodistance.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.1/90_isochrone.sql b/server/extension/sql/0.5.1/90_isochrone.sql deleted file mode 120000 index 59276d2..0000000 --- a/server/extension/sql/0.5.1/90_isochrone.sql +++ /dev/null @@ -1 +0,0 @@ -../0.4.0/90_isochrone.sql \ No newline at end of file diff --git a/server/extension/sql/0.5.1/999_geocoder_server_user.sql b/server/extension/sql/0.5.1/999_geocoder_server_user.sql deleted file mode 120000 index 916112a..0000000 --- a/server/extension/sql/0.5.1/999_geocoder_server_user.sql +++ /dev/null @@ -1 +0,0 @@ -../0.5.0/999_geocoder_server_user.sql \ No newline at end of file diff --git a/server/extension/sql/0.0.1/00_header.sql b/server/extension/sql/00_header.sql similarity index 100% rename from server/extension/sql/0.0.1/00_header.sql rename to server/extension/sql/00_header.sql diff --git a/server/extension/sql/0.5.0/100_routing_helper.sql b/server/extension/sql/100_routing_helper.sql similarity index 75% rename from server/extension/sql/0.5.0/100_routing_helper.sql rename to server/extension/sql/100_routing_helper.sql index e23a1c5..6e561ba 100644 --- a/server/extension/sql/0.5.0/100_routing_helper.sql +++ b/server/extension/sql/100_routing_helper.sql @@ -28,6 +28,11 @@ RETURNS cdb_dataservices_server.simple_route AS $$ try: client = MapzenRouting(user_routing_config.mapzen_app_key) + if not origin or not destination: + plpy.notice("Empty origin or destination") + quota_service.increment_empty_service_use() + return [None, None, None] + orig_lat = plpy.execute("SELECT ST_Y('%s') AS lat" % origin)[0]['lat'] orig_lon = plpy.execute("SELECT ST_X('%s') AS lon" % origin)[0]['lon'] origin_coordinates = Coordinate(orig_lon, orig_lat) @@ -37,19 +42,24 @@ RETURNS cdb_dataservices_server.simple_route AS $$ resp = client.calculate_route_point_to_point(origin_coordinates, dest_coordinates, mode, options, units) - if resp: + if resp and resp.shape: shape_linestring = polyline_to_linestring(resp.shape) - quota_service.increment_success_geocoder_use() - return [shape_linestring, resp.length, resp.duration] + if shape_linestring: + quota_service.increment_success_service_use() + return [shape_linestring, resp.length, resp.duration] + else: + quota_service.increment_empty_service_use() + return [None, None, None] else: - quota_service.increment_empty_geocoder_use() + quota_service.increment_empty_service_use() + return [None, None, None] except BaseException as e: import sys, traceback type_, value_, traceback_ = sys.exc_info() - quota_service.increment_failed_geocoder_use() + quota_service.increment_failed_service_use() error_msg = 'There was an error trying to obtain route using mapzen provider: {0}'.format(e) plpy.notice(traceback.format_tb(traceback_)) plpy.error(error_msg) finally: - quota_service.increment_total_geocoder_use() + quota_service.increment_total_service_use() $$ LANGUAGE plpythonu SECURITY DEFINER; diff --git a/server/extension/sql/0.5.0/105_route_point_to_point.sql b/server/extension/sql/105_route_point_to_point.sql similarity index 100% rename from server/extension/sql/0.5.0/105_route_point_to_point.sql rename to server/extension/sql/105_route_point_to_point.sql diff --git a/server/extension/sql/0.5.1/10_redis_helper.sql b/server/extension/sql/10_redis_helper.sql similarity index 100% rename from server/extension/sql/0.5.1/10_redis_helper.sql rename to server/extension/sql/10_redis_helper.sql diff --git a/server/extension/sql/0.5.1/15_config_helper.sql b/server/extension/sql/15_config_helper.sql similarity index 100% rename from server/extension/sql/0.5.1/15_config_helper.sql rename to server/extension/sql/15_config_helper.sql diff --git a/server/extension/sql/0.5.1/20_geocode_street.sql b/server/extension/sql/20_geocode_street.sql similarity index 100% rename from server/extension/sql/0.5.1/20_geocode_street.sql rename to server/extension/sql/20_geocode_street.sql diff --git a/server/extension/sql/0.5.1/30_admin0.sql b/server/extension/sql/30_admin0.sql similarity index 100% rename from server/extension/sql/0.5.1/30_admin0.sql rename to server/extension/sql/30_admin0.sql diff --git a/server/extension/sql/0.5.1/40_admin1.sql b/server/extension/sql/40_admin1.sql similarity index 100% rename from server/extension/sql/0.5.1/40_admin1.sql rename to server/extension/sql/40_admin1.sql diff --git a/server/extension/sql/0.5.1/50_namedplaces.sql b/server/extension/sql/50_namedplaces.sql similarity index 100% rename from server/extension/sql/0.5.1/50_namedplaces.sql rename to server/extension/sql/50_namedplaces.sql diff --git a/server/extension/sql/0.5.1/60_postalcodes.sql b/server/extension/sql/60_postalcodes.sql similarity index 100% rename from server/extension/sql/0.5.1/60_postalcodes.sql rename to server/extension/sql/60_postalcodes.sql diff --git a/server/extension/sql/0.5.1/70_ips.sql b/server/extension/sql/70_ips.sql similarity index 100% rename from server/extension/sql/0.5.1/70_ips.sql rename to server/extension/sql/70_ips.sql diff --git a/server/extension/sql/0.5.1/80_isolines_helper.sql b/server/extension/sql/80_isolines_helper.sql similarity index 100% rename from server/extension/sql/0.5.1/80_isolines_helper.sql rename to server/extension/sql/80_isolines_helper.sql diff --git a/server/extension/sql/0.4.0/85_isodistance.sql b/server/extension/sql/85_isodistance.sql similarity index 100% rename from server/extension/sql/0.4.0/85_isodistance.sql rename to server/extension/sql/85_isodistance.sql diff --git a/server/extension/sql/0.4.0/90_isochrone.sql b/server/extension/sql/90_isochrone.sql similarity index 100% rename from server/extension/sql/0.4.0/90_isochrone.sql rename to server/extension/sql/90_isochrone.sql diff --git a/server/extension/sql/0.5.0/999_geocoder_server_user.sql b/server/extension/sql/999_geocoder_server_user.sql similarity index 100% rename from server/extension/sql/0.5.0/999_geocoder_server_user.sql rename to server/extension/sql/999_geocoder_server_user.sql diff --git a/server/extension/test/0.0.1/expected/00_install_test.out b/server/extension/test/0.0.1/expected/00_install_test.out deleted file mode 100644 index 63e6c5d..0000000 --- a/server/extension/test/0.0.1/expected/00_install_test.out +++ /dev/null @@ -1,30 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; --- Install the extension -CREATE EXTENSION cdb_dataservices_server; --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_conf', '{"sentinel_host": "localhost", "sentinel_port": 26739, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - cdb_conf_setconf ------------------- - -(1 row) - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); - cdb_setuserquotainbytes -------------------------- - 0 -(1 row) - diff --git a/server/extension/test/0.0.1/expected/90_remove_geocoder_api_user_test.out b/server/extension/test/0.0.1/expected/90_remove_geocoder_api_user_test.out deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.0.1/expected/90_remove_geocoder_api_user_test.out +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.0.1/sql/00_install_test.sql b/server/extension/test/0.0.1/sql/00_install_test.sql deleted file mode 100644 index 2e1ee42..0000000 --- a/server/extension/test/0.0.1/sql/00_install_test.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; - --- Install the extension -CREATE EXTENSION cdb_dataservices_server; - --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_conf', '{"sentinel_host": "localhost", "sentinel_port": 26739, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; - --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); diff --git a/server/extension/test/0.0.1/sql/90_remove_geocoder_api_user_test.sql b/server/extension/test/0.0.1/sql/90_remove_geocoder_api_user_test.sql deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.0.1/sql/90_remove_geocoder_api_user_test.sql +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.1.0/expected/00_install_test.out b/server/extension/test/0.1.0/expected/00_install_test.out deleted file mode 100644 index 63e6c5d..0000000 --- a/server/extension/test/0.1.0/expected/00_install_test.out +++ /dev/null @@ -1,30 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; --- Install the extension -CREATE EXTENSION cdb_dataservices_server; --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_conf', '{"sentinel_host": "localhost", "sentinel_port": 26739, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - cdb_conf_setconf ------------------- - -(1 row) - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); - cdb_setuserquotainbytes -------------------------- - 0 -(1 row) - diff --git a/server/extension/test/0.1.0/expected/30_admin0_test.out b/server/extension/test/0.1.0/expected/30_admin0_test.out deleted file mode 100644 index 55c7639..0000000 --- a/server/extension/test/0.1.0/expected/30_admin0_test.out +++ /dev/null @@ -1,47 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - cdb_geocode_admin0_polygon ----------------------------- - -(1 row) - --- Insert some dummy synonym -INSERT INTO admin0_synonyms (name, adm0_a3) VALUES ('Spain', 'ESP'); --- Insert some dummy geometry to return -INSERT INTO ne_admin0_v3 (adm0_a3, the_geom) VALUES('ESP', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - cdb_geocode_admin0_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - --- Check for admin0 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.1.0/expected/40_admin1_test.out b/server/extension/test/0.1.0/expected/40_admin1_test.out deleted file mode 100644 index 4894b0c..0000000 --- a/server/extension/test/0.1.0/expected/40_admin1_test.out +++ /dev/null @@ -1,81 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); - cdb_geocode_admin1_polygon ----------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - cdb_geocode_admin1_polygon ----------------------------- - -(1 row) - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso3) VALUES (Array['united states'], 'USA'); --- Insert some dummy data and geometry to return -INSERT INTO global_province_polygons (synonyms, iso3, the_geom) VALUES (Array['california'], 'USA', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); - cdb_geocode_admin1_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - cdb_geocode_admin1_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - --- Check for admin1 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.1.0/expected/50_namedplaces_test.out b/server/extension/test/0.1.0/expected/50_namedplaces_test.out deleted file mode 100644 index 7755bf4..0000000 --- a/server/extension/test/0.1.0/expected/50_namedplaces_test.out +++ /dev/null @@ -1,136 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - --- Insert dummy data into points table -INSERT INTO global_cities_points_limited (geoname_id, name, iso2, admin1, admin2, population, lowername, the_geom) VALUES (3128760, 'Elche', 'ES', 'Valencia', 'AL', 34534, 'elche', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); --- Insert dummy data into alternates table -INSERT INTO global_cities_alternates_limited (geoname_id, name, preferred, lowername, admin1_geonameid, iso2, admin1, the_geom) VALUES (3128760, 'Elx', true, 'elx', '000000', 'ES', 'Valencia', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso2) VALUES (Array['spain'], 'ES'); --- Insert dummy data into admin1 decoder table -INSERT INTO admin1_decoder (admin1, synonyms, iso2) VALUES ('Valencia', Array['valencia', 'Valencia'], 'ES'); --- This should return the point inserted above -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'valencia', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.1.0/expected/60_postalcodes_test.out b/server/extension/test/0.1.0/expected/60_postalcodes_test.out deleted file mode 100644 index b2a5c91..0000000 --- a/server/extension/test/0.1.0/expected/60_postalcodes_test.out +++ /dev/null @@ -1,163 +0,0 @@ --- Make sure dbs are clean -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_point ------------------------------- - -(1 row) - --- Insert dummy data into ip_address_locations -INSERT INTO global_postal_code_points (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0101000020E61000000000000000E040408036B47414764840', - 'ESP', - '03204', - 3204 -); -INSERT INTO global_postal_code_polygons (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040', - 'ESP', - '03204', - 3204 -); -INSERT INTO country_decoder (iso3, synonyms) VALUES ( - 'ESP', - Array['spain', 'Spain', 'ESP'] -); -INSERT INTO available_services (adm0_a3, admin0, postal_code_points, postal_code_polygons) VALUES ( - 'ESP', - 't', - 't', - 't' -); -INSERT INTO admin0_synonyms (adm0_a3, name, name_, rank) VALUES ( - 'ESP', - 'Spain', - 'spain', - 3 -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_point ----------------------------------------------------- - 0101000020E61000000000000000E040408036B47414764840 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204', 'spain'); - cdb_geocode_postalcode_point ----------------------------------------------------- - 0101000020E61000000000000000E040408036B47414764840 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204', 'spain'); - cdb_geocode_postalcode_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040 -(1 row) - --- Clean dbs -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.1.0/expected/70_ips_test.out b/server/extension/test/0.1.0/expected/70_ips_test.out deleted file mode 100644 index 48012f7..0000000 --- a/server/extension/test/0.1.0/expected/70_ips_test.out +++ /dev/null @@ -1,40 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - cdb_geocode_ipaddress_point ------------------------------ - -(1 row) - --- Insert dummy data into ip_address_locations -INSERT INTO ip_address_locations VALUES ('::ffff:0.0.0.0'::inet, (ST_SetSRID(ST_MakePoint('40.40', '3.71'), 4326))); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - cdb_geocode_ipaddress_point ----------------------------------------------------- - 0101000020E61000003333333333334440AE47E17A14AE0D40 -(1 row) - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.1.0/expected/90_remove_geocoder_api_user_test.out b/server/extension/test/0.1.0/expected/90_remove_geocoder_api_user_test.out deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.1.0/expected/90_remove_geocoder_api_user_test.out +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.1.0/sql/00_install_test.sql b/server/extension/test/0.1.0/sql/00_install_test.sql deleted file mode 100644 index 2e1ee42..0000000 --- a/server/extension/test/0.1.0/sql/00_install_test.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; - --- Install the extension -CREATE EXTENSION cdb_dataservices_server; - --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_conf', '{"sentinel_host": "localhost", "sentinel_port": 26739, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; - --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); diff --git a/server/extension/test/0.1.0/sql/30_admin0_test.sql b/server/extension/test/0.1.0/sql/30_admin0_test.sql deleted file mode 100644 index 3249c60..0000000 --- a/server/extension/test/0.1.0/sql/30_admin0_test.sql +++ /dev/null @@ -1,32 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - --- Insert some dummy synonym -INSERT INTO admin0_synonyms (name, adm0_a3) VALUES ('Spain', 'ESP'); - --- Insert some dummy geometry to return -INSERT INTO ne_admin0_v3 (adm0_a3, the_geom) VALUES('ESP', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - --- Check for admin0 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); diff --git a/server/extension/test/0.1.0/sql/40_admin1_test.sql b/server/extension/test/0.1.0/sql/40_admin1_test.sql deleted file mode 100644 index 7b3748c..0000000 --- a/server/extension/test/0.1.0/sql/40_admin1_test.sql +++ /dev/null @@ -1,48 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso3) VALUES (Array['united states'], 'USA'); - --- Insert some dummy data and geometry to return -INSERT INTO global_province_polygons (synonyms, iso3, the_geom) VALUES (Array['california'], 'USA', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - --- Check for admin1 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); diff --git a/server/extension/test/0.1.0/sql/50_namedplaces_test.sql b/server/extension/test/0.1.0/sql/50_namedplaces_test.sql deleted file mode 100644 index 306a682..0000000 --- a/server/extension/test/0.1.0/sql/50_namedplaces_test.sql +++ /dev/null @@ -1,72 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - --- Insert dummy data into points table -INSERT INTO global_cities_points_limited (geoname_id, name, iso2, admin1, admin2, population, lowername, the_geom) VALUES (3128760, 'Elche', 'ES', 'Valencia', 'AL', 34534, 'elche', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); - --- Insert dummy data into alternates table -INSERT INTO global_cities_alternates_limited (geoname_id, name, preferred, lowername, admin1_geonameid, iso2, admin1, the_geom) VALUES (3128760, 'Elx', true, 'elx', '000000', 'ES', 'Valencia', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso2) VALUES (Array['spain'], 'ES'); - --- Insert dummy data into admin1 decoder table -INSERT INTO admin1_decoder (admin1, synonyms, iso2) VALUES ('Valencia', Array['valencia', 'Valencia'], 'ES'); - --- This should return the point inserted above -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'valencia', 'Spain'); - --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); diff --git a/server/extension/test/0.1.0/sql/60_postalcodes_test.sql b/server/extension/test/0.1.0/sql/60_postalcodes_test.sql deleted file mode 100644 index 55d1c85..0000000 --- a/server/extension/test/0.1.0/sql/60_postalcodes_test.sql +++ /dev/null @@ -1,117 +0,0 @@ --- Make sure dbs are clean -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; - --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - --- Insert dummy data into ip_address_locations -INSERT INTO global_postal_code_points (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0101000020E61000000000000000E040408036B47414764840', - 'ESP', - '03204', - 3204 -); - -INSERT INTO global_postal_code_polygons (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040', - 'ESP', - '03204', - 3204 -); - -INSERT INTO country_decoder (iso3, synonyms) VALUES ( - 'ESP', - Array['spain', 'Spain', 'ESP'] -); - -INSERT INTO available_services (adm0_a3, admin0, postal_code_points, postal_code_polygons) VALUES ( - 'ESP', - 't', - 't', - 't' -); - -INSERT INTO admin0_synonyms (adm0_a3, name, name_, rank) VALUES ( - 'ESP', - 'Spain', - 'spain', - 3 -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204', 'spain'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204', 'spain'); - --- Clean dbs -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); diff --git a/server/extension/test/0.1.0/sql/70_ips_test.sql b/server/extension/test/0.1.0/sql/70_ips_test.sql deleted file mode 100644 index 6111bd0..0000000 --- a/server/extension/test/0.1.0/sql/70_ips_test.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - --- Insert dummy data into ip_address_locations -INSERT INTO ip_address_locations VALUES ('::ffff:0.0.0.0'::inet, (ST_SetSRID(ST_MakePoint('40.40', '3.71'), 4326))); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text'); diff --git a/server/extension/test/0.1.0/sql/90_remove_geocoder_api_user_test.sql b/server/extension/test/0.1.0/sql/90_remove_geocoder_api_user_test.sql deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.1.0/sql/90_remove_geocoder_api_user_test.sql +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.2.0/expected/00_install_test.out b/server/extension/test/0.2.0/expected/00_install_test.out deleted file mode 100644 index 63e6c5d..0000000 --- a/server/extension/test/0.2.0/expected/00_install_test.out +++ /dev/null @@ -1,30 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; --- Install the extension -CREATE EXTENSION cdb_dataservices_server; --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_conf', '{"sentinel_host": "localhost", "sentinel_port": 26739, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - cdb_conf_setconf ------------------- - -(1 row) - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); - cdb_setuserquotainbytes -------------------------- - 0 -(1 row) - diff --git a/server/extension/test/0.2.0/expected/20_street_test.out b/server/extension/test/0.2.0/expected/20_street_test.out deleted file mode 100644 index 8fbce7a..0000000 --- a/server/extension/test/0.2.0/expected/20_street_test.out +++ /dev/null @@ -1,12 +0,0 @@ --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_street_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text, text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.2.0/expected/30_admin0_test.out b/server/extension/test/0.2.0/expected/30_admin0_test.out deleted file mode 100644 index 55c7639..0000000 --- a/server/extension/test/0.2.0/expected/30_admin0_test.out +++ /dev/null @@ -1,47 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - cdb_geocode_admin0_polygon ----------------------------- - -(1 row) - --- Insert some dummy synonym -INSERT INTO admin0_synonyms (name, adm0_a3) VALUES ('Spain', 'ESP'); --- Insert some dummy geometry to return -INSERT INTO ne_admin0_v3 (adm0_a3, the_geom) VALUES('ESP', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - cdb_geocode_admin0_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - --- Check for admin0 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.2.0/expected/40_admin1_test.out b/server/extension/test/0.2.0/expected/40_admin1_test.out deleted file mode 100644 index 4894b0c..0000000 --- a/server/extension/test/0.2.0/expected/40_admin1_test.out +++ /dev/null @@ -1,81 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); - cdb_geocode_admin1_polygon ----------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - cdb_geocode_admin1_polygon ----------------------------- - -(1 row) - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso3) VALUES (Array['united states'], 'USA'); --- Insert some dummy data and geometry to return -INSERT INTO global_province_polygons (synonyms, iso3, the_geom) VALUES (Array['california'], 'USA', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); - cdb_geocode_admin1_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - cdb_geocode_admin1_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - --- Check for admin1 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.2.0/expected/50_namedplaces_test.out b/server/extension/test/0.2.0/expected/50_namedplaces_test.out deleted file mode 100644 index 7755bf4..0000000 --- a/server/extension/test/0.2.0/expected/50_namedplaces_test.out +++ /dev/null @@ -1,136 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - --- Insert dummy data into points table -INSERT INTO global_cities_points_limited (geoname_id, name, iso2, admin1, admin2, population, lowername, the_geom) VALUES (3128760, 'Elche', 'ES', 'Valencia', 'AL', 34534, 'elche', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); --- Insert dummy data into alternates table -INSERT INTO global_cities_alternates_limited (geoname_id, name, preferred, lowername, admin1_geonameid, iso2, admin1, the_geom) VALUES (3128760, 'Elx', true, 'elx', '000000', 'ES', 'Valencia', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso2) VALUES (Array['spain'], 'ES'); --- Insert dummy data into admin1 decoder table -INSERT INTO admin1_decoder (admin1, synonyms, iso2) VALUES ('Valencia', Array['valencia', 'Valencia'], 'ES'); --- This should return the point inserted above -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'valencia', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.2.0/expected/60_postalcodes_test.out b/server/extension/test/0.2.0/expected/60_postalcodes_test.out deleted file mode 100644 index b2a5c91..0000000 --- a/server/extension/test/0.2.0/expected/60_postalcodes_test.out +++ /dev/null @@ -1,163 +0,0 @@ --- Make sure dbs are clean -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_point ------------------------------- - -(1 row) - --- Insert dummy data into ip_address_locations -INSERT INTO global_postal_code_points (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0101000020E61000000000000000E040408036B47414764840', - 'ESP', - '03204', - 3204 -); -INSERT INTO global_postal_code_polygons (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040', - 'ESP', - '03204', - 3204 -); -INSERT INTO country_decoder (iso3, synonyms) VALUES ( - 'ESP', - Array['spain', 'Spain', 'ESP'] -); -INSERT INTO available_services (adm0_a3, admin0, postal_code_points, postal_code_polygons) VALUES ( - 'ESP', - 't', - 't', - 't' -); -INSERT INTO admin0_synonyms (adm0_a3, name, name_, rank) VALUES ( - 'ESP', - 'Spain', - 'spain', - 3 -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_point ----------------------------------------------------- - 0101000020E61000000000000000E040408036B47414764840 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204', 'spain'); - cdb_geocode_postalcode_point ----------------------------------------------------- - 0101000020E61000000000000000E040408036B47414764840 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204', 'spain'); - cdb_geocode_postalcode_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040 -(1 row) - --- Clean dbs -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.2.0/expected/70_ips_test.out b/server/extension/test/0.2.0/expected/70_ips_test.out deleted file mode 100644 index 48012f7..0000000 --- a/server/extension/test/0.2.0/expected/70_ips_test.out +++ /dev/null @@ -1,40 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - cdb_geocode_ipaddress_point ------------------------------ - -(1 row) - --- Insert dummy data into ip_address_locations -INSERT INTO ip_address_locations VALUES ('::ffff:0.0.0.0'::inet, (ST_SetSRID(ST_MakePoint('40.40', '3.71'), 4326))); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - cdb_geocode_ipaddress_point ----------------------------------------------------- - 0101000020E61000003333333333334440AE47E17A14AE0D40 -(1 row) - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.2.0/expected/90_remove_geocoder_api_user_test.out b/server/extension/test/0.2.0/expected/90_remove_geocoder_api_user_test.out deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.2.0/expected/90_remove_geocoder_api_user_test.out +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.2.0/sql/00_install_test.sql b/server/extension/test/0.2.0/sql/00_install_test.sql deleted file mode 100644 index 2e1ee42..0000000 --- a/server/extension/test/0.2.0/sql/00_install_test.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; - --- Install the extension -CREATE EXTENSION cdb_dataservices_server; - --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_conf', '{"sentinel_host": "localhost", "sentinel_port": 26739, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; - --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); diff --git a/server/extension/test/0.2.0/sql/20_street_test.sql b/server/extension/test/0.2.0/sql/20_street_test.sql deleted file mode 100644 index 86e0368..0000000 --- a/server/extension/test/0.2.0/sql/20_street_test.sql +++ /dev/null @@ -1,7 +0,0 @@ --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_street_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text, text, text'); diff --git a/server/extension/test/0.2.0/sql/30_admin0_test.sql b/server/extension/test/0.2.0/sql/30_admin0_test.sql deleted file mode 100644 index 3249c60..0000000 --- a/server/extension/test/0.2.0/sql/30_admin0_test.sql +++ /dev/null @@ -1,32 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - --- Insert some dummy synonym -INSERT INTO admin0_synonyms (name, adm0_a3) VALUES ('Spain', 'ESP'); - --- Insert some dummy geometry to return -INSERT INTO ne_admin0_v3 (adm0_a3, the_geom) VALUES('ESP', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - --- Check for admin0 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); diff --git a/server/extension/test/0.2.0/sql/40_admin1_test.sql b/server/extension/test/0.2.0/sql/40_admin1_test.sql deleted file mode 100644 index 7b3748c..0000000 --- a/server/extension/test/0.2.0/sql/40_admin1_test.sql +++ /dev/null @@ -1,48 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso3) VALUES (Array['united states'], 'USA'); - --- Insert some dummy data and geometry to return -INSERT INTO global_province_polygons (synonyms, iso3, the_geom) VALUES (Array['california'], 'USA', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - --- Check for admin1 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); diff --git a/server/extension/test/0.2.0/sql/50_namedplaces_test.sql b/server/extension/test/0.2.0/sql/50_namedplaces_test.sql deleted file mode 100644 index 306a682..0000000 --- a/server/extension/test/0.2.0/sql/50_namedplaces_test.sql +++ /dev/null @@ -1,72 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - --- Insert dummy data into points table -INSERT INTO global_cities_points_limited (geoname_id, name, iso2, admin1, admin2, population, lowername, the_geom) VALUES (3128760, 'Elche', 'ES', 'Valencia', 'AL', 34534, 'elche', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); - --- Insert dummy data into alternates table -INSERT INTO global_cities_alternates_limited (geoname_id, name, preferred, lowername, admin1_geonameid, iso2, admin1, the_geom) VALUES (3128760, 'Elx', true, 'elx', '000000', 'ES', 'Valencia', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso2) VALUES (Array['spain'], 'ES'); - --- Insert dummy data into admin1 decoder table -INSERT INTO admin1_decoder (admin1, synonyms, iso2) VALUES ('Valencia', Array['valencia', 'Valencia'], 'ES'); - --- This should return the point inserted above -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'valencia', 'Spain'); - --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); diff --git a/server/extension/test/0.2.0/sql/60_postalcodes_test.sql b/server/extension/test/0.2.0/sql/60_postalcodes_test.sql deleted file mode 100644 index 55d1c85..0000000 --- a/server/extension/test/0.2.0/sql/60_postalcodes_test.sql +++ /dev/null @@ -1,117 +0,0 @@ --- Make sure dbs are clean -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; - --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - --- Insert dummy data into ip_address_locations -INSERT INTO global_postal_code_points (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0101000020E61000000000000000E040408036B47414764840', - 'ESP', - '03204', - 3204 -); - -INSERT INTO global_postal_code_polygons (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040', - 'ESP', - '03204', - 3204 -); - -INSERT INTO country_decoder (iso3, synonyms) VALUES ( - 'ESP', - Array['spain', 'Spain', 'ESP'] -); - -INSERT INTO available_services (adm0_a3, admin0, postal_code_points, postal_code_polygons) VALUES ( - 'ESP', - 't', - 't', - 't' -); - -INSERT INTO admin0_synonyms (adm0_a3, name, name_, rank) VALUES ( - 'ESP', - 'Spain', - 'spain', - 3 -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204', 'spain'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204', 'spain'); - --- Clean dbs -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); diff --git a/server/extension/test/0.2.0/sql/70_ips_test.sql b/server/extension/test/0.2.0/sql/70_ips_test.sql deleted file mode 100644 index 6111bd0..0000000 --- a/server/extension/test/0.2.0/sql/70_ips_test.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - --- Insert dummy data into ip_address_locations -INSERT INTO ip_address_locations VALUES ('::ffff:0.0.0.0'::inet, (ST_SetSRID(ST_MakePoint('40.40', '3.71'), 4326))); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text'); diff --git a/server/extension/test/0.2.0/sql/90_remove_geocoder_api_user_test.sql b/server/extension/test/0.2.0/sql/90_remove_geocoder_api_user_test.sql deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.2.0/sql/90_remove_geocoder_api_user_test.sql +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.3.0/expected/00_install_test.out b/server/extension/test/0.3.0/expected/00_install_test.out deleted file mode 100644 index db041d0..0000000 --- a/server/extension/test/0.3.0/expected/00_install_test.out +++ /dev/null @@ -1,36 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; --- Install the extension -CREATE EXTENSION cdb_dataservices_server; --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_metrics_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - cdb_conf_setconf ------------------- - -(1 row) - -SELECT cartodb.cdb_conf_setconf('redis_metadata_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - cdb_conf_setconf ------------------- - -(1 row) - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); - cdb_setuserquotainbytes -------------------------- - 0 -(1 row) - diff --git a/server/extension/test/0.3.0/expected/20_street_test.out b/server/extension/test/0.3.0/expected/20_street_test.out deleted file mode 100644 index 8fbce7a..0000000 --- a/server/extension/test/0.3.0/expected/20_street_test.out +++ /dev/null @@ -1,12 +0,0 @@ --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_street_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text, text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.3.0/expected/30_admin0_test.out b/server/extension/test/0.3.0/expected/30_admin0_test.out deleted file mode 100644 index 55c7639..0000000 --- a/server/extension/test/0.3.0/expected/30_admin0_test.out +++ /dev/null @@ -1,47 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - cdb_geocode_admin0_polygon ----------------------------- - -(1 row) - --- Insert some dummy synonym -INSERT INTO admin0_synonyms (name, adm0_a3) VALUES ('Spain', 'ESP'); --- Insert some dummy geometry to return -INSERT INTO ne_admin0_v3 (adm0_a3, the_geom) VALUES('ESP', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - cdb_geocode_admin0_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - --- Check for admin0 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.3.0/expected/40_admin1_test.out b/server/extension/test/0.3.0/expected/40_admin1_test.out deleted file mode 100644 index 4894b0c..0000000 --- a/server/extension/test/0.3.0/expected/40_admin1_test.out +++ /dev/null @@ -1,81 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); - cdb_geocode_admin1_polygon ----------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - cdb_geocode_admin1_polygon ----------------------------- - -(1 row) - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso3) VALUES (Array['united states'], 'USA'); --- Insert some dummy data and geometry to return -INSERT INTO global_province_polygons (synonyms, iso3, the_geom) VALUES (Array['california'], 'USA', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); - cdb_geocode_admin1_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - cdb_geocode_admin1_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - --- Check for admin1 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.3.0/expected/50_namedplaces_test.out b/server/extension/test/0.3.0/expected/50_namedplaces_test.out deleted file mode 100644 index 7755bf4..0000000 --- a/server/extension/test/0.3.0/expected/50_namedplaces_test.out +++ /dev/null @@ -1,136 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - --- Insert dummy data into points table -INSERT INTO global_cities_points_limited (geoname_id, name, iso2, admin1, admin2, population, lowername, the_geom) VALUES (3128760, 'Elche', 'ES', 'Valencia', 'AL', 34534, 'elche', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); --- Insert dummy data into alternates table -INSERT INTO global_cities_alternates_limited (geoname_id, name, preferred, lowername, admin1_geonameid, iso2, admin1, the_geom) VALUES (3128760, 'Elx', true, 'elx', '000000', 'ES', 'Valencia', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso2) VALUES (Array['spain'], 'ES'); --- Insert dummy data into admin1 decoder table -INSERT INTO admin1_decoder (admin1, synonyms, iso2) VALUES ('Valencia', Array['valencia', 'Valencia'], 'ES'); --- This should return the point inserted above -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'valencia', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.3.0/expected/60_postalcodes_test.out b/server/extension/test/0.3.0/expected/60_postalcodes_test.out deleted file mode 100644 index b2a5c91..0000000 --- a/server/extension/test/0.3.0/expected/60_postalcodes_test.out +++ /dev/null @@ -1,163 +0,0 @@ --- Make sure dbs are clean -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_point ------------------------------- - -(1 row) - --- Insert dummy data into ip_address_locations -INSERT INTO global_postal_code_points (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0101000020E61000000000000000E040408036B47414764840', - 'ESP', - '03204', - 3204 -); -INSERT INTO global_postal_code_polygons (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040', - 'ESP', - '03204', - 3204 -); -INSERT INTO country_decoder (iso3, synonyms) VALUES ( - 'ESP', - Array['spain', 'Spain', 'ESP'] -); -INSERT INTO available_services (adm0_a3, admin0, postal_code_points, postal_code_polygons) VALUES ( - 'ESP', - 't', - 't', - 't' -); -INSERT INTO admin0_synonyms (adm0_a3, name, name_, rank) VALUES ( - 'ESP', - 'Spain', - 'spain', - 3 -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_point ----------------------------------------------------- - 0101000020E61000000000000000E040408036B47414764840 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204', 'spain'); - cdb_geocode_postalcode_point ----------------------------------------------------- - 0101000020E61000000000000000E040408036B47414764840 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204', 'spain'); - cdb_geocode_postalcode_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040 -(1 row) - --- Clean dbs -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.3.0/expected/70_ips_test.out b/server/extension/test/0.3.0/expected/70_ips_test.out deleted file mode 100644 index 48012f7..0000000 --- a/server/extension/test/0.3.0/expected/70_ips_test.out +++ /dev/null @@ -1,40 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - cdb_geocode_ipaddress_point ------------------------------ - -(1 row) - --- Insert dummy data into ip_address_locations -INSERT INTO ip_address_locations VALUES ('::ffff:0.0.0.0'::inet, (ST_SetSRID(ST_MakePoint('40.40', '3.71'), 4326))); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - cdb_geocode_ipaddress_point ----------------------------------------------------- - 0101000020E61000003333333333334440AE47E17A14AE0D40 -(1 row) - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.3.0/expected/90_remove_geocoder_api_user_test.out b/server/extension/test/0.3.0/expected/90_remove_geocoder_api_user_test.out deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.3.0/expected/90_remove_geocoder_api_user_test.out +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.3.0/sql/00_install_test.sql b/server/extension/test/0.3.0/sql/00_install_test.sql deleted file mode 100644 index da91608..0000000 --- a/server/extension/test/0.3.0/sql/00_install_test.sql +++ /dev/null @@ -1,25 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; - --- Install the extension -CREATE EXTENSION cdb_dataservices_server; - --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_metrics_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); -SELECT cartodb.cdb_conf_setconf('redis_metadata_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; - --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); diff --git a/server/extension/test/0.3.0/sql/20_street_test.sql b/server/extension/test/0.3.0/sql/20_street_test.sql deleted file mode 100644 index 86e0368..0000000 --- a/server/extension/test/0.3.0/sql/20_street_test.sql +++ /dev/null @@ -1,7 +0,0 @@ --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_street_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text, text, text'); diff --git a/server/extension/test/0.3.0/sql/30_admin0_test.sql b/server/extension/test/0.3.0/sql/30_admin0_test.sql deleted file mode 100644 index 3249c60..0000000 --- a/server/extension/test/0.3.0/sql/30_admin0_test.sql +++ /dev/null @@ -1,32 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - --- Insert some dummy synonym -INSERT INTO admin0_synonyms (name, adm0_a3) VALUES ('Spain', 'ESP'); - --- Insert some dummy geometry to return -INSERT INTO ne_admin0_v3 (adm0_a3, the_geom) VALUES('ESP', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - --- Check for admin0 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); diff --git a/server/extension/test/0.3.0/sql/40_admin1_test.sql b/server/extension/test/0.3.0/sql/40_admin1_test.sql deleted file mode 100644 index 7b3748c..0000000 --- a/server/extension/test/0.3.0/sql/40_admin1_test.sql +++ /dev/null @@ -1,48 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso3) VALUES (Array['united states'], 'USA'); - --- Insert some dummy data and geometry to return -INSERT INTO global_province_polygons (synonyms, iso3, the_geom) VALUES (Array['california'], 'USA', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - --- Check for admin1 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); diff --git a/server/extension/test/0.3.0/sql/50_namedplaces_test.sql b/server/extension/test/0.3.0/sql/50_namedplaces_test.sql deleted file mode 100644 index 306a682..0000000 --- a/server/extension/test/0.3.0/sql/50_namedplaces_test.sql +++ /dev/null @@ -1,72 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - --- Insert dummy data into points table -INSERT INTO global_cities_points_limited (geoname_id, name, iso2, admin1, admin2, population, lowername, the_geom) VALUES (3128760, 'Elche', 'ES', 'Valencia', 'AL', 34534, 'elche', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); - --- Insert dummy data into alternates table -INSERT INTO global_cities_alternates_limited (geoname_id, name, preferred, lowername, admin1_geonameid, iso2, admin1, the_geom) VALUES (3128760, 'Elx', true, 'elx', '000000', 'ES', 'Valencia', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso2) VALUES (Array['spain'], 'ES'); - --- Insert dummy data into admin1 decoder table -INSERT INTO admin1_decoder (admin1, synonyms, iso2) VALUES ('Valencia', Array['valencia', 'Valencia'], 'ES'); - --- This should return the point inserted above -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'valencia', 'Spain'); - --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); diff --git a/server/extension/test/0.3.0/sql/60_postalcodes_test.sql b/server/extension/test/0.3.0/sql/60_postalcodes_test.sql deleted file mode 100644 index 55d1c85..0000000 --- a/server/extension/test/0.3.0/sql/60_postalcodes_test.sql +++ /dev/null @@ -1,117 +0,0 @@ --- Make sure dbs are clean -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; - --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - --- Insert dummy data into ip_address_locations -INSERT INTO global_postal_code_points (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0101000020E61000000000000000E040408036B47414764840', - 'ESP', - '03204', - 3204 -); - -INSERT INTO global_postal_code_polygons (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040', - 'ESP', - '03204', - 3204 -); - -INSERT INTO country_decoder (iso3, synonyms) VALUES ( - 'ESP', - Array['spain', 'Spain', 'ESP'] -); - -INSERT INTO available_services (adm0_a3, admin0, postal_code_points, postal_code_polygons) VALUES ( - 'ESP', - 't', - 't', - 't' -); - -INSERT INTO admin0_synonyms (adm0_a3, name, name_, rank) VALUES ( - 'ESP', - 'Spain', - 'spain', - 3 -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204', 'spain'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204', 'spain'); - --- Clean dbs -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); diff --git a/server/extension/test/0.3.0/sql/70_ips_test.sql b/server/extension/test/0.3.0/sql/70_ips_test.sql deleted file mode 100644 index 6111bd0..0000000 --- a/server/extension/test/0.3.0/sql/70_ips_test.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - --- Insert dummy data into ip_address_locations -INSERT INTO ip_address_locations VALUES ('::ffff:0.0.0.0'::inet, (ST_SetSRID(ST_MakePoint('40.40', '3.71'), 4326))); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text'); diff --git a/server/extension/test/0.3.0/sql/90_remove_geocoder_api_user_test.sql b/server/extension/test/0.3.0/sql/90_remove_geocoder_api_user_test.sql deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.3.0/sql/90_remove_geocoder_api_user_test.sql +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.4.0/expected/00_install_test.out b/server/extension/test/0.4.0/expected/00_install_test.out deleted file mode 100644 index db041d0..0000000 --- a/server/extension/test/0.4.0/expected/00_install_test.out +++ /dev/null @@ -1,36 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; --- Install the extension -CREATE EXTENSION cdb_dataservices_server; --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_metrics_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - cdb_conf_setconf ------------------- - -(1 row) - -SELECT cartodb.cdb_conf_setconf('redis_metadata_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - cdb_conf_setconf ------------------- - -(1 row) - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); - cdb_setuserquotainbytes -------------------------- - 0 -(1 row) - diff --git a/server/extension/test/0.4.0/expected/20_street_test.out b/server/extension/test/0.4.0/expected/20_street_test.out deleted file mode 100644 index 8fbce7a..0000000 --- a/server/extension/test/0.4.0/expected/20_street_test.out +++ /dev/null @@ -1,12 +0,0 @@ --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_street_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text, text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.4.0/expected/30_admin0_test.out b/server/extension/test/0.4.0/expected/30_admin0_test.out deleted file mode 100644 index 55c7639..0000000 --- a/server/extension/test/0.4.0/expected/30_admin0_test.out +++ /dev/null @@ -1,47 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - cdb_geocode_admin0_polygon ----------------------------- - -(1 row) - --- Insert some dummy synonym -INSERT INTO admin0_synonyms (name, adm0_a3) VALUES ('Spain', 'ESP'); --- Insert some dummy geometry to return -INSERT INTO ne_admin0_v3 (adm0_a3, the_geom) VALUES('ESP', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - cdb_geocode_admin0_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - --- Check for admin0 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.4.0/expected/40_admin1_test.out b/server/extension/test/0.4.0/expected/40_admin1_test.out deleted file mode 100644 index 4894b0c..0000000 --- a/server/extension/test/0.4.0/expected/40_admin1_test.out +++ /dev/null @@ -1,81 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); - cdb_geocode_admin1_polygon ----------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - cdb_geocode_admin1_polygon ----------------------------- - -(1 row) - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso3) VALUES (Array['united states'], 'USA'); --- Insert some dummy data and geometry to return -INSERT INTO global_province_polygons (synonyms, iso3, the_geom) VALUES (Array['california'], 'USA', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); - cdb_geocode_admin1_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - cdb_geocode_admin1_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0103000020E61000000100000004000000D0EA37A29AC651C00FD603035B284540FEFCFB379AC651C0C0503E9F5B284540FFDDDD4D96C651C033AC3B284F284540D0EA37A29AC651C00FD603035B284540 -(1 row) - --- Check for admin1 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.4.0/expected/50_namedplaces_test.out b/server/extension/test/0.4.0/expected/50_namedplaces_test.out deleted file mode 100644 index 7755bf4..0000000 --- a/server/extension/test/0.4.0/expected/50_namedplaces_test.out +++ /dev/null @@ -1,136 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - cdb_geocode_namedplace_point ------------------------------- - -(1 row) - --- Insert dummy data into points table -INSERT INTO global_cities_points_limited (geoname_id, name, iso2, admin1, admin2, population, lowername, the_geom) VALUES (3128760, 'Elche', 'ES', 'Valencia', 'AL', 34534, 'elche', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); --- Insert dummy data into alternates table -INSERT INTO global_cities_alternates_limited (geoname_id, name, preferred, lowername, admin1_geonameid, iso2, admin1, the_geom) VALUES (3128760, 'Elx', true, 'elx', '000000', 'ES', 'Valencia', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso2) VALUES (Array['spain'], 'ES'); --- Insert dummy data into admin1 decoder table -INSERT INTO admin1_decoder (admin1, synonyms, iso2) VALUES ('Valencia', Array['valencia', 'Valencia'], 'ES'); --- This should return the point inserted above -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'valencia', 'Spain'); - cdb_geocode_namedplace_point ----------------------------------------------------- - 0101000020E6100000637FD93D7958E63F2ECA6C9049A24340 -(1 row) - --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.4.0/expected/60_postalcodes_test.out b/server/extension/test/0.4.0/expected/60_postalcodes_test.out deleted file mode 100644 index b2a5c91..0000000 --- a/server/extension/test/0.4.0/expected/60_postalcodes_test.out +++ /dev/null @@ -1,163 +0,0 @@ --- Make sure dbs are clean -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_point ------------------------------- - -(1 row) - --- Insert dummy data into ip_address_locations -INSERT INTO global_postal_code_points (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0101000020E61000000000000000E040408036B47414764840', - 'ESP', - '03204', - 3204 -); -INSERT INTO global_postal_code_polygons (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040', - 'ESP', - '03204', - 3204 -); -INSERT INTO country_decoder (iso3, synonyms) VALUES ( - 'ESP', - Array['spain', 'Spain', 'ESP'] -); -INSERT INTO available_services (adm0_a3, admin0, postal_code_points, postal_code_polygons) VALUES ( - 'ESP', - 't', - 't', - 't' -); -INSERT INTO admin0_synonyms (adm0_a3, name, name_, rank) VALUES ( - 'ESP', - 'Spain', - 'spain', - 3 -); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_point ----------------------------------------------------- - 0101000020E61000000000000000E040408036B47414764840 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204', 'spain'); - cdb_geocode_postalcode_point ----------------------------------------------------- - 0101000020E61000000000000000E040408036B47414764840 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204'); - cdb_geocode_postalcode_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040 -(1 row) - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204', 'spain'); - cdb_geocode_postalcode_polygon --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - 0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040 -(1 row) - --- Clean dbs -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.4.0/expected/70_ips_test.out b/server/extension/test/0.4.0/expected/70_ips_test.out deleted file mode 100644 index 48012f7..0000000 --- a/server/extension/test/0.4.0/expected/70_ips_test.out +++ /dev/null @@ -1,40 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - cdb_geocode_ipaddress_point ------------------------------ - -(1 row) - --- Insert dummy data into ip_address_locations -INSERT INTO ip_address_locations VALUES ('::ffff:0.0.0.0'::inet, (ST_SetSRID(ST_MakePoint('40.40', '3.71'), 4326))); --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - cdb_geocode_ipaddress_point ----------------------------------------------------- - 0101000020E61000003333333333334440AE47E17A14AE0D40 -(1 row) - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - exists --------- - t -(1 row) - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text'); - exists --------- - t -(1 row) - diff --git a/server/extension/test/0.4.0/expected/99_remove_geocoder_api_user_test.out b/server/extension/test/0.4.0/expected/99_remove_geocoder_api_user_test.out deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.4.0/expected/99_remove_geocoder_api_user_test.out +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.4.0/sql/00_install_test.sql b/server/extension/test/0.4.0/sql/00_install_test.sql deleted file mode 100644 index da91608..0000000 --- a/server/extension/test/0.4.0/sql/00_install_test.sql +++ /dev/null @@ -1,25 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; - --- Install the extension -CREATE EXTENSION cdb_dataservices_server; - --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_metrics_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); -SELECT cartodb.cdb_conf_setconf('redis_metadata_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; - --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); diff --git a/server/extension/test/0.4.0/sql/20_street_test.sql b/server/extension/test/0.4.0/sql/20_street_test.sql deleted file mode 100644 index 86e0368..0000000 --- a/server/extension/test/0.4.0/sql/20_street_test.sql +++ /dev/null @@ -1,7 +0,0 @@ --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_street_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text, text, text'); diff --git a/server/extension/test/0.4.0/sql/30_admin0_test.sql b/server/extension/test/0.4.0/sql/30_admin0_test.sql deleted file mode 100644 index 3249c60..0000000 --- a/server/extension/test/0.4.0/sql/30_admin0_test.sql +++ /dev/null @@ -1,32 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - --- Insert some dummy synonym -INSERT INTO admin0_synonyms (name, adm0_a3) VALUES ('Spain', 'ESP'); - --- Insert some dummy geometry to return -INSERT INTO ne_admin0_v3 (adm0_a3, the_geom) VALUES('ESP', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin0_polygon('test_user', 'test_orgname', 'Spain'); - --- Check for admin0 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin0_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); diff --git a/server/extension/test/0.4.0/sql/40_admin1_test.sql b/server/extension/test/0.4.0/sql/40_admin1_test.sql deleted file mode 100644 index 7b3748c..0000000 --- a/server/extension/test/0.4.0/sql/40_admin1_test.sql +++ /dev/null @@ -1,48 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso3) VALUES (Array['united states'], 'USA'); - --- Insert some dummy data and geometry to return -INSERT INTO global_province_polygons (synonyms, iso3, the_geom) VALUES (Array['california'], 'USA', ST_GeomFromText( - 'POLYGON((-71.1031880899493 42.3152774590236, - -71.1031627617667 42.3152960829043, - -71.102923838298 42.3149156848307, - -71.1031880899493 42.3152774590236))',4326) -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California'); -SELECT cdb_dataservices_server.cdb_geocode_admin1_polygon('test_user', 'test_orgname', 'California', 'United States'); - --- Check for admin1 signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_admin1_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); diff --git a/server/extension/test/0.4.0/sql/50_namedplaces_test.sql b/server/extension/test/0.4.0/sql/50_namedplaces_test.sql deleted file mode 100644 index 306a682..0000000 --- a/server/extension/test/0.4.0/sql/50_namedplaces_test.sql +++ /dev/null @@ -1,72 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); - --- Insert dummy data into points table -INSERT INTO global_cities_points_limited (geoname_id, name, iso2, admin1, admin2, population, lowername, the_geom) VALUES (3128760, 'Elche', 'ES', 'Valencia', 'AL', 34534, 'elche', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); - --- Insert dummy data into alternates table -INSERT INTO global_cities_alternates_limited (geoname_id, name, preferred, lowername, admin1_geonameid, iso2, admin1, the_geom) VALUES (3128760, 'Elx', true, 'elx', '000000', 'ES', 'Valencia', ST_GeomFromText( - 'POINT(0.6983 39.26787)',4326) -); - --- Insert dummy data into country decoder table -INSERT INTO country_decoder (synonyms, iso2) VALUES (Array['spain'], 'ES'); - --- Insert dummy data into admin1 decoder table -INSERT INTO admin1_decoder (admin1, synonyms, iso2) VALUES ('Valencia', Array['valencia', 'Valencia'], 'ES'); - --- This should return the point inserted above -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elx', 'Valencia', 'Spain'); -SELECT cdb_dataservices_server.cdb_geocode_namedplace_point('test_user', 'test_orgname', 'Elche', 'valencia', 'Spain'); - --- Check for namedplaces signatures -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_namedplace_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); diff --git a/server/extension/test/0.4.0/sql/60_postalcodes_test.sql b/server/extension/test/0.4.0/sql/60_postalcodes_test.sql deleted file mode 100644 index 55d1c85..0000000 --- a/server/extension/test/0.4.0/sql/60_postalcodes_test.sql +++ /dev/null @@ -1,117 +0,0 @@ --- Make sure dbs are clean -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; - --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - --- Insert dummy data into ip_address_locations -INSERT INTO global_postal_code_points (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0101000020E61000000000000000E040408036B47414764840', - 'ESP', - '03204', - 3204 -); - -INSERT INTO global_postal_code_polygons (the_geom, iso3, postal_code, postal_code_num) VALUES ( - '0106000020E610000001000000010300000001000000040000000000000000E000C01F383D7839B740400000000000E000C0AA3C0EDE220F3B4000000000004812404FB7FCCD04893D400000000000E000C01F383D7839B74040', - 'ESP', - '03204', - 3204 -); - -INSERT INTO country_decoder (iso3, synonyms) VALUES ( - 'ESP', - Array['spain', 'Spain', 'ESP'] -); - -INSERT INTO available_services (adm0_a3, admin0, postal_code_points, postal_code_polygons) VALUES ( - 'ESP', - 't', - 't', - 't' -); - -INSERT INTO admin0_synonyms (adm0_a3, name, name_, rank) VALUES ( - 'ESP', - 'Spain', - 'spain', - 3 -); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_point('test_user', 'test_org', '03204', 'spain'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204'); - -SELECT cdb_dataservices_server.cdb_geocode_postalcode_polygon('test_user', 'test_org', '03204', 'spain'); - --- Clean dbs -DELETE FROM global_postal_code_points; -DELETE FROM global_postal_code_polygons; -DELETE FROM country_decoder; -DELETE FROM available_services; -DELETE FROM admin0_synonyms; - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_point' - AND oidvectortypes(p.proargtypes) = 'text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_postalcode_polygon' - AND oidvectortypes(p.proargtypes) = 'text, text'); diff --git a/server/extension/test/0.4.0/sql/70_ips_test.sql b/server/extension/test/0.4.0/sql/70_ips_test.sql deleted file mode 100644 index 6111bd0..0000000 --- a/server/extension/test/0.4.0/sql/70_ips_test.sql +++ /dev/null @@ -1,24 +0,0 @@ --- Check that the public function is callable, even with no data --- It should return NULL -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - --- Insert dummy data into ip_address_locations -INSERT INTO ip_address_locations VALUES ('::ffff:0.0.0.0'::inet, (ST_SetSRID(ST_MakePoint('40.40', '3.71'), 4326))); - --- This should return the polygon inserted above -SELECT cdb_dataservices_server.cdb_geocode_ipaddress_point('test_user', 'test_orgname', '0.0.0.0'); - --- Check for namedplaces signatures (point and polygon) -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = 'cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text, text, text'); - -SELECT exists(SELECT * - FROM pg_proc p - INNER JOIN pg_namespace ns ON (p.pronamespace = ns.oid) - WHERE ns.nspname = 'cdb_dataservices_server' - AND proname = '_cdb_geocode_ipaddress_point' - AND oidvectortypes(p.proargtypes) = 'text'); diff --git a/server/extension/test/0.4.0/sql/99_remove_geocoder_api_user_test.sql b/server/extension/test/0.4.0/sql/99_remove_geocoder_api_user_test.sql deleted file mode 100644 index ad4fee7..0000000 --- a/server/extension/test/0.4.0/sql/99_remove_geocoder_api_user_test.sql +++ /dev/null @@ -1,5 +0,0 @@ -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM geocoder_api; -REVOKE USAGE ON SCHEMA cdb_dataservices_server FROM geocoder_api; -REVOKE USAGE ON SCHEMA public FROM geocoder_api; -REVOKE SELECT ON ALL TABLES IN SCHEMA public FROM geocoder_api; diff --git a/server/extension/test/0.5.0/expected/20_street_test.out b/server/extension/test/0.5.0/expected/20_street_test.out deleted file mode 120000 index 6081021..0000000 --- a/server/extension/test/0.5.0/expected/20_street_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/20_street_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.0/expected/30_admin0_test.out b/server/extension/test/0.5.0/expected/30_admin0_test.out deleted file mode 120000 index 9cfed39..0000000 --- a/server/extension/test/0.5.0/expected/30_admin0_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/30_admin0_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.0/expected/40_admin1_test.out b/server/extension/test/0.5.0/expected/40_admin1_test.out deleted file mode 120000 index 32b2ff2..0000000 --- a/server/extension/test/0.5.0/expected/40_admin1_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/40_admin1_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.0/expected/50_namedplaces_test.out b/server/extension/test/0.5.0/expected/50_namedplaces_test.out deleted file mode 120000 index ebc8d68..0000000 --- a/server/extension/test/0.5.0/expected/50_namedplaces_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/50_namedplaces_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.0/expected/60_postalcodes_test.out b/server/extension/test/0.5.0/expected/60_postalcodes_test.out deleted file mode 120000 index 147ebf6..0000000 --- a/server/extension/test/0.5.0/expected/60_postalcodes_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/60_postalcodes_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.0/expected/70_ips_test.out b/server/extension/test/0.5.0/expected/70_ips_test.out deleted file mode 120000 index 9b61caa..0000000 --- a/server/extension/test/0.5.0/expected/70_ips_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/70_ips_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.0/expected/85_isodistance_test.out b/server/extension/test/0.5.0/expected/85_isodistance_test.out deleted file mode 120000 index 3c81fbf..0000000 --- a/server/extension/test/0.5.0/expected/85_isodistance_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/85_isodistance_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.0/expected/90_isochrone_test.out b/server/extension/test/0.5.0/expected/90_isochrone_test.out deleted file mode 120000 index 596e8ab..0000000 --- a/server/extension/test/0.5.0/expected/90_isochrone_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/90_isochrone_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.0/sql/00_install_test.sql b/server/extension/test/0.5.0/sql/00_install_test.sql deleted file mode 100644 index 09503cc..0000000 --- a/server/extension/test/0.5.0/sql/00_install_test.sql +++ /dev/null @@ -1,26 +0,0 @@ --- Install dependencies -CREATE EXTENSION postgis; -CREATE EXTENSION schema_triggers; -CREATE EXTENSION plpythonu; -CREATE EXTENSION cartodb; -CREATE EXTENSION cdb_geocoder; - --- Install the extension -CREATE EXTENSION cdb_dataservices_server; - --- Mock the redis server connection to point to this very test db -SELECT cartodb.cdb_conf_setconf('redis_metrics_config', '{"redis_host": "localhost", "redis_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); -SELECT cartodb.cdb_conf_setconf('redis_metadata_config', '{"redis_host": "localhost", "redis_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}'); -SELECT cartodb.cdb_conf_setconf('mapzen_conf', '{"app_key": "dummy_key"}'); - --- Mock the varnish invalidation function --- (used by cdb_geocoder tests) -CREATE OR REPLACE FUNCTION public.cdb_invalidate_varnish(table_name text) RETURNS void AS $$ -BEGIN - RETURN; -END -$$ -LANGUAGE plpgsql; - --- Set user quota -SELECT cartodb.CDB_SetUserQuotaInBytes(0); diff --git a/server/extension/test/0.5.0/sql/20_street_test.sql b/server/extension/test/0.5.0/sql/20_street_test.sql deleted file mode 120000 index ca39762..0000000 --- a/server/extension/test/0.5.0/sql/20_street_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/20_street_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.0/sql/30_admin0_test.sql b/server/extension/test/0.5.0/sql/30_admin0_test.sql deleted file mode 120000 index f25c0a1..0000000 --- a/server/extension/test/0.5.0/sql/30_admin0_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/30_admin0_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.0/sql/40_admin1_test.sql b/server/extension/test/0.5.0/sql/40_admin1_test.sql deleted file mode 120000 index ada2acf..0000000 --- a/server/extension/test/0.5.0/sql/40_admin1_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/40_admin1_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.0/sql/50_namedplaces_test.sql b/server/extension/test/0.5.0/sql/50_namedplaces_test.sql deleted file mode 120000 index deb2105..0000000 --- a/server/extension/test/0.5.0/sql/50_namedplaces_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/50_namedplaces_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.0/sql/60_postalcodes_test.sql b/server/extension/test/0.5.0/sql/60_postalcodes_test.sql deleted file mode 120000 index 19eff09..0000000 --- a/server/extension/test/0.5.0/sql/60_postalcodes_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/60_postalcodes_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.0/sql/70_ips_test.sql b/server/extension/test/0.5.0/sql/70_ips_test.sql deleted file mode 120000 index 7af108a..0000000 --- a/server/extension/test/0.5.0/sql/70_ips_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/70_ips_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.0/sql/85_isodistance_test.sql b/server/extension/test/0.5.0/sql/85_isodistance_test.sql deleted file mode 120000 index d819b66..0000000 --- a/server/extension/test/0.5.0/sql/85_isodistance_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/85_isodistance_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.0/sql/90_isochrone_test.sql b/server/extension/test/0.5.0/sql/90_isochrone_test.sql deleted file mode 120000 index 33feb9b..0000000 --- a/server/extension/test/0.5.0/sql/90_isochrone_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/90_isochrone_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/00_install_test.out b/server/extension/test/0.5.1/expected/00_install_test.out deleted file mode 120000 index 9a720f2..0000000 --- a/server/extension/test/0.5.1/expected/00_install_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.5.0/expected/00_install_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/20_street_test.out b/server/extension/test/0.5.1/expected/20_street_test.out deleted file mode 120000 index 6081021..0000000 --- a/server/extension/test/0.5.1/expected/20_street_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/20_street_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/30_admin0_test.out b/server/extension/test/0.5.1/expected/30_admin0_test.out deleted file mode 120000 index 9cfed39..0000000 --- a/server/extension/test/0.5.1/expected/30_admin0_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/30_admin0_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/40_admin1_test.out b/server/extension/test/0.5.1/expected/40_admin1_test.out deleted file mode 120000 index 32b2ff2..0000000 --- a/server/extension/test/0.5.1/expected/40_admin1_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/40_admin1_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/50_namedplaces_test.out b/server/extension/test/0.5.1/expected/50_namedplaces_test.out deleted file mode 120000 index ebc8d68..0000000 --- a/server/extension/test/0.5.1/expected/50_namedplaces_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/50_namedplaces_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/60_postalcodes_test.out b/server/extension/test/0.5.1/expected/60_postalcodes_test.out deleted file mode 120000 index 147ebf6..0000000 --- a/server/extension/test/0.5.1/expected/60_postalcodes_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/60_postalcodes_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/70_ips_test.out b/server/extension/test/0.5.1/expected/70_ips_test.out deleted file mode 120000 index 9b61caa..0000000 --- a/server/extension/test/0.5.1/expected/70_ips_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/70_ips_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/85_isodistance_test.out b/server/extension/test/0.5.1/expected/85_isodistance_test.out deleted file mode 120000 index 3c81fbf..0000000 --- a/server/extension/test/0.5.1/expected/85_isodistance_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/85_isodistance_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/90_isochrone_test.out b/server/extension/test/0.5.1/expected/90_isochrone_test.out deleted file mode 120000 index 596e8ab..0000000 --- a/server/extension/test/0.5.1/expected/90_isochrone_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/expected/90_isochrone_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/95_route_point_to_point_test.out b/server/extension/test/0.5.1/expected/95_route_point_to_point_test.out deleted file mode 120000 index 2f0d32c..0000000 --- a/server/extension/test/0.5.1/expected/95_route_point_to_point_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.5.0/expected/95_route_point_to_point_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/expected/999_remove_geocoder_api_user_test.out b/server/extension/test/0.5.1/expected/999_remove_geocoder_api_user_test.out deleted file mode 120000 index 54a988d..0000000 --- a/server/extension/test/0.5.1/expected/999_remove_geocoder_api_user_test.out +++ /dev/null @@ -1 +0,0 @@ -../../0.5.0/expected/999_remove_geocoder_api_user_test.out \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/20_street_test.sql b/server/extension/test/0.5.1/sql/20_street_test.sql deleted file mode 120000 index ca39762..0000000 --- a/server/extension/test/0.5.1/sql/20_street_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/20_street_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/30_admin0_test.sql b/server/extension/test/0.5.1/sql/30_admin0_test.sql deleted file mode 120000 index f25c0a1..0000000 --- a/server/extension/test/0.5.1/sql/30_admin0_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/30_admin0_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/40_admin1_test.sql b/server/extension/test/0.5.1/sql/40_admin1_test.sql deleted file mode 120000 index ada2acf..0000000 --- a/server/extension/test/0.5.1/sql/40_admin1_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/40_admin1_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/50_namedplaces_test.sql b/server/extension/test/0.5.1/sql/50_namedplaces_test.sql deleted file mode 120000 index deb2105..0000000 --- a/server/extension/test/0.5.1/sql/50_namedplaces_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/50_namedplaces_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/60_postalcodes_test.sql b/server/extension/test/0.5.1/sql/60_postalcodes_test.sql deleted file mode 120000 index 19eff09..0000000 --- a/server/extension/test/0.5.1/sql/60_postalcodes_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/60_postalcodes_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/70_ips_test.sql b/server/extension/test/0.5.1/sql/70_ips_test.sql deleted file mode 120000 index 7af108a..0000000 --- a/server/extension/test/0.5.1/sql/70_ips_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/70_ips_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/85_isodistance_test.sql b/server/extension/test/0.5.1/sql/85_isodistance_test.sql deleted file mode 120000 index d819b66..0000000 --- a/server/extension/test/0.5.1/sql/85_isodistance_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/85_isodistance_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/90_isochrone_test.sql b/server/extension/test/0.5.1/sql/90_isochrone_test.sql deleted file mode 120000 index 33feb9b..0000000 --- a/server/extension/test/0.5.1/sql/90_isochrone_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.4.0/sql/90_isochrone_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/95_route_point_to_point_test.sql b/server/extension/test/0.5.1/sql/95_route_point_to_point_test.sql deleted file mode 120000 index 13f56b7..0000000 --- a/server/extension/test/0.5.1/sql/95_route_point_to_point_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.5.0/sql/95_route_point_to_point_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.1/sql/999_remove_geocoder_api_user_test.sql b/server/extension/test/0.5.1/sql/999_remove_geocoder_api_user_test.sql deleted file mode 120000 index b9b169d..0000000 --- a/server/extension/test/0.5.1/sql/999_remove_geocoder_api_user_test.sql +++ /dev/null @@ -1 +0,0 @@ -../../0.5.0/sql/999_remove_geocoder_api_user_test.sql \ No newline at end of file diff --git a/server/extension/test/0.5.0/expected/00_install_test.out b/server/extension/test/expected/00_install_test.out similarity index 100% rename from server/extension/test/0.5.0/expected/00_install_test.out rename to server/extension/test/expected/00_install_test.out diff --git a/server/extension/test/0.1.0/expected/20_street_test.out b/server/extension/test/expected/20_street_test.out similarity index 100% rename from server/extension/test/0.1.0/expected/20_street_test.out rename to server/extension/test/expected/20_street_test.out diff --git a/server/extension/test/0.0.1/expected/30_admin0_test.out b/server/extension/test/expected/30_admin0_test.out similarity index 100% rename from server/extension/test/0.0.1/expected/30_admin0_test.out rename to server/extension/test/expected/30_admin0_test.out diff --git a/server/extension/test/0.0.1/expected/40_admin1_test.out b/server/extension/test/expected/40_admin1_test.out similarity index 100% rename from server/extension/test/0.0.1/expected/40_admin1_test.out rename to server/extension/test/expected/40_admin1_test.out diff --git a/server/extension/test/0.0.1/expected/50_namedplaces_test.out b/server/extension/test/expected/50_namedplaces_test.out similarity index 100% rename from server/extension/test/0.0.1/expected/50_namedplaces_test.out rename to server/extension/test/expected/50_namedplaces_test.out diff --git a/server/extension/test/0.0.1/expected/60_postalcodes_test.out b/server/extension/test/expected/60_postalcodes_test.out similarity index 100% rename from server/extension/test/0.0.1/expected/60_postalcodes_test.out rename to server/extension/test/expected/60_postalcodes_test.out diff --git a/server/extension/test/0.0.1/expected/70_ips_test.out b/server/extension/test/expected/70_ips_test.out similarity index 100% rename from server/extension/test/0.0.1/expected/70_ips_test.out rename to server/extension/test/expected/70_ips_test.out diff --git a/server/extension/test/0.4.0/expected/85_isodistance_test.out b/server/extension/test/expected/85_isodistance_test.out similarity index 100% rename from server/extension/test/0.4.0/expected/85_isodistance_test.out rename to server/extension/test/expected/85_isodistance_test.out diff --git a/server/extension/test/0.4.0/expected/90_isochrone_test.out b/server/extension/test/expected/90_isochrone_test.out similarity index 100% rename from server/extension/test/0.4.0/expected/90_isochrone_test.out rename to server/extension/test/expected/90_isochrone_test.out diff --git a/server/extension/test/0.5.0/expected/95_route_point_to_point_test.out b/server/extension/test/expected/95_route_point_to_point_test.out similarity index 100% rename from server/extension/test/0.5.0/expected/95_route_point_to_point_test.out rename to server/extension/test/expected/95_route_point_to_point_test.out diff --git a/server/extension/test/0.5.0/expected/999_remove_geocoder_api_user_test.out b/server/extension/test/expected/999_remove_geocoder_api_user_test.out similarity index 100% rename from server/extension/test/0.5.0/expected/999_remove_geocoder_api_user_test.out rename to server/extension/test/expected/999_remove_geocoder_api_user_test.out diff --git a/server/extension/test/0.5.1/sql/00_install_test.sql b/server/extension/test/sql/00_install_test.sql similarity index 100% rename from server/extension/test/0.5.1/sql/00_install_test.sql rename to server/extension/test/sql/00_install_test.sql diff --git a/server/extension/test/0.1.0/sql/20_street_test.sql b/server/extension/test/sql/20_street_test.sql similarity index 100% rename from server/extension/test/0.1.0/sql/20_street_test.sql rename to server/extension/test/sql/20_street_test.sql diff --git a/server/extension/test/0.0.1/sql/30_admin0_test.sql b/server/extension/test/sql/30_admin0_test.sql similarity index 100% rename from server/extension/test/0.0.1/sql/30_admin0_test.sql rename to server/extension/test/sql/30_admin0_test.sql diff --git a/server/extension/test/0.0.1/sql/40_admin1_test.sql b/server/extension/test/sql/40_admin1_test.sql similarity index 100% rename from server/extension/test/0.0.1/sql/40_admin1_test.sql rename to server/extension/test/sql/40_admin1_test.sql diff --git a/server/extension/test/0.0.1/sql/50_namedplaces_test.sql b/server/extension/test/sql/50_namedplaces_test.sql similarity index 100% rename from server/extension/test/0.0.1/sql/50_namedplaces_test.sql rename to server/extension/test/sql/50_namedplaces_test.sql diff --git a/server/extension/test/0.0.1/sql/60_postalcodes_test.sql b/server/extension/test/sql/60_postalcodes_test.sql similarity index 100% rename from server/extension/test/0.0.1/sql/60_postalcodes_test.sql rename to server/extension/test/sql/60_postalcodes_test.sql diff --git a/server/extension/test/0.0.1/sql/70_ips_test.sql b/server/extension/test/sql/70_ips_test.sql similarity index 100% rename from server/extension/test/0.0.1/sql/70_ips_test.sql rename to server/extension/test/sql/70_ips_test.sql diff --git a/server/extension/test/0.4.0/sql/85_isodistance_test.sql b/server/extension/test/sql/85_isodistance_test.sql similarity index 100% rename from server/extension/test/0.4.0/sql/85_isodistance_test.sql rename to server/extension/test/sql/85_isodistance_test.sql diff --git a/server/extension/test/0.4.0/sql/90_isochrone_test.sql b/server/extension/test/sql/90_isochrone_test.sql similarity index 100% rename from server/extension/test/0.4.0/sql/90_isochrone_test.sql rename to server/extension/test/sql/90_isochrone_test.sql diff --git a/server/extension/test/0.5.0/sql/95_route_point_to_point_test.sql b/server/extension/test/sql/95_route_point_to_point_test.sql similarity index 100% rename from server/extension/test/0.5.0/sql/95_route_point_to_point_test.sql rename to server/extension/test/sql/95_route_point_to_point_test.sql diff --git a/server/extension/test/0.5.0/sql/999_remove_geocoder_api_user_test.sql b/server/extension/test/sql/999_remove_geocoder_api_user_test.sql similarity index 100% rename from server/extension/test/0.5.0/sql/999_remove_geocoder_api_user_test.sql rename to server/extension/test/sql/999_remove_geocoder_api_user_test.sql diff --git a/server/lib/python/cartodb_services/cartodb_services/mapzen/routing.py b/server/lib/python/cartodb_services/cartodb_services/mapzen/routing.py index 2cff989..54b6145 100644 --- a/server/lib/python/cartodb_services/cartodb_services/mapzen/routing.py +++ b/server/lib/python/cartodb_services/cartodb_services/mapzen/routing.py @@ -45,6 +45,8 @@ class MapzenRouting: response = requests.get(self._url, params=request_params) if response.status_code == requests.codes.ok: return self.__parse_routing_response(response.text) + elif response.status_code == requests.codes.bad_request: + return MapzenRoutingResponse(None, None, None) else: response.raise_for_status() @@ -78,9 +80,7 @@ class MapzenRouting: shape = PolyLine().decode(legs['shape']) length = legs['summary']['length'] duration = legs['summary']['time'] - routing_response = MapzenRoutingResponse(shape, length, duration) - - return routing_response + return MapzenRoutingResponse(shape, length, duration) except IndexError: return [] except KeyError: diff --git a/server/lib/python/cartodb_services/cartodb_services/mapzen/types.py b/server/lib/python/cartodb_services/cartodb_services/mapzen/types.py index bfaef3b..fa3aeed 100644 --- a/server/lib/python/cartodb_services/cartodb_services/mapzen/types.py +++ b/server/lib/python/cartodb_services/cartodb_services/mapzen/types.py @@ -10,7 +10,11 @@ def polyline_to_linestring(polyline): coordinates.append("%s %s" % (point[1]/10, point[0]/10)) wkt_coordinates = ','.join(coordinates) - sql = "SELECT ST_GeomFromText('LINESTRING({0})', 4326) as geom".format(wkt_coordinates) - geometry = plpy.execute(sql, 1)[0]['geom'] + try: + sql = "SELECT ST_GeomFromText('LINESTRING({0})', 4326) as geom".format(wkt_coordinates) + geometry = plpy.execute(sql, 1)[0]['geom'] + except BaseException as e: + plpy.warning("Can't generate LINESTRING from polyline: {0}".format(e)) + geometry = None return geometry diff --git a/server/lib/python/cartodb_services/cartodb_services/tools/coordinates.py b/server/lib/python/cartodb_services/cartodb_services/tools/coordinates.py index c8c0748..759b02e 100644 --- a/server/lib/python/cartodb_services/cartodb_services/tools/coordinates.py +++ b/server/lib/python/cartodb_services/cartodb_services/tools/coordinates.py @@ -17,3 +17,5 @@ class Coordinate: def to_json(self): return "{{\"lon\": {0},\"lat\": {1}}}".format(self._longitude, self._latitude) + def __str__(self): + return "{0}, {1}".format(self._longitude, self._latitude) \ No newline at end of file diff --git a/server/lib/python/cartodb_services/cartodb_services/tools/polyline.py b/server/lib/python/cartodb_services/cartodb_services/tools/polyline.py index a903e57..05b367a 100644 --- a/server/lib/python/cartodb_services/cartodb_services/tools/polyline.py +++ b/server/lib/python/cartodb_services/cartodb_services/tools/polyline.py @@ -11,14 +11,11 @@ class PolyLine: for chunk in chunks: coordinate = self._process_chunk(chunk) coordinate /= 1e5 - print coordinate if len(coordinates) > 1: # We have to sum the previous with the offset in this chunk coordinate += coordinates[-2] coordinates.append(round(coordinate, 5)) - print coordinates - return zip(coordinates, coordinates[1:])[::2] def _extract_chunks(self, data): diff --git a/server/lib/python/cartodb_services/setup.py b/server/lib/python/cartodb_services/setup.py index 499e833..53f3b95 100644 --- a/server/lib/python/cartodb_services/setup.py +++ b/server/lib/python/cartodb_services/setup.py @@ -10,7 +10,7 @@ from setuptools import setup, find_packages setup( name='cartodb_services', - version='0.3.2', + version='0.3.3', description='CartoDB Services API Python Library', diff --git a/server/lib/python/cartodb_services/test/test_heremapsrouting.py b/server/lib/python/cartodb_services/test/test_heremapsrouting.py index 3b30b7b..a6ce503 100644 --- a/server/lib/python/cartodb_services/test/test_heremapsrouting.py +++ b/server/lib/python/cartodb_services/test/test_heremapsrouting.py @@ -132,7 +132,6 @@ class HereMapsRoutingIsolineTestCase(unittest.TestCase): HereMapsRoutingIsoline.ISOLINE_PATH) def test_calculate_isodistance_with_valid_params(self, req_mock): - print self.isoline_url url = "{0}?start=geo%2133.0%2C1.0&mode=shortest%3Bcar".format(self.isoline_url) req_mock.register_uri('GET', url, text=self.GOOD_RESPONSE) response = self.routing.calculate_isodistance('geo!33.0,1.0', 'car',