Merge pull request #150 from CartoDB/development

Fixed tests with the isolines changes

README.md

@@ -23,11 +23,11 @@ Steps to deploy a new Data Services API version :
 
 ### Local install instructions
 
-- install data services extension 
+- install data services geocoder extension 
 
     ```
     git clone git@github.com:CartoDB/data-services.git
-    data-services/geocoder/extension
+    cd data-services/geocoder/extension
     sudo make install
     ```
 
@@ -35,7 +35,7 @@ Steps to deploy a new Data Services API version :
     
     ```
     cd client && sudo make install
-    cd server && sudo make install
+    cd server/extension && sudo make install
     ```
 
 - install python library
@@ -57,21 +57,28 @@ Steps to deploy a new Data Services API version :
 
 
     ```
-    # select CDB_Conf_SetConf('redis_metadata_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}');
-    # select CDB_Conf_SetConf('redis_metrics_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}');
-    
-    # select CDB_Conf_SetConf('heremaps_conf', '{"app_id": "APP_ID", "app_code": "APP_CODE"}');
-    # select CDB_Conf_SetConf('user_config', '{"is_organization": false, "entity_name": "<YOUR_USERNAME>"}')
+    # If sentinel is used:
+      SELECT CDB_Conf_SetConf('redis_metadata_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "mymaster", "timeout": 0.1, "redis_db": 5}');
+      SELECT CDB_Conf_SetConf('redis_metrics_config', '{"sentinel_host": "localhost", "sentinel_port": 26379, "sentinel_master_id": "", "timeout": 0.1, "redis_db": 5}');
+      
+    # If sentinel is not used
+      SELECT CDB_Conf_SetConf('redis_metadata_config', '{"redis_host": "localhost", "redis_port": 26379, "sentinel_master_id": "", "timeout": 0.1, "redis_db": 5}');
+      SELECT CDB_Conf_SetConf('redis_metrics_config', '{"redis_host": "localhost", "redis_port": 6379, "sentinel_master_id": "", "timeout": 0.1, "redis_db": 5}');
+  
+    SELECT CDB_Conf_SetConf('heremaps_conf', '{"app_id": "APP_ID", "app_code": "APP_CODE", "geocoder_cost_per_hit": "COST_PER_HIT"}');
+    SELECT CDB_Conf_SetConf('user_config', '{"is_organization": false, "entity_name": "<YOUR_USERNAME>"}')
+    SELECT CDB_Conf_SetConf('mapzen_conf', '{"routing_app_key": "ROUTING_API_KEY", "geocoder_app_key": "GEOCODER_API_KEY"}');
+    SELECT CDB_Conf_SetConf('logger_con', '{"geocoder_log_path": "/tmp/geocodings.log"}')
     ```
 
-- configure plproxy to point to the same user database (you could do in a different one)
+- configure plproxy to point to the a database (you can use a specific database for the server or your same user)
 
     ```
-     select CDB_Conf_SetConf('geocoder_server_config', '{ "connection_str": "host=localhost port=5432 dbname=cartodb_dev_user_accf0647-d942-4e37-b129-8287c117e687_db user=postgres"}');
+     SELECT CDB_Conf_SetConf('geocoder_server_config', '{ "connection_str": "host=localhost port=5432 dbname=<SERVER_DB_NAME> user=postgres"}');
     ```
 
-- configure the search path in order to be able to execute the functions without use the schema:
+- configure the search path in order to be able to execute the functions without using the schema:
 
     ```
-    alter role "<USER_ROLE>" set search_path='"$user", public, cartodb, cdb_dataservices_client';
+    ALTER ROLE "<USER_ROLE>" SET search_path="$user", public, cartodb, cdb_dataservices_client;
     ```

client/Makefile

@@ -5,19 +5,14 @@ EXTVERSION = $(shell grep default_version $(EXTENSION).control | sed -e "s/defau
 
 # The new version to be generated from templates
 NEW_EXTENSION_ARTIFACT = $(EXTENSION)--$(EXTVERSION).sql
+OLD_VERSIONS = $(wildcard old_versions/*.sql)
 
 # DATA is a special variable used by postgres build infrastructure
 # These are the files to be installed in the server shared dir,
 # for installation from scratch, upgrades and downgrades.
 # @see http://www.postgresql.org/docs/current/static/extend-pgxs.html
 DATA =  $(NEW_EXTENSION_ARTIFACT) \
-  cdb_dataservices_client--0.0.1.sql \
-  cdb_dataservices_client--0.1.0.sql \
-  cdb_dataservices_client--0.2.0.sql \
-  cdb_dataservices_client--0.1.0--0.0.1.sql \
-  cdb_dataservices_client--0.0.1--0.1.0.sql \
-  cdb_dataservices_client--0.2.0--0.1.0.sql \
-  cdb_dataservices_client--0.1.0--0.2.0.sql \
+  $(OLD_VERSIONS) \
   cdb_dataservices_client--0.2.0--0.3.0.sql \
   cdb_dataservices_client--0.3.0--0.2.0.sql
 

doc/API.md

@@ -1,9 +1,15 @@
-# Geocoder API
+# Data Services API
 
-The CartoDB Geocoder API allows you to match your data with geometries on your map. This geocoding service can be used programatically to geocode datasets via the CartoDB SQL API. It is fed from _Open Data_ and it serves geometries for countries, provinces, states, cities, postal codes, IP addresses and street addresses.
+The CartoDB Data Services API offers a set of location based services that can be used programatically to empower your geospatial applications.
+
+The geocoder functions allow you to match your data with geometries on your map. This geocoding service can be used programatically to geocode datasets via the CartoDB SQL API. It is fed from _Open Data_ and it serves geometries for countries, provinces, states, cities, postal codes, IP addresses and street addresses.
+
+The isoline functions provide a way to generate isolines in terms of distance and time, by means of the available isodistance and isochrone functions useful for Trade Areas Analysis.
 
 ## Documentation
 
 * [Quickstart](quickstart.md)
-* [General concepts](general_concepts.md)
-* [Reference](reference.md)
+* [General Concepts](general_concepts.md)
+* [Geocoding Functions](geocoding_functions.md)
+* [Isoline Functions](isoline_functions.md)
+* [Quota Information](quota_information.md)

doc/general_concepts.md

@@ -1,20 +1,20 @@
-# General concepts
+# General Concepts
 
-The Geocoder API offers geocoding services on top of the CartoDB SQL API by means of a set of geocoding functions. Each one of these functions is oriented to one kind of geocoding operation and it will return the corresponding geometry (a `polygon` or a `point`) according to the input information.
+The Data Services API offers geocoding and isoline services on top of the CartoDB SQL API by means of a set of functions. Each one of these functions is oriented to one kind of operation and returns the corresponding geometry (a `polygon` or a `point`), according to the input information.
 
-The Geocoder API decouples the geocoding service from the CartoDB Editor, and allows to geocode data (being single rows, complete datasets or simple inputs) programatically through authenticated requests.
+The Data Services API decouples the geocoding and isoline services from the CartoDB Editor. The API allows you to geocode data (from single rows, complete datasets, or simple inputs) and to perform trade areas analysis (computing isodistances or isochrones) programatically through authenticated requests.
 
 The geometries provided by this API are projected in the projection [WGS 84 SRID 4326](http://spatialreference.org/ref/epsg/wgs-84/).
 
-The Geocoder API can return different types of geometries (points or polygons) as result of different geocoding processes. The CartoDB platform does not support multigeometry layers or datasets, therefore the final users of this Geocoder API must check that they are using consistent geometry types inside a table to avoid further conflicts in the map visualization.
+The Geocoder functions can return different types of geometries (points or polygons) as result of different geocoding processes. The CartoDB platform does not support multigeometry layers or datasets, therefore the final users of this Data Services API must check that they are using consistent geometry types inside a table to avoid further conflicts in the map visualization.
 
 ## Authentication
 
-All requests performed to the CartoDB Geocoder API must be authenticated with the user API Key. For more information about where to find your API Key, and how to authenticate your SQL API requests, view the [SQL API authentication](/cartodb-platform/sql-api/authentication/) guide.
+All requests performed to the CartoDB Data Services API must be authenticated with the user API Key. For more information about where to find your API Key, and how to authenticate your SQL API requests, view the [SQL API authentication](/cartodb-platform/sql-api/authentication/) guide.
 
 ## Errors
 
-Errors are described in the response of the geocoder request. An example is as follows:
+Errors are described in the response of the request. An example is as follows:
 
 ```json
 {
@@ -24,10 +24,10 @@ Errors are described in the response of the geocoder request. An example is as f
 }
 ```
 
-Since the Geocoder API is used on top of the CartoDB SQL API, you can refer to the [Making calls to the SQL API](/cartodb-platform/sql-api/making-calls/) documentation for help debugging your SQL errors.
+Since the Data Services API is used on top of the CartoDB SQL API, you can refer to the [Making calls to the SQL API](/cartodb-platform/sql-api/making-calls/) documentation for help debugging your SQL errors.
 
 If the requested information is not in the CartoDB geocoding database, or if CartoDB is unable to recognize your input and match it with a result, the geocoding function returns `null` as a result.
 
 ## Limits
 
-Usage of the Geocoder API is subject to the CartoDB SQL API limits, stated in our [Terms of Service](https://cartodb.com/terms/#excessive).
+Usage of the Data Services API is subject to the CartoDB SQL API limits, stated in our [Terms of Service](https://cartodb.com/terms/#excessive).

doc/geocoding_functions.md

@@ -1,4 +1,4 @@
-# Geocoding functions
+# Geocoding Functions
 
 The following geocoding functions are available, grouped by categories.
 
@@ -36,7 +36,7 @@ UPDATE {tablename} SET the_geom = cdb_geocode_admin0_polygon({country_column})
 
 ## Level-1 Administrative regions geocoder
 
-The following functions provide a geocoding service for administrative regions of level 1 (or NUTS-1) such as states for the United States, regions in France or autonomous communities in Spain.
+The following functions provide a geocoding service for administrative regions of level 1 (or NUTS-1) such as states for the United States, *départements* in France or autonomous communities in Spain.
 
 ### cdb_geocode_admin1_polygon(_admin1_name text_)
 
@@ -94,7 +94,7 @@ UPDATE {tablename} SET the_geom = cdb_geocode_admin1_polygon({province_column},
 
 ## City geocoder
 
-The following functions provide a city geocoder service. It is recommended to use the more specific geocoding function -- the one that requires more parameters — in order for the result to be as accurate as possible when several cities share their name.
+The following functions provide a city geocoder service. It is recommended to use the more specific geocoding function -- the one that requires more parameters — in order for the result to be as accurate as possible when several cities share their name. If there are duplicate results for a city name, the city name with the highest population will be returned.
 
 ### cdb_geocode_namedplace_point(_city_name text_)
 
@@ -181,6 +181,8 @@ UPDATE {tablename} SET the_geom = cdb_geocode_namedplace_point({city_column}, {p
 
 The following functions provide a postal code geocoding service that can be used to obtain points or polygon results. The postal code polygon geocoder covers the United States, France, Australia and Canada; a request for a different country will return an empty response.
 
+**Note:** For the USA, US Census [Zip Code Tabulation Areas](https://www.census.gov/geo/reference/zctas.html) (ZCTA) are used to reference geocodes for USPS postal codes service areas. See the [FAQs](http://docs.cartodb.com/faqs/datasets-and-data/#why-does-cartodb-use-census-bureau-zctas-and-not-usps-zip-codes-for-postal-codes) about datasets and data for details.
+
 ### cdb_geocode_postalcode_polygon(_postal_code text, country_name text_)
 
 #### Arguments
@@ -208,8 +210,6 @@ SELECT cdb_geocode_postalcode_polygon('11211', 'USA')
 UPDATE {tablename} SET the_geom = cdb_geocode_postalcode_polygon({postal_code_column}, 'USA')
 ```
 
-**Note:** For the USA, US Census ZCTAs are considered.
-
 ### cdb_geocode_postalcode_point(_code text, country_name text_)
 
 #### Arguments
@@ -271,13 +271,7 @@ UPDATE {tablename} SET the_geom = cdb_geocode_ipaddress_point('102.23.34.1')
 
 This function provides a street-level geocoding service. This service uses the street level geocoder defined for the user.
 
-**This service is subject to quota limitations, and extra fees may apply.** Please view our [terms and conditions](https://cartodb.com/terms/)
-
-Be mindful of the following when using this function:
-
-  - **One credit per function call will be consumed**, and the results are not cached. If the query applies to a N rows dataset, then N credits will be used.
-  - You are discouraged from using dynamic queries to the Geocoder API in your maps. This can result in credits consumption per map view. Note: **queries to the Geocoder API in your maps may be forbidden in the future**.
-  - You are advised to store results of Geocoder API queries into your datasets and refresh them as needed, so that you can have finer control on your credits' usage.
+**This service is subject to quota limitations, and extra fees may apply**. Please view our [terms and conditions](https://cartodb.com/terms/) and check out the [Quota information section](http://docs.cartodb.com/cartodb-platform/dataservices-api/quota-information/) for details and recommendations related with quota usage.
 
 ### cdb_geocode_street_point(_search_text text, [city text], [state text], [country text]_)
 

doc/isoline_functions.md

@@ -0,0 +1,99 @@
+# Isoline Functions
+
+The following functions provide an isolines generator service based on time or distance. This service uses the isolines service defined for the user (currently, only the [HERE](https://developer.here.com/coverage-info) isolines service is available).
+
+**This service is subject to quota limitations, and extra fees may apply**. Please view our [terms and conditions](https://cartodb.com/terms/) and check out the [Quota information section](http://docs.cartodb.com/cartodb-platform/dataservices-api/quota-information/) for details and recommendations related with quota usage.
+
+### cdb_isodistance(_source geometry, mode text, range integer[], [options text[]]_)
+
+#### Arguments
+
+Name | Type | Description | Accepted values
+--- | --- | --- | ---
+`source` | `geometry` | Source point, in 4326 projection, which defines the start location. |
+`mode` | `text` | Type of transport used to calculate the isolines. | `car` or `walk`
+`range` | `integer[]` | Range of the isoline, in meters. |
+`options` | `text[]` | (Optional) Multiple options to add more capabilities to the analysis. See [Optional isolines parameters](#optional-isoline-parameters) for details.
+
+
+#### Returns
+
+Name | Type | Description
+--- | --- | ---
+`center` | `geometry` | Source point, in 4326 projection, which defines the start location.
+`data_range` | `integer` | The range that belongs to the generated isoline.
+`the_geom` | `geometry(MultiPolygon)` | MultiPolygon geometry of the generated isoline in the 4326 projection.
+
+#### Examples
+
+##### Select the results of the isodistance function
+
+```bash
+SELECT * FROM cdb_isodistance('POINT(-3.70568 40.42028)'::geometry, 'car', ARRAY[1000,2000]::integer[]);
+```
+
+```bash
+SELECT * FROM cdb_isodistance('POINT(-3.70568 40.42028)'::geometry, 'walk', ARRAY[1000]::integer[], ARRAY['mode_traffic=enabled','quality=3']::text[]);
+```
+
+##### Select the geometric results of the isodistance function
+
+```bash
+SELECT the_geom FROM cdb_isodistance('POINT(-3.70568 40.42028)'::geometry, 'walk', ARRAY[1000]::integer[]);
+```
+
+##### Calculate and insert the generated isolines from `points_table` table to another table
+
+```bash
+INSERT INTO {table} (the_geom) SELECT (cdb_isodistance(the_geom, 'walk', string_to_array(distance, ',')::integer[])).the_geom FROM {points_table}
+```
+
+### cdb_isochrone(_source geometry, mode text, range integer[], [options text[]]_)
+
+#### Arguments
+
+This function uses the same parameters and information as the `cdb_isodistance` function, with the exception that the range is measured in seconds instead of meters.
+
+Name | Type | Description | Accepted values
+--- | --- | --- | ---
+`source` | `geometry` | Source point, in 4326 projection, which defines the start location. |
+`mode` | `text` | Type of transport used to calculate the isolines. | `car` or `walk`
+`range` | `integer[]` | Range of the isoline, in seconds. |
+`options` | `text[]` | (Optional) Multiple options to add more capabilities to the analysis. See [Optional isolines parameters](#optional-isoline-parameters) for details.
+
+#### Examples
+
+##### Select the results of the isochrone function
+
+```bash
+SELECT * FROM cdb_isochrone('POINT(-3.70568 40.42028)'::geometry, 'car', ARRAY[300,900,12000]::integer[]);
+```
+
+```bash
+SELECT * FROM cdb_isochrone('POINT(-3.70568 40.42028)'::geometry, 'walk', ARRAY[300,900]::integer[], ARRAY['mode_traffic=enabled','quality=3']::text[]);
+```
+
+##### Select the geometric results of the isochrone function
+
+```bash
+SELECT the_geom FROM cdb_isochrone('POINT(-3.70568 40.42028)'::geometry, 'walk', ARRAY[300]::integer[]);
+```
+
+##### Calculate and insert the generated isolines from `points_table` table to another table
+
+```bash
+INSERT INTO {table} (the_geom) SELECT (cdb_isochrone(the_geom, 'walk', string_to_array(time_distance, ',')::integer[])).the_geom FROM {points_table}
+```
+
+### Optional isoline parameters
+
+The optional value parameters must be passed using the format: `option=value`.
+
+Name | Type | Description | Accepted values
+--- | --- | --- | ---
+`is_destination` | `boolean` | If true, the source point is the destination instead of the starting location | `true` or `false`. `false` by default
+`mode_type` | `text` | Type of route calculation | `shortest` or `fastest`. `shortest` by default
+`mode_traffic` | `text` | Use traffic data to calculate the route | `enabled` or `disabled`. `disabled` by default
+`resolution` | `text` | Allows you to specify the level of detail needed for the isoline polygon. Unit is meters per pixel. Higher resolution may increase the response time of the service.
+`maxpoints` | `text` | Allows you to limit the amount of points in the returned isoline. If the isoline consists of multiple components, the sum of points from all components is considered. Each component will have at least two points. It is possible that more points than specified could be returned, in case when `2 * number of components` is higher than the `maxpoints` value itself. Increasing the number of `maxpoints` may increase the response time of the service.
+`quality` | `text` | Allows you to reduce the quality of the isoline in favor of the response time. | `1`, `2`, `3`. Default value is `1`, corresponding to the best quality option.

doc/quickstart.md

@@ -1,6 +1,6 @@
 # Quickstart
 
-If you are using the set of APIs and libraries that CartoDB offers, and you are handling your data with the SQL API, you can make your data visible in your maps by geocoding the dataset programatically.
+If you are using the set of APIs and libraries that CartoDB offers, and you are handling your data with the SQL API, you can make your data visible in your maps by geocoding the dataset programatically. The set of isoline functions allow you to calculate the area which can be reached by travelling a given distance or time, useful for geospatial analysis, such as Trade Area Analysis.
 
 Here is an example of how to geocode a single country:
 
@@ -13,8 +13,13 @@ In order to geocode an existent CartoDB dataset, an SQL UPDATE statement must be
 ```bash
 https://{username}.cartodb.com/api/v2/sql?q=UPDATE {tablename} SET the_geom = cdb_geocode_admin0_polygon({country_column})&api_key={Your API key}
 ```
+You can use the isoline functions to retrieve, for example, isochrone lines from a certain location, specifying the mode and the ranges that will define each of the isolines. The following query calculates isolines for areas that are 5, 10 and 15 minutes (300, 600 and 900 seconds, respectively) away from the location by following a path defined by car routing.
 
-Notice that you can make use of Postgres or PostGIS functions in your Geocoder API requests, as the result of it will be a geometry that can be handled by the system. As an example, if you need to retrieve the centroid of a specific country, you can wrap the resulting geometry from the Geocoder API inside the PostGIS `ST_Centroid` function:
+```bash
+https://{username}.cartodb.com/api/v2/sql?q=SELECT cdb_isochrone('POINT(-3.70568 40.42028)'::geometry, 'car', ARRAY[300,600,900]::integer[])&api_key={Your API key}
+```
+
+Notice that you can make use of Postgres or PostGIS functions in your Data Services API requests, as the result is a geometry that can be handled by the system. For example, suppose you need to retrieve the centroid of a specific country, you can wrap the resulting geometry from the geocoder functions inside the PostGIS `ST_Centroid` function:
 
 ```bash
 https://{username}.cartodb.com/api/v2/sql?q=SELECT ST_Centroid(cdb_geocode_admin0_polygon('USA'))&api_key={Your API key}

doc/quota_information.md

@@ -0,0 +1,17 @@
+# Quota Information
+
+**This Data Services API provides functions which are subject to quota limitations, and extra fees may apply**. Please check our [terms and conditions](https://cartodb.com/terms/).
+
+The functions that require service credits to be used are as follows:
+
+* cdb_geocode_street_point(_search_text text, [city text], [state text], [country text]_); from [Geocoding functions](http://docs.cartodb.com/cartodb-platform/dataservices-api/geocoding-functions/)
+* cdb_isodistance(_source geometry, mode text, range integer[], [options text[]]_); from [Isoline functions](http://docs.cartodb.com/cartodb-platform/dataservices-api/isoline-functions/)
+* cdb_isochrone(_source geometry, mode text, range integer[], [options text[]]_); from [Isoline functions](http://docs.cartodb.com/cartodb-platform/dataservices-api/isoline-functions/)
+
+## Quota consumption information and usage recommendations
+
+Be mindful of the following when using the abovementioned functions:
+
+* One credit per function call will be consumed, and the results are not cached. If the query is applied to a _N_ rows dataset, then _N_ credits will be used.
+* You are discouraged from using dynamic queries to these functions in your maps. This can result in credits consumption per map view. **Note:** Queries to the Data Services API and any of its functions in your maps may be forbidden in the future.
+* You are advised to store results of these queries into your datasets and refresh them as needed, so that you can have finer control on your credits' usage.

server/extension/.gitignore

@@ -5,3 +5,5 @@ cdb_geocoder_server--0.0.1.sql
 cdb_geocoder_server--0.1.0.sql
 cdb_geocoder_server--0.2.0.sql
 cdb_geocoder_server--0.3.0.sql
+cdb_geocoder_server--0.4.0.sql
+cdb_geocoder_server--0.5.0.sql

server/extension/Makefile

@@ -5,30 +5,19 @@ EXTVERSION = $(shell grep default_version $(EXTENSION).control | sed -e "s/defau
 
 # The new version to be generated from templates
 NEW_EXTENSION_ARTIFACT = $(EXTENSION)--$(EXTVERSION).sql
+OLD_VERSIONS = $(wildcard old_versions/*.sql)
 
 # DATA is a special variable used by postgres build infrastructure
 # These are the files to be installed in the server shared dir,
 # for installation from scratch, upgrades and downgrades.
 # @see http://www.postgresql.org/docs/current/static/extend-pgxs.html
 DATA =  $(NEW_EXTENSION_ARTIFACT) \
-  cdb_dataservices_server--0.0.1.sql \
-  cdb_dataservices_server--0.1.0.sql \
-  cdb_dataservices_server--0.2.0.sql \
-  cdb_dataservices_server--0.3.0.sql \
-  cdb_dataservices_server--0.4.0.sql \
-  cdb_dataservices_server--0.1.0--0.0.1.sql \
-  cdb_dataservices_server--0.0.1--0.1.0.sql \
-  cdb_dataservices_server--0.2.0--0.1.0.sql \
-  cdb_dataservices_server--0.1.0--0.2.0.sql \
-  cdb_dataservices_server--0.2.0--0.3.0.sql \
-  cdb_dataservices_server--0.3.0--0.2.0.sql \
-  cdb_dataservices_server--0.3.0--0.4.0.sql \
-  cdb_dataservices_server--0.4.0--0.3.0.sql \
-  cdb_dataservices_server--0.5.0--0.4.0.sql \
-  cdb_dataservices_server--0.4.0--0.5.0.sql
+  $(OLD_VERSIONS) \
+  cdb_dataservices_server--0.6.2--0.6.1.sql \
+  cdb_dataservices_server--0.6.1--0.6.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
@@ -36,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 $@

server/extension/cdb_dataservices_server--0.6.1--0.6.2.sql

@@ -0,0 +1,102 @@
+--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.6.2'" to load this file. \quit
+CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_mapzen_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.mapzen import MapzenGeocoder
+  from cartodb_services.mapzen.types import country_to_iso3
+  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)
+  if not quota_service.check_user_quota():
+    plpy.error('You have reach the limit of your quota')
+
+  try:
+    geocoder = MapzenGeocoder(user_geocoder_config.mapzen_api_key)
+    country_iso3 = None
+    if country:
+      country_iso3 = country_to_iso3(country)
+    coordinates = geocoder.geocode(searchtext=searchtext, city=city,
+                                   state_province=state_province,
+                                   country=country_iso3)
+    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 mapzen 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_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)
+  if not quota_service.check_user_quota():
+    plpy.error('You have reach the limit of your quota')
+
+  try:
+    client = MapzenRouting(user_routing_config.mapzen_api_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;

server/extension/cdb_dataservices_server--0.6.2--0.6.1.sql

@@ -0,0 +1,98 @@
+--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.6.1'" to load this file. \quit
+CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_mapzen_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.mapzen import MapzenGeocoder
+  from cartodb_services.mapzen.types import country_to_iso3
+  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 = MapzenGeocoder(user_geocoder_config.mapzen_app_key)
+    country_iso3 = None
+    if country:
+      country_iso3 = country_to_iso3(country)
+    coordinates = geocoder.geocode(searchtext=searchtext, city=city,
+                                   state_province=state_province,
+                                   country=country_iso3)
+    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 mapzen 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_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;

server/extension/cdb_dataservices_server.control

@@ -1,5 +1,5 @@
 comment = 'CartoDB dataservices server extension'
-default_version = '0.5.0'
+default_version = '0.6.2'
 requires = 'plpythonu, postgis, cdb_geocoder'
 superuser = true
 schema = cdb_dataservices_server

server/extension/old_versions/cdb_dataservices_server--0.5.0--0.5.1.sql

@@ -0,0 +1,600 @@
+--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
+DROP FUNCTION IF EXISTS cdb_dataservices_server._get_redis_conf_v2(text);
+DROP TYPE IF EXISTS cdb_dataservices_server._redis_conf_params;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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_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)
+
+    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:
+      shape_linestring = polyline_to_linestring(resp.shape)
+      quota_service.increment_success_service_use()
+      return [shape_linestring, resp.length, resp.duration]
+    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 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;

server/extension/old_versions/cdb_dataservices_server--0.5.1--0.5.0.sql

@@ -0,0 +1,651 @@
+--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.0'" to load this file. \quit
+DROP FUNCTION IF EXISTS cdb_dataservices_server._get_internal_geocoder_config(text, text);
+
+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;
+
+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;
+
+-- 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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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;
+
+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)
+
+    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:
+      shape_linestring = polyline_to_linestring(resp.shape)
+      quota_service.increment_success_geocoder_use()
+      return [shape_linestring, resp.length, resp.duration]
+    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 route using mapzen provider: {0}'.format(e)
+    plpy.notice(traceback.format_tb(traceback_))
+    plpy.error(error_msg)
+  finally:
+    quota_service.increment_total_geocoder_use()
+$$ LANGUAGE plpythonu SECURITY DEFINER;

server/extension/old_versions/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;

server/extension/old_versions/cdb_dataservices_server--0.5.1.sql

@@ -0,0 +1,970 @@
+--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)
+
+    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:
+      shape_linestring = polyline_to_linestring(resp.shape)
+      quota_service.increment_success_service_use()
+      return [shape_linestring, resp.length, resp.duration]
+    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 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$$;

server/extension/old_versions/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,
@@ -39,17 +35,17 @@ RETURNS cdb_dataservices_server.simple_route AS $$
 
     if resp:
       shape_linestring = polyline_to_linestring(resp.shape)
-      quota_service.increment_success_geocoder_use()
+      quota_service.increment_success_service_use()
       return [shape_linestring, resp.length, resp.duration]
     else:
-      quota_service.increment_empty_geocoder_use()
+      quota_service.increment_empty_service_use()
   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()
-$$ LANGUAGE plpythonu SECURITY DEFINER;
+    quota_service.increment_total_service_use()
+$$ LANGUAGE plpythonu SECURITY DEFINER;

server/extension/old_versions/cdb_dataservices_server--0.5.2--0.6.0.sql

@@ -1,4 +1,6 @@
--- Geocodes a street address given a searchtext and a state and/or country
+--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.6.0'" to load this file. \quit
 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))
@@ -12,47 +14,41 @@ RETURNS Geometry AS $$
   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']
+  elif user_geocoder_config.mapzen_geocoder:
+    mapzen_plan = plpy.prepare("SELECT cdb_dataservices_server._cdb_mapzen_geocode_street_point($1, $2, $3, $4, $5, $6) as point; ", ["text", "text", "text", "text", "text", "text"])
+    return plpy.execute(mapzen_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)
+CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_mapzen_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
+  from cartodb_services.mapzen import MapzenGeocoder
+  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 = 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')
+  quota_service = QuotaService(user_geocoder_config, redis_conn)
 
   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
+    geocoder = MapzenGeocoder(user_geocoder_config.mapzen_app_key)
+    coordinates = geocoder.geocode(searchtext, country=country)
+    if coordinates:
+      quota_service.increment_success_service_use()
+      plan = plpy.prepare("SELECT ST_SetSRID(ST_MakePoint($1, $2), 4326) as point; ", ["double precision", "double precision"])
+      point = plpy.execute(plan, [coordinates[0], coordinates[1]], 1)[0]
+      return point['point']
+    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_geocoder_use()
-    error_msg = 'There was an error trying to geocode using here maps geocoder: {0}'.format(e)
+    quota_service.increment_failed_service_use()
+    error_msg = 'There was an error trying to geocode using mapzen 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;
+  finally:
+    quota_service.increment_total_service_use()
+$$ LANGUAGE plpythonu;

server/extension/old_versions/cdb_dataservices_server--0.5.2.sql

@@ -0,0 +1,974 @@
+--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)
+
+    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)
+      quota_service.increment_success_service_use()
+      return [shape_linestring, resp.length, resp.duration]
+    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 route using mapzen provider: {0}'.format(e)
+    plpy.warning('Resp shape: {0}'.format(resp.shape))
+    plpy.warning('Resp duration: {0}'.format(resp.duration))
+    plpy.warning('Resp length: {0}'.format(resp.length))
+    plpy.warning('Points: {0}, {1}'.format(origin, destination))
+    plpy.warning(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$$;

server/extension/old_versions/cdb_dataservices_server--0.6.0--0.5.2.sql

@@ -0,0 +1,22 @@
+--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
+DROP FUNCTION IF EXISTS cdb_dataservices_server._cdb_mapzen_geocode_street_point(TEXT, TEXT, TEXT, TEXT, TEXT, TEXT);
+
+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;

server/extension/old_versions/cdb_dataservices_server--0.6.0--0.6.1.sql

@@ -0,0 +1,39 @@
+--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.6.1'" to load this file. \quit
+CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_mapzen_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.mapzen import MapzenGeocoder
+  from cartodb_services.mapzen.types import country_to_iso3
+  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 = MapzenGeocoder(user_geocoder_config.mapzen_app_key)
+    country_iso3 = None
+    if country:
+      country_iso3 = country_to_iso3(country)
+    coordinates = geocoder.geocode(searchtext=searchtext, city=city,
+                                   state_province=state_province,
+                                   country=country_iso3)
+    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 mapzen geocoder: {0}'.format(e)
+    plpy.notice(traceback.format_tb(traceback_))
+    plpy.error(error_msg)
+  finally:
+    quota_service.increment_total_service_use()
+$$ LANGUAGE plpythonu;

server/extension/old_versions/cdb_dataservices_server--0.6.1--0.6.0.sql

@@ -0,0 +1,33 @@
+--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.6.0'" to load this file. \quit
+CREATE OR REPLACE FUNCTION cdb_dataservices_server._cdb_mapzen_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.mapzen import MapzenGeocoder
+  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 = MapzenGeocoder(user_geocoder_config.mapzen_app_key)
+    coordinates = geocoder.geocode(searchtext=searchtext, 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 mapzen geocoder: {0}'.format(e)
+    plpy.notice(traceback.format_tb(traceback_))
+    plpy.error(error_msg)
+  finally:
+    quota_service.increment_total_service_use()
+$$ LANGUAGE plpythonu;

server/extension/sql/0.0.1/10_redis_helper.sql

@@ -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;

server/extension/sql/0.0.1/20_geocode_street.sql

@@ -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;

server/extension/sql/0.0.1/30_admin0.sql

@@ -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;

server/extension/sql/0.0.1/40_admin1.sql

@@ -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;
-

server/extension/sql/0.0.1/50_namedplaces.sql

@@ -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;
-

server/extension/sql/0.0.1/60_postalcodes.sql

@@ -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;

server/extension/sql/0.0.1/70_ips.sql

@@ -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;

server/extension/sql/0.0.1/90_geocoder_server_user.sql

@@ -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$$;

server/extension/sql/0.1.0/00_header.sql

@@ -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

server/extension/sql/0.1.0/10_redis_helper.sql

@@ -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;

server/extension/sql/0.1.0/15_config_helper.sql

@@ -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;

server/extension/sql/0.1.0/30_admin0.sql

@@ -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;

server/extension/sql/0.1.0/40_admin1.sql

@@ -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;
-

server/extension/sql/0.1.0/50_namedplaces.sql

@@ -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;
-

server/extension/sql/0.1.0/60_postalcodes.sql

@@ -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;

server/extension/sql/0.1.0/70_ips.sql

@@ -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;

server/extension/sql/0.1.0/90_geocoder_server_user.sql

@@ -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$$;

server/extension/sql/0.2.0/00_header.sql

@@ -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

server/extension/sql/0.2.0/10_redis_helper.sql

@@ -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;

server/extension/sql/0.2.0/15_config_helper.sql

@@ -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;

server/extension/sql/0.2.0/20_geocode_street.sql

@@ -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;

server/extension/sql/0.2.0/30_admin0.sql

@@ -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;

server/extension/sql/0.2.0/40_admin1.sql

@@ -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;
-

server/extension/sql/0.2.0/50_namedplaces.sql

@@ -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;
-

server/extension/sql/0.2.0/60_postalcodes.sql

@@ -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;

server/extension/sql/0.2.0/70_ips.sql

@@ -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;

server/extension/sql/0.2.0/90_geocoder_server_user.sql

@@ -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$$;

server/extension/sql/0.3.0/00_header.sql

@@ -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

server/extension/sql/0.3.0/10_redis_helper.sql

@@ -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;

server/extension/sql/0.3.0/15_config_helper.sql

@@ -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;

server/extension/sql/0.3.0/30_admin0.sql

@@ -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;

server/extension/sql/0.3.0/40_admin1.sql

@@ -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;
-

server/extension/sql/0.3.0/50_namedplaces.sql

@@ -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;
-

server/extension/sql/0.3.0/90_geocoder_server_user.sql

@@ -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$$;

server/extension/sql/0.4.0/00_header.sql

@@ -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

server/extension/sql/0.4.0/10_redis_helper.sql

@@ -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;

server/extension/sql/0.4.0/15_config_helper.sql

@@ -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;

server/extension/sql/0.4.0/20_geocode_street.sql

@@ -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;

server/extension/sql/0.4.0/60_postalcodes.sql

@@ -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;

server/extension/sql/0.4.0/70_ips.sql

@@ -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;

server/extension/sql/0.4.0/99_geocoder_server_user.sql

@@ -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$$;

server/extension/sql/0.5.0/00_header.sql

@@ -1 +0,0 @@
-../0.4.0/00_header.sql

server/extension/sql/0.5.0/10_redis_helper.sql

@@ -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;

server/extension/sql/0.5.0/20_geocode_street.sql

@@ -1 +0,0 @@
-../0.4.0/20_geocode_street.sql

server/extension/sql/0.5.0/30_admin0.sql

@@ -1 +0,0 @@
-../0.4.0/30_admin0.sql

server/extension/sql/0.5.0/40_admin1.sql

@@ -1 +0,0 @@
-../0.4.0/40_admin1.sql

server/extension/sql/0.5.0/50_namedplaces.sql

@@ -1 +0,0 @@
-../0.4.0/50_namedplaces.sql

server/extension/sql/0.5.0/60_postalcodes.sql

@@ -1 +0,0 @@
-../0.4.0/60_postalcodes.sql

server/extension/sql/0.5.0/70_ips.sql

@@ -1 +0,0 @@
-../0.4.0/70_ips.sql

server/extension/sql/0.5.0/80_isolines_helper.sql

@@ -1 +0,0 @@
-../0.4.0/80_isolines_helper.sql

server/extension/sql/0.5.0/85_isodistance.sql

@@ -1 +0,0 @@
-../0.4.0/85_isodistance.sql