Release 2.53.4

Upgrades camshaft to 0.22.1

.travis.yml

@@ -1,9 +1,10 @@
 sudo: false
 
 addons:
-  postgresql: "9.3"
+  postgresql: "9.4"
   apt:
     packages:
+      - postgresql-plpython-9.4
       - pkg-config
       - libcairo2-dev
       - libjpeg8-dev

Makefile

@@ -43,7 +43,7 @@ jshint:
 	@echo "***jshint***"
 	@./node_modules/.bin/jshint lib/ test/ app.js
 
-test-all: jshint test
+test-all: test jshint
 
 coverage:
 	@RUNTESTFLAGS=--with-coverage make test

NEWS.md

@@ -1,5 +1,197 @@
 # Changelog
 
+## 2.53.4
+
+Released 2016-06-28
+
+Announcements:
+ - Upgrades camshaft to [0.22.4](https://github.com/CartoDB/camshaft/releases/tag/0.22.4)
+
+
+## 2.53.3
+
+Released 2016-06-28
+
+Announcements:
+ - Upgrades camshaft to [0.22.3](https://github.com/CartoDB/camshaft/releases/tag/0.22.3)
+
+
+## 2.53.2
+
+Released 2016-06-28
+
+Announcements:
+ - Upgrades camshaft to [0.22.2](https://github.com/CartoDB/camshaft/releases/tag/0.22.2)
+
+
+## 2.53.1
+
+Released 2016-06-28
+
+Announcements:
+ - Upgrades camshaft to [0.22.1](https://github.com/CartoDB/camshaft/releases/tag/0.22.1)
+
+
+## 2.53.0
+
+Released 2016-06-24
+
+Announcements:
+ - Upgrades camshaft to [0.22.0](https://github.com/CartoDB/camshaft/releases/tag/0.22.0)
+
+
+## 2.52.0
+
+Released 2016-06-23
+
+Announcements:
+ - Upgrades camshaft to [0.21.0](https://github.com/CartoDB/camshaft/releases/tag/0.21.0)
+
+
+## 2.51.0
+
+Released 2016-06-21
+
+Enhancements:
+ - Split turbo-carto adapter substitutions tokens query.
+ - Now errors with context have the same schema. #519
+
+Announcements:
+ - Upgrades camshaft to [0.20.0](https://github.com/CartoDB/camshaft/releases/tag/0.20.0)
+
+
+## 2.50.0
+
+Released 2016-06-21
+
+Bug fixes:
+ - Pixel size query for turbo-carto adapter using radians and degrees instead of meters.
+
+New features:
+ - Add support for min, max, and avg operations in aggregation dataview #513.
+
+Announcements:
+ - Upgrades camshaft to [0.19.0](https://github.com/CartoDB/camshaft/releases/tag/0.19.0)
+
+
+## 2.49.1
+
+Released 2016-06-20
+
+Announcements:
+ - Upgrades turbo-carto to [0.12.1](https://github.com/CartoDB/turbo-carto/releases/tag/0.12.1).
+
+Bug fixes:
+ - Use an empty array as default value for falsy ramps #512.
+ - Use the_geom for intermediate dataviews #511.
+ - Pick last update time for layergroupid from analyses results #510.
+
+
+## 2.49.0
+
+Released 2016-06-15
+
+Announcements:
+ - Upgrades camshaft to [0.17.1](https://github.com/CartoDB/camshaft/releases/tag/0.17.1)
+
+
+## 2.48.0
+
+Released 2016-06-14
+
+Announcements:
+ - Upgrades camshaft to [0.15.1](https://github.com/CartoDB/camshaft/releases/tag/0.15.1)
+ - Responses with more context info if analysis or turbo-carto fails during map creation.
+
+## 2.47.1
+
+Released 2016-06-13
+
+Announcements:
+ - Upgrades camshaft to [0.14.1](https://github.com/CartoDB/camshaft/releases/tag/0.14.1)
+
+
+## 2.47.0
+
+Released 2016-06-10
+
+Announcements:
+ - Upgrades camshaft to [0.14.0](https://github.com/CartoDB/camshaft/releases/tag/0.14.0)
+
+
+## 2.46.0
+
+Released 2016-06-09
+
+Improvements:
+ - Support for substitution tokens in geojson tiles
+ - Warn on application start about non-matching dependencies
+
+Announcements:
+ - Upgrades windshaft to [2.3.0](https://github.com/CartoDB/camshaft/releases/tag/2.3.0)
+ - Upgrades camshaft to [0.13.0](https://github.com/CartoDB/camshaft/releases/tag/0.13.0)
+ - Upgrades turbo-carto to [0.11.0](https://github.com/CartoDB/turbo-carto/releases/tag/0.11.0)
+
+Bug fixes:
+ - Column provided for geojson renderer should not be null #476
+ - Dataviews/widgets adapter working with non sql, non source, and non widgets layers
+
+
+## 2.45.0
+
+Released 2016-06-02
+
+Improvements:
+ - Removes Windshaft's widgets dependency.
+ - Makes widgets/dataviews endpoint compatible, but all using dataviews backend instead of widgets from Windshaft.
+ - Keeps adding widgets metadata in map instantiations for old clients.
+
+Announcements:
+ - Upgrades windshaft to [2.0.1](https://github.com/CartoDB/camshaft/releases/tag/2.0.1 )
+ - Upgrades camshaft to [0.12.1](https://github.com/CartoDB/camshaft/releases/tag/0.12.1)
+ - Upgrades turbo-carto to [0.10.1](https://github.com/CartoDB/turbo-carto/releases/tag/0.10.1)
+
+
+## 2.44.1
+
+Released 2016-06-01
+
+Improvements:
+ - Extend overviews support to histogram and aggregation dataviews
+ - Test improvements
+
+
+## 2.44.0
+
+Released 2016-05-31
+
+Announcements:
+ - Upgrades camshaft to [0.11.0](https://github.com/CartoDB/camshaft/releases/tag/0.11.0)
+ - Upgrades turbo-carto to [0.10.0](https://github.com/CartoDB/turbo-carto/releases/tag/0.10.0)
+
+New features:
+ - Adds support for sql wrap in all layers
+
+Bug fixes:
+ - Fail on turbo-carto invalid quantification methods
+
+
+## 2.43.1
+
+Released 2016-05-19
+
+Bug fixes:
+ - Dataview error when bbox present without query rewrite data #458
+
+
+## 2.43.0
+
+Released 2016-05-18
+
+New features:
+ - Overviews now support dataviews and filtering #449
+
+
 ## 2.42.2
 
 Released 2016-05-17

docs/MapConfig-Analyses-extension.md

@@ -0,0 +1,93 @@
+# 1. Purpose
+
+This specification describes an extension for
+[MapConfig 1.4.0](https://github.com/CartoDB/Windshaft/blob/master/doc/MapConfig-1.4.0.md) version.
+
+
+# 2. Changes over specification
+
+This extension targets layers with `sql` option, including layer types: `cartodb`, `mapnik`, and `torque`.
+
+It extends MapConfig with a new attribute: `analyses`.
+
+## 2.1 Analyses attribute
+
+The new analyses attribute must be an array of analyses as per [camshaft](https://github.com/CartoDB/camshaft). Each
+analysis must adhere to the [camshaft-reference](https://github.com/CartoDB/camshaft/blob/0.8.0/reference/versions/0.7.0/reference.json) specification.
+
+Each node can have an id that can be later references to consume the query from MapConfig's layers.
+
+Basic analyses example:
+
+```javascript
+[
+    {
+        // REQUIRED
+        // string, `id` free identifier that can be reference from any layer
+        "id": "HEAD",
+        // REQUIRED
+        // string, `type` camshaft's analysis type
+        "type": "source",
+        // REQUIRED
+        // object, `params` will depend on `type`, check camshaft-reference for more information
+        "params": {
+            "query": "select * from your_table"
+        }
+    }
+]
+```
+
+# 2.2. Integration with layers
+
+As pointed before an analysis node id can be referenced from layers to consume its output query.
+
+The layer consuming the output must reference it with the following option:
+
+```
+{
+    "options": {
+        // REQUIRED
+        // object, `source` as in the future we might want to have other source options
+        "source": {
+            // REQUIRED
+            // string, `id` the analysis node identifier
+            "id": "HEAD"
+        }
+    }
+}
+```
+
+## 2.3. Complete example
+
+```
+{
+    "version": "1.4.0",
+    "layers": [
+        {
+            "type": "cartodb",
+            "options": {
+                "source": {
+                    "id": "HEAD"
+                },
+                "cartocss": "...",
+                "cartocss_version": "2.3.0"
+            }
+        }
+    ],
+    "analyses": [
+        {
+            "id": "HEAD",
+            "type": "source",
+            "params": {
+                "query": "select * from your_table"
+            }
+        }
+    ]
+}
+```
+
+# History
+
+## 1.0.0
+
+ - Initial version

docs/MapConfig-Dataviews-extension.md

@@ -0,0 +1,314 @@
+# 1. Purpose
+
+This specification describes an extension for
+[MapConfig 1.4.0](https://github.com/CartoDB/Windshaft/blob/master/doc/MapConfig-1.4.0.md) version.
+
+
+# 2. Changes over specification
+
+This extension depends on Analyses extension. It extends MapConfig with a new attribute: `dataviews`.
+
+It makes possible to get tabular data from analysis nodes: lists, aggregated lists, aggregations, and histograms.
+
+## 2.1. Dataview types
+
+### List
+
+A list is a simple result set per row where is possible to retrieve several columns from the original layer query.
+
+Definition
+```
+{
+    // REQUIRED
+    // string, `type` the list type
+    “type”: “list”,
+    // REQUIRED
+    // object, `options` dataview params
+    “options”: {
+        // REQUIRED
+        // array, `columns` to select for the list
+        “columns”: [“name”, “description”]
+    }
+}
+```
+
+Expected output
+```
+{
+  "type": "list",
+  "rows": [
+    {
+      "{columnName1}": "val1",
+      "{columnName2}": 100
+    },
+    {
+      "{columnName1}": "val2",
+      "{columnName2}": 200
+    }
+  ]
+}
+```
+
+### Aggregation
+
+An aggregation is very similar to a list but results are aggregated by a column and a given aggregation function.
+
+Definition
+```
+{
+    // REQUIRED
+    // string, `type` the aggregation type
+    “type”: “aggregation”,
+    // REQUIRED
+    // object, `options` dataview params
+    “options”: {
+        // REQUIRED
+        // string, `column` column name to aggregate by
+        “column”: “country”,
+        // REQUIRED
+        // string, `aggregation` operation to perform
+        “aggregation”: “count”
+        // OPTIONAL
+        // string, `aggregationColumn` column value to aggregate
+        // This param is required when `aggregation` is different than "count"
+        “aggregationColumn”: “population”
+    }
+}
+```
+
+Expected output
+```
+{
+  "type": "aggregation",
+  "categories": [
+    {
+      "category": "foo",
+      "value": 100
+    },
+    {
+      "category": "bar",
+      "value": 200
+    }
+  ]
+}
+```
+
+### Histograms
+
+Histograms represent the data distribution for a column.
+
+Definition
+```
+{
+    // REQUIRED
+    // string, `type` the histogram type
+    “type”: “histogram”,
+    // REQUIRED
+    // object, `options` dataview params
+    “options”: {
+        // REQUIRED
+        // string, `column` column name to aggregate by
+        “column”: “name”,
+        // OPTIONAL
+        // number, `bins` how many buckets the histogram should use
+        “bins”: 10
+    }
+}
+```
+
+Expected output
+```
+{
+  "type": "histogram",
+  "bins": [{"bin": 0, "start": 2, "end": 2, "min": 2, "max": 2, "freq": 1}, null, null, {"bin": 3, "min": 40, "max": 44, "freq": 2}, null],
+  "width": 10
+}
+```
+
+### Formula
+
+Formulas given a final value representing the whole dataset.
+
+Definition
+```
+{
+    // REQUIRED
+    // string, `type` the formula type
+    “type”: “formula”,
+    // REQUIRED
+    // object, `options` dataview params
+    “options”: {
+        // REQUIRED
+        // string, `column` column name to aggregate by
+        “column”: “name”,
+        // REQUIRED
+        // string, `aggregation` operation to perform
+        “operation”: “count”
+    }
+}
+```
+
+Operation must be: “min”, “max”, “count”, “avg”, or “sum”.
+
+Result
+```
+{
+  "type": "formula",
+  "operation": "count",
+  "result": 1000,
+  "nulls": 0
+}
+```
+
+
+## 2.2 Dataviews attribute
+
+The new dataviews attribute must be a dictionary of dataviews.
+
+An analysis node id can be referenced from dataviews to consume its output query.
+
+
+The layer consuming the output must reference it with the following option:
+
+```
+{
+    // REQUIRED
+    // object, `source` as in the future we might want to have other source options
+    "source": {
+        // REQUIRED
+        // string, `id` the analysis node identifier
+        "id": "HEAD"
+    }
+}
+```
+
+## 2.3. Complete example
+
+```
+{
+    "version": "1.4.0",
+    "layers": [
+        {
+            "type": "cartodb",
+            "options": {
+                "source": {
+                    "id": "HEAD"
+                },
+                "cartocss": "...",
+                "cartocss_version": "2.3.0"
+            }
+        }
+    ],
+    "dataviews" {
+        "basic_histogram": {
+            "source": {
+                "id": "HEAD"
+            },
+            "type": "histogram",
+            "options": {
+                "column": "pop_max"
+            }
+        }
+    },
+    "analyses": [
+        {
+            "id": "HEAD",
+            "type": "source",
+            "params": {
+                "query": "select * from your_table"
+            }
+        }
+    ]
+}
+```
+
+## 3. Filters
+
+Camshaft's analyses expose a filtering capability and `aggregation` and `histogram` dataviews get them for free with
+ this extension. Filters are available with the very dataview id, so if you have a "basic_histogram" histogram dataview
+ you can filter with a range filter with "basic_histogram" name.
+
+
+## 3.1 Filter types
+
+### Category
+
+Allows to remove results that are not contained within a set of elements.
+Initially this filter can be applied to a `numeric` or `text` columns.
+
+Params
+
+```
+{
+    “accept”: [“Spain”, “Germany”]
+    “reject”: [“Japan”]
+}
+```
+
+### Range filter
+
+Allows to remove results that don’t satisfy numeric min and max values.
+Filter is applied to a numeric column.
+
+Params
+
+```
+{
+    “min”: 0,
+    “max”: 1000
+}
+```
+
+## 3.2. How to apply filters
+
+Filters must be applied at map instantiation time.
+
+With :mapconfig as a valid MapConfig and with :filters (a valid JSON) as:
+
+### Anonymous map
+
+`GET /api/v1/map?config=:mapconfig&filters=:filters`
+
+`POST /api/v1/map?filters=:filters`
+with `BODY=:mapconfig`
+
+If in the future we need to support a bigger filters param and it doesn’t fit in the query string,
+ we might solve it by accepting:
+
+`POST /api/v1/map`
+with `BODY={“config”: :mapconfig, “filters”: :filters}`
+
+### Named map
+
+Assume :params (a valid JSON) as named maps params, like in: `{“color”: “red”}`
+
+`GET /api/v1/named/:name/jsonp?config=:params&filters=:filters&callback=cb`
+
+`POST /api/v1/named/:name?filters=:filters`
+with `BODY=:params`
+
+If, again, in the future we need to support a bigger filters param that doesn’t fit in the query string,
+ we might solve it by accepting:
+
+`POST /api/v1/named/:name`
+with `BODY={“config”: :params, “filters”: :filters}`
+
+
+## 3.3 Bounding box special filter
+
+A bounding box filter allows to remove results that don’t satisfy a geospatial range.
+
+The bounding box special filter is available per dataview and there is no need to create a bounding box definition as
+it’s always possible to apply a bbox filter per dataview.
+
+A dataview can get its result filtered by bounding box by sending a bbox param in the query string,
+param must be in the form `west,south,east,north`.
+
+So applying a bbox filter to a dataview looks like:
+GET /api/v1/map/:layergroupid/dataview/:dataview_name?bbox=-90,-45,90,45
+
+# History
+
+## 1.0.0-alpha
+
+ - WIP document

lib/cartodb/api/filter_stats_api.js

@@ -0,0 +1,59 @@
+var _ = require('underscore');
+var step = require('step');
+var CamshaftFilter = require('../models/filter/camshaft');
+
+function FilterStatsApi(pgQueryRunner) {
+    this.pgQueryRunner = pgQueryRunner;
+}
+
+module.exports = FilterStatsApi;
+
+function getEstimatedRows(pgQueryRunner, username, query, callback) {
+    pgQueryRunner.run(username, "EXPLAIN (FORMAT JSON)"+query, function(err, result_rows) {
+        if (err){
+            callback(err);
+            return;
+        }
+        var rows;
+        if ( result_rows[0] && result_rows[0]['QUERY PLAN'] &&
+             result_rows[0]['QUERY PLAN'][0] && result_rows[0]['QUERY PLAN'][0].Plan ) {
+            rows = result_rows[0]['QUERY PLAN'][0].Plan['Plan Rows'];
+        }
+        return callback(null, rows);
+    });
+}
+
+FilterStatsApi.prototype.getFilterStats = function (username, unfiltered_query, filters, callback) {
+  var stats = {};
+  var self = this;
+  step(
+      function getUnfilteredRows() {
+          getEstimatedRows(self.pgQueryRunner, username, unfiltered_query, this);
+      },
+      function receiveUnfilteredRows(err, rows) {
+          if (err){
+              callback(err);
+              return;
+          }
+          stats.unfiltered_rows = rows;
+          this(null, rows);
+      },
+      function getFilteredRows() {
+          if ( filters && !_.isEmpty(filters)) {
+              var camshaftFilter = new CamshaftFilter(filters);
+              var query = camshaftFilter.sql(unfiltered_query);
+              getEstimatedRows(self.pgQueryRunner, username, query, this);
+          } else {
+              this(null, null);
+          }
+      },
+      function receiveFilteredRows(err, rows) {
+          if (err){
+              callback(err);
+              return;
+          }
+          stats.filtered_rows = rows;
+          callback(null, stats);
+      }
+  );
+};

lib/cartodb/backends/dataview.js

@@ -8,7 +8,16 @@ var step = require('step');
 var Timer = require('../stats/timer');
 
 var BBoxFilter = require('../models/filter/bbox');
+
 var DataviewFactory = require('../models/dataview/factory');
+var DataviewFactoryWithOverviews = require('../models/dataview/overviews/factory');
+var OverviewsQueryRewriter = require('../utils/overviews_query_rewriter');
+var overviewsQueryRewriter = new OverviewsQueryRewriter({
+    zoom_level: 'CDB_ZoomFromScale(!scale_denominator!)'
+});
+
+var dot = require('dot');
+dot.templateSettings.strip = false;
 
 function DataviewBackend(analysisBackend) {
     this.analysisBackend = analysisBackend;
@@ -16,7 +25,6 @@ function DataviewBackend(analysisBackend) {
 
 module.exports = DataviewBackend;
 
-
 DataviewBackend.prototype.getDataview = function (mapConfigProvider, user, params, callback) {
     var self = this;
 
@@ -100,20 +108,50 @@ DataviewBackend.prototype.getDataview = function (mapConfigProvider, user, param
             var ownFilter = +params.own_filter;
             ownFilter = !!ownFilter;
 
-            var query;
-            if (ownFilter) {
-                query = node.getQuery();
-            } else {
-                var applyFilters = {};
-                applyFilters[dataviewName] = false;
-                query = node.getQuery(applyFilters);
+            var query = layerQuery(node, dataviewName, ownFilter);
+
+            var sourceId =  dataviewDefinition.source.id; // node.id
+            var layer = _.find(
+                mapConfig.obj().layers,
+                function(l){ return l.options.source && (l.options.source.id === sourceId); }
+            );
+            var queryRewriteData = layer && layer.options.query_rewrite_data;
+            if ( queryRewriteData ) {
+                if ( node.type === 'source' ) {
+                    var filters = node.getFilters();
+                    var filters_disabler = Object.keys(filters).reduce(
+                        function(disabler, filter_id){ disabler[filter_id] = false; return disabler; },
+                        {}
+                    );
+                    var unfiltered_query = node.getQuery(filters_disabler);
+                    queryRewriteData = _.extend(
+                        {},
+                        queryRewriteData, { filters: filters, unfiltered_query: unfiltered_query }
+                    );
+                }
             }
 
             if (params.bbox) {
-                var bboxFilter = new BBoxFilter({column: 'the_geom', srid: 4326}, {bbox: params.bbox});
+                var bboxFilter = new BBoxFilter({column: 'the_geom_webmercator', srid: 3857}, {bbox: params.bbox});
                 query = bboxFilter.sql(query);
+                if ( queryRewriteData ) {
+                    var bbox_filter_definition = {
+                        type: 'bbox',
+                        options: {
+                            column: 'the_geom_webmercator',
+                            srid: 3857
+                        },
+                        params: {
+                            bbox: params.bbox
+                        }
+                    };
+                    queryRewriteData = _.extend(queryRewriteData, { bbox_filter: bbox_filter_definition });
+                }
             }
 
+            var dataviewFactory = DataviewFactoryWithOverviews.getFactory(
+                overviewsQueryRewriter, queryRewriteData, { bbox: params.bbox }
+            );
 
             var overrideParams = _.reduce(_.pick(params, 'start', 'end', 'bins'),
                 function castNumbers(overrides, val, k) {
@@ -123,7 +161,7 @@ DataviewBackend.prototype.getDataview = function (mapConfigProvider, user, param
                 {ownFilter: ownFilter}
             );
 
-            var dataview = DataviewFactory.getDataview(query, dataviewDefinition);
+            var dataview = dataviewFactory.getDataview(query, dataviewDefinition);
             dataview.getResult(pg, overrideParams, this);
         },
         function returnCallback(err, result) {
@@ -217,14 +255,7 @@ DataviewBackend.prototype.search = function (mapConfigProvider, user, params, ca
             var ownFilter = +params.own_filter;
             ownFilter = !!ownFilter;
 
-            var query;
-            if (ownFilter) {
-                query = node.getQuery();
-            } else {
-                var applyFilters = {};
-                applyFilters[dataviewName] = false;
-                query = node.getQuery(applyFilters);
-            }
+            var query = layerQuery(node, dataviewName, ownFilter);
 
             if (params.bbox) {
                 var bboxFilter = new BBoxFilter({column: 'the_geom', srid: 4326}, {bbox: params.bbox});
@@ -277,4 +308,32 @@ function dbParamsFromReqParams(params) {
         dbParams.dbname = params.dbname;
     }
     return dbParams;
-}
+}
+
+var SKIP_COLUMNS = {
+    'the_geom': true,
+    'the_geom_webmercator': true
+};
+
+function skipColumns(columnNames) {
+    return columnNames
+        .filter(function(columnName) { return !SKIP_COLUMNS[columnName]; });
+}
+
+var layerQueryTemplate = dot.template([
+    'SELECT {{=it._columns}}',
+    'FROM ({{=it._query}}) _cdb_analysis_query'
+].join('\n'));
+
+function layerQuery(node, dataviewName, ownFilter) {
+    var applyFilters = {};
+    if (!ownFilter) {
+        applyFilters[dataviewName] = false;
+    }
+
+    if (node.type === 'source') {
+        return node.getQuery(applyFilters);
+    }
+    var _columns = ['ST_Transform(the_geom, 3857) the_geom_webmercator'].concat(skipColumns(node.getColumns()));
+    return layerQueryTemplate({ _query: node.getQuery(applyFilters), _columns: _columns.join(', ') });
+}

lib/cartodb/backends/turbo-carto-postgres-datasource.js

@@ -0,0 +1,97 @@
+'use strict';
+
+var dot = require('dot');
+dot.templateSettings.strip = false;
+
+function createTemplate(method) {
+    return dot.template([
+        'SELECT',
+        method,
+        'FROM ({{=it._sql}}) _table_sql WHERE {{=it._column}} IS NOT NULL'
+    ].join('\n'));
+}
+
+var methods = {
+    quantiles: 'CDB_QuantileBins(array_agg(distinct({{=it._column}}::numeric)), {{=it._buckets}}) as quantiles',
+    equal: 'CDB_EqualIntervalBins(array_agg({{=it._column}}::numeric), {{=it._buckets}}) as equal',
+    jenks: 'CDB_JenksBins(array_agg(distinct({{=it._column}}::numeric)), {{=it._buckets}}) as jenks',
+    headtails: 'CDB_HeadsTailsBins(array_agg(distinct({{=it._column}}::numeric)), {{=it._buckets}}) as headtails'
+};
+
+var methodTemplates = Object.keys(methods).reduce(function(methodTemplates, methodName) {
+    methodTemplates[methodName] = createTemplate(methods[methodName]);
+    return methodTemplates;
+}, {});
+
+methodTemplates.category = dot.template([
+    'WITH',
+    'categories AS (',
+    '  SELECT {{=it._column}} AS category, count(1) AS value, row_number() OVER (ORDER BY count(1) desc) as rank',
+    '  FROM ({{=it._sql}}) _cdb_aggregation_all',
+    '  GROUP BY {{=it._column}}',
+    '  ORDER BY 2 DESC',
+    '),',
+    'agg_categories AS (',
+    '  SELECT \'__other\' category',
+    '  FROM categories',
+    '  WHERE rank >= {{=it._buckets}}',
+    '  GROUP BY 1',
+    '  UNION ALL',
+    '  SELECT CAST(category AS text)',
+    '  FROM categories',
+    '  WHERE rank < {{=it._buckets}}',
+    ')',
+    'SELECT array_agg(category) AS category FROM agg_categories'
+].join('\n'));
+
+var STRATEGY = {
+    SPLIT: 'split',
+    EXACT: 'exact'
+};
+
+var method2strategy = {
+    headtails: STRATEGY.SPLIT,
+    category: STRATEGY.EXACT
+};
+
+function PostgresDatasource (psql, query) {
+    this.psql = psql;
+    this.query = query;
+}
+
+PostgresDatasource.prototype.getName = function () {
+    return 'PostgresDatasource';
+};
+
+PostgresDatasource.prototype.getRamp = function (column, buckets, method, callback) {
+    if (method && !methodTemplates.hasOwnProperty(method)) {
+        return callback(new Error(
+            'Invalid method "' + method + '", valid methods: [' + Object.keys(methodTemplates).join(',') + ']'
+        ));
+    }
+    var methodName = method || 'quantiles';
+    var template = methodTemplates[methodName];
+
+    var query = template({ _column: column, _sql: this.query, _buckets: buckets });
+
+    this.psql.query(query, function (err, resultSet) {
+        if (err) {
+            return callback(err);
+        }
+
+        resultSet = resultSet || {};
+        var result = resultSet.rows || [];
+
+        var strategy = method2strategy[methodName];
+        var ramp = result[0][methodName] || [];
+        if (strategy !== STRATEGY.EXACT) {
+            ramp = ramp.sort(function(a, b) {
+                return a - b;
+            });
+        }
+
+        return callback(null, { ramp: ramp, strategy: strategy });
+    }, true); // use read-only transaction
+};
+
+module.exports = PostgresDatasource;

lib/cartodb/cache/named_map_provider_cache.js

@@ -1,24 +1,17 @@
 var _ = require('underscore');
 var dot = require('dot');
-var NamedMapMapConfigProvider = require('../models/mapconfig/named_map_provider');
-var MapConfigNamedLayersAdapter = require('../models/mapconfig_named_layers_adapter');
-var AnalysisMapConfigAdapter = require('../models/analysis-mapconfig-adapter');
+var NamedMapMapConfigProvider = require('../models/mapconfig/provider/named-map-provider');
 var templateName = require('../backends/template_maps').templateName;
 var queue = require('queue-async');
 
 var LruCache = require("lru-cache");
 
-function NamedMapProviderCache(templateMaps, pgConnection, metadataBackend, analysisBackend, userLimitsApi,
-                               overviewsAdapter, turboCartoAdapter) {
+function NamedMapProviderCache(templateMaps, pgConnection, metadataBackend, userLimitsApi, mapConfigAdapter) {
     this.templateMaps = templateMaps;
     this.pgConnection = pgConnection;
     this.metadataBackend = metadataBackend;
     this.userLimitsApi = userLimitsApi;
-
-    this.namedLayersAdapter = new MapConfigNamedLayersAdapter(templateMaps);
-    this.analysisMapConfigAdapter = new AnalysisMapConfigAdapter(analysisBackend);
-    this.overviewsAdapter = overviewsAdapter;
-    this.turboCartoAdapter = turboCartoAdapter;
+    this.mapConfigAdapter = mapConfigAdapter;
 
     this.providerCache = new LruCache({ max: 2000 });
 }
@@ -36,10 +29,7 @@ NamedMapProviderCache.prototype.get = function(user, templateId, config, authTok
             this.pgConnection,
             this.metadataBackend,
             this.userLimitsApi,
-            this.namedLayersAdapter,
-            this.overviewsAdapter,
-            this.turboCartoAdapter,
-            this.analysisMapConfigAdapter,
+            this.mapConfigAdapter,
             user,
             templateId,
             config,

lib/cartodb/controllers/base.js

@@ -214,15 +214,15 @@ BaseController.prototype.sendError = function(req, res, err, label) {
         statusCode = 200;
     }
 
-    var errorResponseBody = { errors: allErrors.map(errorMessage) };
+    var errorResponseBody = {
+        errors: allErrors.map(errorMessage),
+        errors_with_context: allErrors.map(errorMessageWithContext)
+    };
 
     this.send(req, res, errorResponseBody, statusCode);
 };
 
-function errorMessage(err) {
-    // See https://github.com/Vizzuality/Windshaft-cartodb/issues/68
-    var message = (_.isString(err) ? err : err.message) || 'Unknown error';
-
+function stripConnectionInfo(message) {
     // Strip connection info, if any
     return message
         // See https://github.com/CartoDB/Windshaft/issues/173
@@ -230,6 +230,24 @@ function errorMessage(err) {
         // See https://travis-ci.org/CartoDB/Windshaft/jobs/20703062#L1644
         .replace(/is the server.*encountered/im, 'encountered');
 }
+
+function errorMessage(err) {
+    // See https://github.com/Vizzuality/Windshaft-cartodb/issues/68
+    var message = (_.isString(err) ? err : err.message) || 'Unknown error';
+
+    return stripConnectionInfo(message);
+}
+
+function errorMessageWithContext(err) {
+    // See https://github.com/Vizzuality/Windshaft-cartodb/issues/68
+    var message = (_.isString(err) ? err : err.message) || 'Unknown error';
+
+    return {
+        type: err.type || 'unknown',
+        message: stripConnectionInfo(message),
+        context: err.context || 'unknown'
+    };
+}
 module.exports.errorMessage = errorMessage;
 
 function findStatusCode(err) {

lib/cartodb/controllers/layergroup.js

@@ -10,7 +10,7 @@ var userMiddleware = require('../middleware/user');
 var DataviewBackend = require('../backends/dataview');
 var AnalysisStatusBackend = require('../backends/analysis-status');
 
-var MapStoreMapConfigProvider = require('../models/mapconfig/map_store_provider');
+var MapStoreMapConfigProvider = require('../models/mapconfig/provider/map-store-provider');
 
 var QueryTables = require('cartodb-query-tables');
 
@@ -21,7 +21,6 @@ var QueryTables = require('cartodb-query-tables');
  * @param {TileBackend} tileBackend
  * @param {PreviewBackend} previewBackend
  * @param {AttributesBackend} attributesBackend
- * @param {WidgetBackend} widgetBackend
  * @param {SurrogateKeysCache} surrogateKeysCache
  * @param {UserLimitsApi} userLimitsApi
  * @param {LayergroupAffectedTables} layergroupAffectedTables
@@ -29,7 +28,7 @@ var QueryTables = require('cartodb-query-tables');
  * @constructor
  */
 function LayergroupController(authApi, pgConnection, mapStore, tileBackend, previewBackend, attributesBackend,
-                          widgetBackend, surrogateKeysCache, userLimitsApi, layergroupAffectedTables, analysisBackend) {
+                              surrogateKeysCache, userLimitsApi, layergroupAffectedTables, analysisBackend) {
     BaseController.call(this, authApi, pgConnection);
 
     this.pgConnection = pgConnection;
@@ -37,7 +36,6 @@ function LayergroupController(authApi, pgConnection, mapStore, tileBackend, prev
     this.tileBackend = tileBackend;
     this.previewBackend = previewBackend;
     this.attributesBackend = attributesBackend;
-    this.widgetBackend = widgetBackend;
     this.surrogateKeysCache = surrogateKeysCache;
     this.userLimitsApi = userLimitsApi;
     this.layergroupAffectedTables = layergroupAffectedTables;
@@ -78,21 +76,19 @@ LayergroupController.prototype.register = function(app) {
 
     // Undocumented/non-supported API endpoint methods.
     // Use at your own peril.
-    app.get(app.base_url_mapconfig +
-        '/:token/:layer/widget/:widgetName', cors(), userMiddleware,
-        this.widget.bind(this));
-
-    app.get(app.base_url_mapconfig +
-            '/:token/:layer/widget/:widgetName/search', cors(), userMiddleware,
-        this.widgetSearch.bind(this));
-
     app.get(app.base_url_mapconfig +
             '/:token/dataview/:dataviewName', cors(), userMiddleware,
         this.dataview.bind(this));
+    app.get(app.base_url_mapconfig +
+            '/:token/:layer/widget/:dataviewName', cors(), userMiddleware,
+        this.dataview.bind(this));
 
     app.get(app.base_url_mapconfig +
             '/:token/dataview/:dataviewName/search', cors(), userMiddleware,
         this.dataviewSearch.bind(this));
+    app.get(app.base_url_mapconfig +
+            '/:token/:layer/widget/:dataviewName/search', cors(), userMiddleware,
+        this.dataviewSearch.bind(this));
 
     app.get(app.base_url_mapconfig +
         '/:token/analysis/node/:nodeId', cors(), userMiddleware,
@@ -181,62 +177,6 @@ LayergroupController.prototype.dataviewSearch = function(req, res) {
 
 };
 
-LayergroupController.prototype.widget = function(req, res) {
-    var self = this;
-
-    step(
-        function setupParams() {
-            self.req2params(req, this);
-        },
-        function retrieveList(err) {
-            assert.ifError(err);
-
-            var mapConfigProvider = new MapStoreMapConfigProvider(
-                self.mapStore, req.context.user, self.userLimitsApi, req.params
-            );
-            self.widgetBackend.getWidget(mapConfigProvider, req.params, this);
-        },
-        function finish(err, widget, stats) {
-            req.profiler.add(stats || {});
-
-            if (err) {
-                self.sendError(req, res, err, 'GET WIDGET');
-            } else {
-                self.sendResponse(req, res, widget, 200);
-            }
-        }
-    );
-
-};
-
-LayergroupController.prototype.widgetSearch = function(req, res) {
-    var self = this;
-
-    step(
-        function setupParams() {
-            self.req2params(req, this);
-        },
-        function retrieveList(err) {
-            assert.ifError(err);
-
-            var mapConfigProvider = new MapStoreMapConfigProvider(
-                self.mapStore, req.context.user, self.userLimitsApi, req.params
-            );
-            self.widgetBackend.search(mapConfigProvider, req.params, this);
-        },
-        function finish(err, searchResult, stats) {
-            req.profiler.add(stats || {});
-
-            if (err) {
-                self.sendError(req, res, err, 'GET WIDGET');
-            } else {
-                self.sendResponse(req, res, searchResult, 200);
-            }
-        }
-    );
-
-};
-
 LayergroupController.prototype.attributes = function(req, res) {
     var self = this;
 

lib/cartodb/controllers/map.js

@@ -15,10 +15,8 @@ var Datasource = windshaft.model.Datasource;
 
 var NamedMapsCacheEntry = require('../cache/model/named_maps_entry');
 
-var MapConfigNamedLayersAdapter = require('../models/mapconfig_named_layers_adapter');
-var AnalysisMapConfigAdapter = require('../models/analysis-mapconfig-adapter');
-var NamedMapMapConfigProvider = require('../models/mapconfig/named_map_provider');
-var CreateLayergroupMapConfigProvider = require('../models/mapconfig/create_layergroup_provider');
+var NamedMapMapConfigProvider = require('../models/mapconfig/provider/named-map-provider');
+var CreateLayergroupMapConfigProvider = require('../models/mapconfig/provider/create-layergroup-provider');
 
 /**
  * @param {AuthApi} authApi
@@ -29,14 +27,11 @@ var CreateLayergroupMapConfigProvider = require('../models/mapconfig/create_laye
  * @param {SurrogateKeysCache} surrogateKeysCache
  * @param {UserLimitsApi} userLimitsApi
  * @param {LayergroupAffectedTables} layergroupAffectedTables
- * @param {MapConfigOverviewsAdapter} overviewsAdapter
- * @param {TurboCartoAdapter} turboCartoAdapter
- * @param {AnalysisBackend} analysisBackend
+ * @param {MapConfigAdapter} mapConfigAdapter
  * @constructor
  */
 function MapController(authApi, pgConnection, templateMaps, mapBackend, metadataBackend,
-                       surrogateKeysCache, userLimitsApi, layergroupAffectedTables,
-                       overviewsAdapter, turboCartoAdapter, analysisBackend) {
+                       surrogateKeysCache, userLimitsApi, layergroupAffectedTables, mapConfigAdapter) {
 
     BaseController.call(this, authApi, pgConnection);
 
@@ -47,11 +42,8 @@ function MapController(authApi, pgConnection, templateMaps, mapBackend, metadata
     this.surrogateKeysCache = surrogateKeysCache;
     this.userLimitsApi = userLimitsApi;
     this.layergroupAffectedTables = layergroupAffectedTables;
-    this.turboCartoAdapter = turboCartoAdapter;
 
-    this.analysisMapConfigAdapter = new AnalysisMapConfigAdapter(analysisBackend);
-    this.namedLayersAdapter = new MapConfigNamedLayersAdapter(templateMaps);
-    this.overviewsAdapter = overviewsAdapter;
+    this.mapConfigAdapter = mapConfigAdapter;
 }
 
 util.inherits(MapController, BaseController);
@@ -132,16 +124,17 @@ MapController.prototype.create = function(req, res, prepareConfigFn) {
     var self = this;
 
     var mapConfig;
-    var analysesResults = [];
+
+    var context = {};
 
     step(
         function setupParams(){
             self.req2params(req, this);
         },
         prepareConfigFn,
-        function prepareAnalysisLayers(err, requestMapConfig) {
+        function prepareAdapterMapConfig(err, requestMapConfig) {
             assert.ifError(err);
-            var analysisConfiguration = {
+            context.analysisConfiguration = {
                 db: {
                     host: req.params.dbhost,
                     port: req.params.dbport,
@@ -154,68 +147,12 @@ MapController.prototype.create = function(req, res, prepareConfigFn) {
                     apiKey: req.params.api_key
                 }
             };
-
-            var filters = {};
-            if (req.params.filters) {
-                try {
-                    filters = JSON.parse(req.params.filters);
-                } catch (e) {
-                    // ignore
-                }
-            }
-            self.analysisMapConfigAdapter.getMapConfig(analysisConfiguration, requestMapConfig, filters, this);
+            self.mapConfigAdapter.getMapConfig(req.context.user, requestMapConfig, req.params, context, this);
         },
-        function beforeLayergroupCreate(err, requestMapConfig, _analysesResults) {
+        function createLayergroup(err, requestMapConfig) {
             assert.ifError(err);
-            var next = this;
-            analysesResults = _analysesResults;
-            self.namedLayersAdapter.getLayers(req.context.user, requestMapConfig.layers, self.pgConnection,
-                function(err, layers, datasource) {
-                    if (err) {
-                        return next(err);
-                    }
-
-                    if (layers) {
-                        requestMapConfig.layers = layers;
-                    }
-                    return next(null, requestMapConfig, datasource);
-                }
-            );
-        },
-        function addOverviewsInformation(err, requestMapConfig, datasource) {
-            assert.ifError(err);
-            var next = this;
-            self.overviewsAdapter.getLayers(req.context.user, requestMapConfig.layers, function(err, layers) {
-                if (err) {
-                    return next(err);
-                }
-
-                if (layers) {
-                    requestMapConfig.layers = layers;
-                }
-
-                return next(null, requestMapConfig, datasource);
-            });
-        },
-        function parseTurboCarto(err, requestMapConfig, datasource) {
-            assert.ifError(err);
-
-            var next = this;
-            self.turboCartoAdapter.getLayers(req.context.user, requestMapConfig.layers, function (err, layers) {
-                if (err) {
-                    return next(err);
-                }
-
-                if (layers) {
-                    requestMapConfig.layers = layers;
-                }
-
-                return next(null, requestMapConfig, datasource);
-            });
-        },
-        function createLayergroup(err, requestMapConfig, datasource) {
-            assert.ifError(err);
-            mapConfig = new MapConfig(requestMapConfig, datasource || Datasource.EmptyDatasource());
+            var datasource = context.datasource || Datasource.EmptyDatasource();
+            mapConfig = new MapConfig(requestMapConfig, datasource);
             self.mapBackend.createLayergroup(
                 mapConfig, req.params,
                 new CreateLayergroupMapConfigProvider(mapConfig, req.context.user, self.userLimitsApi, req.params),
@@ -224,14 +161,15 @@ MapController.prototype.create = function(req, res, prepareConfigFn) {
         },
         function afterLayergroupCreate(err, layergroup) {
             assert.ifError(err);
-            self.afterLayergroupCreate(req, res, mapConfig, analysesResults, layergroup, this);
+            self.afterLayergroupCreate(req, res, mapConfig, layergroup, context.analysesResults, this);
         },
         function finish(err, layergroup) {
             if (err) {
                 self.sendError(req, res, err, 'ANONYMOUS LAYERGROUP');
             } else {
-                addWidgetsUrl(req.context.user, layergroup);
-
+                var analysesResults = context.analysesResults || [];
+                addDataviewsAndWidgetsUrls(req.context.user, layergroup, mapConfig.obj());
+                addAnalysesMetadata(req.context.user, layergroup, analysesResults, true);
                 res.set('X-Layergroup-Id', layergroup.layergroupid);
                 self.send(req, res, layergroup, 200);
             }
@@ -261,10 +199,7 @@ MapController.prototype.instantiateTemplate = function(req, res, prepareParamsFn
                 self.pgConnection,
                 self.metadataBackend,
                 self.userLimitsApi,
-                self.namedLayersAdapter,
-                self.overviewsAdapter,
-                self.turboCartoAdapter,
-                self.analysisMapConfigAdapter,
+                self.mapConfigAdapter,
                 cdbuser,
                 req.params.template_id,
                 templateParams,
@@ -284,7 +219,7 @@ MapController.prototype.instantiateTemplate = function(req, res, prepareParamsFn
         },
         function afterLayergroupCreate(err, layergroup) {
             assert.ifError(err);
-            self.afterLayergroupCreate(req, res, mapConfig, [], layergroup, this);
+            self.afterLayergroupCreate(req, res, mapConfig, layergroup, mapConfigProvider.analysesResults, this);
         },
         function finishTemplateInstantiation(err, layergroup) {
             if (err) {
@@ -293,8 +228,7 @@ MapController.prototype.instantiateTemplate = function(req, res, prepareParamsFn
                 var templateHash = self.templateMaps.fingerPrint(mapConfigProvider.template).substring(0, 8);
                 layergroup.layergroupid = cdbuser + '@' + templateHash + '@' + layergroup.layergroupid;
 
-                addWidgetsUrl(cdbuser, layergroup);
-                addDataviewsUrls(cdbuser, layergroup, mapConfig.obj());
+                addDataviewsAndWidgetsUrls(cdbuser, layergroup, mapConfig.obj());
                 addAnalysesMetadata(cdbuser, layergroup, mapConfigProvider.analysesResults);
 
                 res.set('X-Layergroup-Id', layergroup.layergroupid);
@@ -306,8 +240,7 @@ MapController.prototype.instantiateTemplate = function(req, res, prepareParamsFn
     );
 };
 
-
-MapController.prototype.afterLayergroupCreate = function(req, res, mapconfig, analysesResults, layergroup, callback) {
+MapController.prototype.afterLayergroupCreate = function(req, res, mapconfig, layergroup, analysesResults, callback) {
     var self = this;
 
     var username = req.context.user;
@@ -366,14 +299,13 @@ MapController.prototype.afterLayergroupCreate = function(req, res, mapconfig, an
             // feed affected tables cache so it can be reused from, for instance, layergroup controller
             self.layergroupAffectedTables.set(dbName, layergroupId, result);
 
-            // last update for layergroup cache buster
-            layergroup.layergroupid = layergroup.layergroupid + ':' + result.getLastUpdatedAt();
-            layergroup.last_updated = new Date(result.getLastUpdatedAt()).toISOString();
+            var lastUpdateTime = result.getLastUpdatedAt();
+            lastUpdateTime = getLastUpdatedTime(analysesResults, lastUpdateTime) || lastUpdateTime;
+
+            // last update for layergroup cache buster
+            layergroup.layergroupid = layergroup.layergroupid + ':' + lastUpdateTime;
+            layergroup.last_updated = new Date(lastUpdateTime).toISOString();
 
-            // TODO this should take into account several URL patterns
-            addWidgetsUrl(username, layergroup);
-            addDataviewsUrls(username, layergroup, mapconfig.obj());
-            addAnalysesMetadata(username, layergroup, analysesResults, true);
             if (req.method === 'GET') {
                 var ttl = global.environment.varnish.layergroupTtl || 86400;
                 res.set('Cache-Control', 'public,max-age='+ttl+',must-revalidate');
@@ -392,6 +324,19 @@ MapController.prototype.afterLayergroupCreate = function(req, res, mapconfig, an
     );
 };
 
+function getLastUpdatedTime(analysesResults, lastUpdateTime) {
+    if (!Array.isArray(analysesResults)) {
+        return lastUpdateTime;
+    }
+    return analysesResults.reduce(function(lastUpdateTime, analysis) {
+        return analysis.getSortedNodes().reduce(function(lastNodeUpdatedAtTime, node) {
+            var nodeUpdatedAtDate = node.getUpdatedAt();
+            var nodeUpdatedTimeAt = (nodeUpdatedAtDate && nodeUpdatedAtDate.getTime()) || 0;
+            return nodeUpdatedTimeAt > lastNodeUpdatedAtTime ? nodeUpdatedTimeAt : lastNodeUpdatedAtTime;
+        }, lastUpdateTime);
+    }, lastUpdateTime);
+}
+
 function addAnalysesMetadata(username, layergroup, analysesResults, includeQuery) {
     includeQuery = includeQuery || false;
     analysesResults = analysesResults || [];
@@ -418,6 +363,12 @@ function addAnalysesMetadata(username, layergroup, analysesResults, includeQuery
     });
 }
 
+// TODO this should take into account several URL patterns
+function addDataviewsAndWidgetsUrls(username, layergroup, mapConfig) {
+    addDataviewsUrls(username, layergroup, mapConfig);
+    addWidgetsUrl(username, layergroup, mapConfig);
+}
+
 function addDataviewsUrls(username, layergroup, mapConfig) {
     layergroup.metadata.dataviews = layergroup.metadata.dataviews || {};
     var dataviews = mapConfig.dataviews || {};
@@ -430,20 +381,23 @@ function addDataviewsUrls(username, layergroup, mapConfig) {
     });
 }
 
-function addWidgetsUrl(username, layergroup) {
-
-    if (layergroup.metadata && Array.isArray(layergroup.metadata.layers)) {
+function addWidgetsUrl(username, layergroup, mapConfig) {
+    if (layergroup.metadata && Array.isArray(layergroup.metadata.layers) && Array.isArray(mapConfig.layers)) {
         layergroup.metadata.layers = layergroup.metadata.layers.map(function(layer, layerIndex) {
-            if (layer.widgets) {
-                Object.keys(layer.widgets).forEach(function(widgetName) {
+            var mapConfigLayer = mapConfig.layers[layerIndex];
+            if (mapConfigLayer.options && mapConfigLayer.options.widgets) {
+                layer.widgets = layer.widgets || {};
+                Object.keys(mapConfigLayer.options.widgets).forEach(function(widgetName) {
                     var resource = layergroup.layergroupid + '/' + layerIndex + '/widget/' + widgetName;
-                    layer.widgets[widgetName].url = getUrls(username, resource);
+                    layer.widgets[widgetName] = {
+                        type: mapConfigLayer.options.widgets[widgetName].type,
+                        url: getUrls(username, resource)
+                    };
                 });
             }
             return layer;
         });
     }
-
 }
 
 function getUrls(username, resource) {

lib/cartodb/controllers/server_info.js

@@ -1,21 +1,13 @@
-var windshaft = require('windshaft');
 var HealthCheck = require('../monitoring/health_check');
 
 var WELCOME_MSG = "This is the CartoDB Maps API, " +
     "see the documentation at http://docs.cartodb.com/cartodb-platform/maps-api.html";
 
 
-var versions = {
-    windshaft: windshaft.version,
-    grainstore: windshaft.grainstore.version(),
-    node_mapnik: windshaft.mapnik.version,
-    mapnik: windshaft.mapnik.versions.mapnik,
-    windshaft_cartodb: require('../../../package.json').version
-};
-
-function ServerInfoController() {
+function ServerInfoController(versions) {
     this.healthConfig = global.environment.health || {};
     this.healthCheck = new HealthCheck(global.environment.disabled_file);
+    this.versions = versions || {};
 }
 
 module.exports = ServerInfoController;
@@ -31,7 +23,7 @@ ServerInfoController.prototype.welcome = function(req, res) {
 };
 
 ServerInfoController.prototype.version = function(req, res) {
-    res.status(200).send(versions);
+    res.status(200).send(this.versions);
 };
 
 ServerInfoController.prototype.health = function(req, res) {

lib/cartodb/models/dataview/aggregation.js

@@ -54,7 +54,10 @@ var CATEGORIES_LIMIT = 6;
 
 var VALID_OPERATIONS = {
     count: [],
-    sum: ['aggregationColumn']
+    sum: ['aggregationColumn'],
+    avg: ['aggregationColumn'],
+    min: ['aggregationColumn'],
+    max: ['aggregationColumn']
 };
 
 var TYPE = 'aggregation';
@@ -102,7 +105,7 @@ Aggregation.prototype.constructor = Aggregation;
 
 module.exports = Aggregation;
 
-Aggregation.prototype.sql = function(psql, filters, override, callback) {
+Aggregation.prototype.sql = function(psql, override, callback) {
     if (!callback) {
         callback = override;
         override = {};
@@ -198,6 +201,7 @@ Aggregation.prototype.format = function(result) {
     }
 
     return {
+        aggregation: this.aggregation,
         count: count,
         nulls: nulls,
         min: minValue,

lib/cartodb/models/dataview/formula.js

@@ -56,7 +56,7 @@ Formula.prototype.constructor = Formula;
 
 module.exports = Formula;
 
-Formula.prototype.sql = function(psql, filters, override, callback) {
+Formula.prototype.sql = function(psql, override, callback) {
     if (!callback) {
         callback = override;
         override = {};

lib/cartodb/models/dataview/histogram.js

@@ -174,8 +174,8 @@ Histogram.prototype.sql = function(psql, override, callback) {
         basicsQuery = overrideBasicsQueryTpl({
             _query: _query,
             _column: _column,
-            _start: override.start,
-            _end: override.end
+            _start: getBinStart(override),
+            _end: getBinEnd(override)
         });
 
         binsQuery = [
@@ -248,7 +248,7 @@ Histogram.prototype.format = function(result, override) {
         width = firstRow.bin_width || width;
         avg = firstRow.avg_val;
         nulls = firstRow.nulls_count;
-        binsStart = override.hasOwnProperty('start') ? override.start : firstRow.min;
+        binsStart = override.hasOwnProperty('start') ? getBinStart(override) : firstRow.min;
 
         buckets = result.rows.map(function(row) {
             return _.omit(row, 'bins_number', 'bin_width', 'nulls_count', 'avg_val');
@@ -266,9 +266,19 @@ Histogram.prototype.format = function(result, override) {
 };
 
 function getBinStart(override) {
+    if (override.hasOwnProperty('start') && override.hasOwnProperty('end')) {
+        return Math.min(override.start, override.end);
+    }
     return override.start || 0;
 }
 
+function getBinEnd(override) {
+    if (override.hasOwnProperty('start') && override.hasOwnProperty('end')) {
+        return Math.max(override.start, override.end);
+    }
+    return override.end || 0;
+}
+
 function getBinsCount(override) {
     return override.bins || 0;
 }

lib/cartodb/models/dataview/list.js

@@ -34,7 +34,7 @@ List.prototype.constructor = List;
 
 module.exports = List;
 
-List.prototype.sql = function(psql, filters, override, callback) {
+List.prototype.sql = function(psql, override, callback) {
     if (!callback) {
         callback = override;
     }

lib/cartodb/models/dataview/overviews/aggregation.js

@@ -0,0 +1,141 @@
+var BaseOverviewsDataview = require('./base');
+var BaseDataview = require('../aggregation');
+
+var dot = require('dot');
+dot.templateSettings.strip = false;
+
+var summaryQueryTpl = dot.template([
+    'summary AS (',
+    '  SELECT',
+    '  sum(_feature_count) AS count,',
+    '  sum(CASE WHEN {{=it._column}} IS NULL THEN 1 ELSE 0 END) AS nulls_count',
+    '  FROM ({{=it._query}}) _cdb_aggregation_nulls',
+    ')'
+].join('\n'));
+
+var rankedCategoriesQueryTpl = dot.template([
+    'categories AS(',
+    '  SELECT {{=it._column}} AS category, {{=it._aggregation}} AS value,',
+    '    row_number() OVER (ORDER BY {{=it._aggregation}} desc) as rank',
+    '  FROM ({{=it._query}}) _cdb_aggregation_all',
+    '  GROUP BY {{=it._column}}',
+    '  ORDER BY 2 DESC',
+    ')'
+].join('\n'));
+
+var categoriesSummaryQueryTpl = dot.template([
+    'categories_summary AS(',
+    '  SELECT count(1) categories_count, max(value) max_val, min(value) min_val',
+    '  FROM categories',
+    ')'
+].join('\n'));
+
+var rankedAggregationQueryTpl = dot.template([
+    'SELECT CAST(category AS text), value, false as agg, nulls_count, min_val, max_val, count, categories_count',
+    '  FROM categories, summary, categories_summary',
+    '  WHERE rank < {{=it._limit}}',
+    'UNION ALL',
+    'SELECT \'Other\' category, sum(value), true as agg, nulls_count, min_val, max_val, count, categories_count',
+    '  FROM categories, summary, categories_summary',
+    '  WHERE rank >= {{=it._limit}}',
+    'GROUP BY nulls_count, min_val, max_val, count, categories_count'
+].join('\n'));
+
+var aggregationQueryTpl = dot.template([
+    'SELECT CAST({{=it._column}} AS text) AS category, {{=it._aggregation}} AS value, false as agg,',
+    '  nulls_count, min_val, max_val, count, categories_count',
+    'FROM ({{=it._query}}) _cdb_aggregation_all, summary, categories_summary',
+    'GROUP BY category, nulls_count, min_val, max_val, count, categories_count',
+    'ORDER BY value DESC'
+].join('\n'));
+
+var CATEGORIES_LIMIT = 6;
+
+ function Aggregation(query, options, queryRewriter, queryRewriteData, params) {
+    BaseOverviewsDataview.call(this, query, options, BaseDataview, queryRewriter, queryRewriteData, params);
+
+    this.query = query;
+    this.column = options.column;
+    this.aggregation = options.aggregation;
+    this.aggregationColumn = options.aggregationColumn;
+}
+
+Aggregation.prototype = Object.create(BaseOverviewsDataview.prototype);
+Aggregation.prototype.constructor = Aggregation;
+
+module.exports = Aggregation;
+
+Aggregation.prototype.sql = function(psql, filters, override, callback) {
+    if (!callback) {
+        callback = override;
+        override = {};
+    }
+
+    var _query = this.rewrittenQuery(this.query);
+
+    var aggregationSql;
+    if (!!override.ownFilter) {
+        aggregationSql = [
+            "WITH",
+            [
+                summaryQueryTpl({
+                    _query: _query,
+                    _column: this.column
+                }),
+                rankedCategoriesQueryTpl({
+                    _query: _query,
+                    _column: this.column,
+                    _aggregation: this.getAggregationSql()
+                }),
+                categoriesSummaryQueryTpl({
+                    _query: _query,
+                    _column: this.column
+                })
+            ].join(',\n'),
+            aggregationQueryTpl({
+                _query: _query,
+                _column: this.column,
+                _aggregation: this.getAggregationSql(),
+                _limit: CATEGORIES_LIMIT
+            })
+        ].join('\n');
+    } else {
+        aggregationSql = [
+            "WITH",
+            [
+                summaryQueryTpl({
+                    _query: _query,
+                    _column: this.column
+                }),
+                rankedCategoriesQueryTpl({
+                    _query: _query,
+                    _column: this.column,
+                    _aggregation: this.getAggregationSql()
+                }),
+                categoriesSummaryQueryTpl({
+                    _query: _query,
+                    _column: this.column
+                })
+            ].join(',\n'),
+            rankedAggregationQueryTpl({
+                _query: _query,
+                _column: this.column,
+                _limit: CATEGORIES_LIMIT
+            })
+        ].join('\n');
+    }
+
+    return callback(null, aggregationSql);
+};
+
+var aggregationFnQueryTpl = {
+    count: dot.template('sum(_feature_count)'),
+    sum:   dot.template('sum({{=it._aggregationColumn}}*_feature_count)')
+};
+
+Aggregation.prototype.getAggregationSql = function() {
+    return aggregationFnQueryTpl[this.aggregation]({
+        _aggregationFn: this.aggregation,
+        _aggregationColumn: this.aggregationColumn || 1
+    });
+};

lib/cartodb/models/dataview/overviews/base.js

@@ -0,0 +1,88 @@
+var _ = require('underscore');
+var BaseDataview = require('../base');
+
+function BaseOverviewsDataview(query, queryOptions, BaseDataview, queryRewriter, queryRewriteData, options) {
+  this.BaseDataview = BaseDataview;
+  this.query = query;
+  this.queryOptions = queryOptions;
+  this.queryRewriter = queryRewriter;
+  this.queryRewriteData = queryRewriteData;
+  this.options = options;
+  this.baseDataview = new this.BaseDataview(this.query, this.queryOptions);
+}
+
+module.exports = BaseOverviewsDataview;
+
+BaseOverviewsDataview.prototype = new BaseDataview();
+BaseOverviewsDataview.prototype.constructor = BaseOverviewsDataview;
+
+// TODO: parameterized these settings
+var SETTINGS = {
+    // use overviews as a default fallback strategy
+    defaultOverviews: false,
+
+    // minimum ratio of bounding box size to grid size
+    // (this would ideally be based on the viewport size in pixels)
+    zoomLevelFactor: 1024.0
+};
+
+// Compute zoom level so that the the resolution grid size of the
+// selected overview is smaller (zoomLevelFactor times smaller at least)
+// than the bounding box size.
+BaseOverviewsDataview.prototype.zoomLevelForBbox = function(bbox) {
+    var pxPerTile = 256.0;
+    var earthWidth = 360.0;
+    // TODO: now we assume overviews are computed for 1-pixel tolerance;
+    // should use extended overviews metadata to compute this properly.
+    if ( bbox ) {
+      var bboxValues = _.map(bbox.split(','), function(v) { return +v; });
+      var w = Math.abs(bboxValues[2]-bboxValues[0]);
+      var h = Math.abs(bboxValues[3]-bboxValues[1]);
+      var maxDim = Math.min(w, h);
+
+      // Find minimum suitable z
+      // note that the QueryRewirter will use the minimum level overview
+      // of level >= z if it exists, and otherwise the base table
+      var z = Math.ceil(-Math.log(maxDim*pxPerTile/earthWidth/SETTINGS.zoomLevelFactor)/Math.log(2.0));
+      return Math.max(z, 0);
+    }
+    return 0;
+};
+
+BaseOverviewsDataview.prototype.rewrittenQuery = function(query) {
+    var zoom_level = this.zoomLevelForBbox(this.options.bbox);
+    return this.queryRewriter.query(query, this.queryRewriteData, { zoom_level: zoom_level });
+};
+
+// Default behaviour
+BaseOverviewsDataview.prototype.defaultSql = function(psql, filters, override, callback) {
+    var query = this.query;
+    var dataview = this.baseDataview;
+    if ( SETTINGS.defaultOverviews ) {
+        query = this.rewrittenQuery(query);
+        dataview = new this.BaseDataview(query, this.queryOptions);
+    }
+    return dataview.sql(psql, filters, override, callback);
+};
+
+// default implementation that can be override in derived classes:
+
+BaseOverviewsDataview.prototype.sql = function(psql, filters, override, callback) {
+    return this.defaultSql(psql, filters, override, callback);
+};
+
+BaseOverviewsDataview.prototype.search = function(psql, userQuery, callback) {
+    return this.baseDataview.search(psql, userQuery, callback);
+};
+
+BaseOverviewsDataview.prototype.format = function(result) {
+    return this.baseDataview.format(result);
+};
+
+BaseOverviewsDataview.prototype.getType = function() {
+    return this.baseDataview.getType();
+};
+
+BaseOverviewsDataview.prototype.toString = function() {
+    return this.baseDataview.toString();
+};

lib/cartodb/models/dataview/overviews/factory.js

@@ -0,0 +1,32 @@
+var parentFactory = require('../factory');
+var dataviews = require('./');
+
+function OverviewsDataviewFactory(queryRewriter, queryRewriteData, options) {
+    this.queryRewriter = queryRewriter;
+    this.queryRewriteData = queryRewriteData;
+    this.options = options;
+}
+
+OverviewsDataviewFactory.prototype.getDataview = function(query, dataviewDefinition) {
+    var type = dataviewDefinition.type;
+    var dataviews = OverviewsDataviewMetaFactory.dataviews;
+    if ( !this.queryRewriter || !this.queryRewriteData || !dataviews[type] ) {
+        return parentFactory.getDataview(query, dataviewDefinition);
+    }
+    return new dataviews[type](
+        query, dataviewDefinition.options, this.queryRewriter, this.queryRewriteData, this.options
+    );
+};
+
+var OverviewsDataviewMetaFactory = {
+    dataviews: Object.keys(dataviews).reduce(function(allDataviews, dataviewClassName) {
+        allDataviews[dataviewClassName.toLowerCase()] = dataviews[dataviewClassName];
+        return allDataviews;
+    }, {}),
+
+    getFactory: function(queryRewriter, queryRewriteData, options) {
+        return new OverviewsDataviewFactory(queryRewriter, queryRewriteData, options);
+    },
+};
+
+module.exports = OverviewsDataviewMetaFactory;

lib/cartodb/models/dataview/overviews/formula.js

@@ -0,0 +1,56 @@
+var BaseOverviewsDataview = require('./base');
+var BaseDataview = require('../formula');
+
+var dot = require('dot');
+dot.templateSettings.strip = false;
+
+var formulaQueryTpls = {
+  'count': dot.template([
+      'SELECT',
+      'sum(_feature_count) AS result,',
+      '(SELECT count(1) FROM ({{=it._query}}) _cdb_formula_nulls WHERE {{=it._column}} IS NULL) AS nulls_count',
+      'FROM ({{=it._query}}) _cdb_formula'
+  ].join('\n')),
+  'sum': dot.template([
+      'SELECT',
+      'sum({{=it._column}}*_feature_count) AS result,',
+      '(SELECT count(1) FROM ({{=it._query}}) _cdb_formula_nulls WHERE {{=it._column}} IS NULL) AS nulls_count',
+      'FROM ({{=it._query}}) _cdb_formula'
+  ].join('\n')),
+  'avg': dot.template([
+      'SELECT',
+      'sum({{=it._column}}*_feature_count)/sum(_feature_count) AS result,',
+      '(SELECT count(1) FROM ({{=it._query}}) _cdb_formula_nulls WHERE {{=it._column}} IS NULL) AS nulls_count',
+      'FROM ({{=it._query}}) _cdb_formula'
+  ].join('\n')),
+};
+
+function Formula(query, options, queryRewriter, queryRewriteData, params) {
+    BaseOverviewsDataview.call(this, query, options, BaseDataview, queryRewriter, queryRewriteData, params);
+    this.column = options.column || '1';
+    this.operation = options.operation;
+}
+
+Formula.prototype = Object.create(BaseOverviewsDataview.prototype);
+Formula.prototype.constructor = Formula;
+
+module.exports = Formula;
+
+Formula.prototype.sql = function(psql, filters, override, callback) {
+    var formulaQueryTpl = formulaQueryTpls[this.operation];
+
+    if ( formulaQueryTpl ) {
+        // supported formula for use with overviews
+        var formulaSql = formulaQueryTpl({
+            _query:     this.rewrittenQuery(this.query),
+            _operation: this.operation,
+            _column:    this.column
+        });
+        callback = callback || override;
+
+        return callback(null, formulaSql);
+    }
+
+    // default behaviour
+    return this.defaultSql(psql, filters, override, callback);
+};

lib/cartodb/models/dataview/overviews/histogram.js

@@ -0,0 +1,217 @@
+var _ = require('underscore');
+var BaseOverviewsDataview = require('./base');
+var BaseDataview = require('../histogram');
+
+var dot = require('dot');
+dot.templateSettings.strip = false;
+
+var columnTypeQueryTpl = dot.template(
+    'SELECT pg_typeof({{=it.column}})::oid FROM ({{=it.query}}) _cdb_histogram_column_type limit 1'
+);
+var columnCastTpl = dot.template("date_part('epoch', {{=it.column}})");
+
+var BIN_MIN_NUMBER = 6;
+var BIN_MAX_NUMBER = 48;
+
+var basicsQueryTpl = dot.template([
+    'basics AS (',
+    '  SELECT',
+    '    max({{=it._column}}) AS max_val, min({{=it._column}}) AS min_val,',
+    '    sum({{=it._column}}*_feature_count)/sum(_feature_count) AS avg_val, sum(_feature_count) AS total_rows',
+    '  FROM ({{=it._query}}) _cdb_basics',
+    ')'
+].join(' \n'));
+
+var overrideBasicsQueryTpl = dot.template([
+    'basics AS (',
+    '  SELECT',
+    '    max({{=it._end}}) AS max_val, min({{=it._start}}) AS min_val,',
+    '    sum({{=it._column}}*_feature_count)/sum(_feature_count) AS avg_val, sum(_feature_count) AS total_rows',
+    '  FROM ({{=it._query}}) _cdb_basics',
+    ')'
+].join('\n'));
+
+var iqrQueryTpl = dot.template([
+    'iqrange AS (',
+    '  SELECT max(quartile_max) - min(quartile_max) AS iqr',
+    '  FROM (',
+    '    SELECT quartile, max(_cdb_iqr_column) AS quartile_max from (',
+    '      SELECT {{=it._column}} AS _cdb_iqr_column, ntile(4) over (order by {{=it._column}}',
+    '    ) AS quartile',
+    '    FROM ({{=it._query}}) _cdb_rank) _cdb_quartiles',
+    '    WHERE quartile = 1 or quartile = 3',
+    '    GROUP BY quartile',
+    '  ) _cdb_iqr',
+    ')'
+].join('\n'));
+
+var binsQueryTpl = dot.template([
+    'bins AS (',
+    '  SELECT CASE WHEN total_rows = 0 OR iqr = 0',
+    '      THEN 1',
+    '      ELSE GREATEST(',
+    '        LEAST({{=it._minBins}}, CAST(total_rows AS INT)),',
+    '        LEAST(',
+    '          CAST(((max_val - min_val) / (2 * iqr * power(total_rows, 1/3))) AS INT),',
+    '          {{=it._maxBins}}',
+    '        )',
+    '      )',
+    '    END AS bins_number',
+    '  FROM basics, iqrange, ({{=it._query}}) _cdb_bins',
+    '  LIMIT 1',
+    ')'
+].join('\n'));
+
+var overrideBinsQueryTpl = dot.template([
+    'bins AS (',
+    '  SELECT {{=it._bins}} AS bins_number',
+    ')'
+].join('\n'));
+
+var nullsQueryTpl = dot.template([
+    'nulls AS (',
+    '  SELECT',
+    '  count(*) AS nulls_count',
+    '  FROM ({{=it._query}}) _cdb_histogram_nulls',
+    '  WHERE {{=it._column}} IS NULL',
+    ')'
+].join('\n'));
+
+var histogramQueryTpl = dot.template([
+    'SELECT',
+    '    (max_val - min_val) / cast(bins_number as float) AS bin_width,',
+    '    bins_number,',
+    '    nulls_count,',
+    '    avg_val,',
+    '    CASE WHEN min_val = max_val',
+    '      THEN 0',
+    '      ELSE GREATEST(1, LEAST(WIDTH_BUCKET({{=it._column}}, min_val, max_val, bins_number), bins_number)) - 1',
+    '    END AS bin,',
+    '    min({{=it._column}})::numeric AS min,',
+    '    max({{=it._column}})::numeric AS max,',
+    '    sum({{=it._column}}*_feature_count)/sum(_feature_count)::numeric AS avg,',
+    '    sum(_feature_count) AS freq',
+    'FROM ({{=it._query}}) _cdb_histogram, basics, nulls, bins',
+    'WHERE {{=it._column}} IS NOT NULL',
+    'GROUP BY bin, bins_number, bin_width, nulls_count, avg_val',
+    'ORDER BY bin'
+].join('\n'));
+
+function Histogram(query, options, queryRewriter, queryRewriteData, params) {
+    BaseOverviewsDataview.call(this, query, options, BaseDataview, queryRewriter, queryRewriteData, params);
+
+    this.query = query;
+    this.column = options.column;
+    this.bins = options.bins;
+
+    this._columnType = null;
+}
+
+Histogram.prototype = Object.create(BaseOverviewsDataview.prototype);
+Histogram.prototype.constructor = Histogram;
+
+module.exports = Histogram;
+
+
+var DATE_OIDS = {
+    1082: true,
+    1114: true,
+    1184: true
+};
+
+Histogram.prototype.sql = function(psql, override, callback) {
+    if (!callback) {
+        callback = override;
+        override = {};
+    }
+
+    var self = this;
+
+    var _column = this.column;
+
+    var columnTypeQuery = columnTypeQueryTpl({
+        column: _column, query: this.rewrittenQuery(this.query)
+    });
+
+    if (this._columnType === null) {
+        psql.query(columnTypeQuery, function(err, result) {
+            // assume numeric, will fail later
+            self._columnType = 'numeric';
+            if (!err && !!result.rows[0]) {
+                var pgType = result.rows[0].pg_typeof;
+                if (DATE_OIDS.hasOwnProperty(pgType)) {
+                    self._columnType = 'date';
+                }
+            }
+            self.sql(psql, override, callback);
+        }, true); // use read-only transaction
+        return null;
+    }
+
+    if (this._columnType === 'date') {
+        _column = columnCastTpl({column: _column});
+    }
+
+    var _query = this.rewrittenQuery(this.query);
+
+    var basicsQuery, binsQuery;
+
+    if (override && _.has(override, 'start') && _.has(override, 'end') && _.has(override, 'bins')) {
+        basicsQuery = overrideBasicsQueryTpl({
+            _query: _query,
+            _column: _column,
+            _start: override.start,
+            _end: override.end
+        });
+
+        binsQuery = [
+            overrideBinsQueryTpl({
+                _bins: override.bins
+            })
+        ].join(',\n');
+    } else {
+        basicsQuery = basicsQueryTpl({
+            _query: _query,
+            _column: _column
+        });
+
+        if (override && _.has(override, 'bins')) {
+            binsQuery = [
+                overrideBinsQueryTpl({
+                    _bins: override.bins
+                })
+            ].join(',\n');
+        } else {
+            binsQuery = [
+                iqrQueryTpl({
+                    _query: _query,
+                    _column: _column
+                }),
+                binsQueryTpl({
+                    _query: _query,
+                    _minBins: BIN_MIN_NUMBER,
+                    _maxBins: BIN_MAX_NUMBER
+                })
+            ].join(',\n');
+        }
+    }
+
+
+    var histogramSql = [
+        "WITH",
+        [
+            basicsQuery,
+            binsQuery,
+            nullsQueryTpl({
+                _query: _query,
+                _column: _column
+            })
+        ].join(',\n'),
+        histogramQueryTpl({
+            _query: _query,
+            _column: _column
+        })
+    ].join('\n');
+
+    return callback(null, histogramSql);
+};

lib/cartodb/models/dataview/overviews/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+  Aggregation: require('./aggregation'),
+  Formula: require('./formula'),
+  Histogram: require('./histogram'),
+  List: require('./list')
+};

lib/cartodb/models/dataview/overviews/list.js

@@ -0,0 +1,11 @@
+var BaseOverviewsDataview = require('./base');
+var BaseDataview = require('../list');
+
+function List(query, options, queryRewriter, queryRewriteData, params) {
+    BaseOverviewsDataview.call(this, query, options, BaseDataview, queryRewriter, queryRewriteData, params);
+}
+
+List.prototype = Object.create(BaseOverviewsDataview.prototype);
+List.prototype.constructor = List;
+
+module.exports = List;

lib/cartodb/models/filter/camshaft.js

@@ -0,0 +1,35 @@
+var filters = {
+    category: require('./camshaft/category'),
+    range: require('./camshaft/range')
+};
+
+function createFilter(filterDefinition) {
+    var filterType = filterDefinition.type.toLowerCase();
+    if (!filters.hasOwnProperty(filterType)) {
+        throw new Error('Unknown filter type: ' + filterType);
+    }
+    return new filters[filterType](filterDefinition.column, filterDefinition.params);
+}
+
+function CamshaftFilters(filters) {
+    this.filters = filters;
+}
+
+CamshaftFilters.prototype.sql = function(rawSql) {
+  var filters = this.filters || {};
+  var applyFilters = {};
+
+  return Object.keys(filters)
+      .filter(function(filterName) {
+          return applyFilters.hasOwnProperty(filterName) ? applyFilters[filterName] : true;
+      })
+      .map(function(filterName) {
+          var filterDefinition = filters[filterName];
+          return createFilter(filterDefinition);
+      })
+      .reduce(function(sql, filter) {
+          return filter.sql(sql);
+      }, rawSql);
+};
+
+module.exports = CamshaftFilters;

lib/cartodb/models/filter/camshaft/category.js

@@ -0,0 +1,79 @@
+'use strict';
+
+var debug = require('debug')('windshaft:filter:category');
+var dot = require('dot');
+dot.templateSettings.strip = false;
+
+var filterQueryTpl = dot.template([
+    'SELECT *',
+    'FROM ({{=it._sql}}) _camshaft_category_filter',
+    'WHERE {{=it._filters}}'
+].join('\n'));
+var escapeStringTpl = dot.template('$escape_{{=it._i}}${{=it._value}}$escape_{{=it._i}}$');
+var inConditionTpl = dot.template('{{=it._column}} IN ({{=it._values}})');
+var notInConditionTpl = dot.template('{{=it._column}} NOT IN ({{=it._values}})');
+
+function Category(column, filterParams) {
+    this.column = column;
+
+    if (!Array.isArray(filterParams.accept) && !Array.isArray(filterParams.reject)) {
+        throw new Error('Category filter expects at least one array in accept or reject params');
+    }
+
+    if (Array.isArray(filterParams.accept) && Array.isArray(filterParams.reject)) {
+        if (filterParams.accept.length === 0 && filterParams.reject.length === 0) {
+            throw new Error(
+                'Category filter expects one value either in accept or reject params when both are provided'
+            );
+        }
+    }
+
+    this.accept = filterParams.accept;
+    this.reject = filterParams.reject;
+}
+
+module.exports = Category;
+
+/*
+ - accept: [] => reject all
+ - reject: [] => accept all
+ */
+Category.prototype.sql = function(rawSql) {
+    var valueFilters = [];
+
+    if (Array.isArray(this.accept)) {
+        if (this.accept.length > 0) {
+            valueFilters.push(inConditionTpl({
+                _column: this.column,
+                _values: this.accept.map(function(value, i) {
+                    return Number.isFinite(value) ? value : escapeStringTpl({_i: i, _value: value});
+                }).join(',')
+            }));
+        } else {
+            valueFilters.push('0 = 1');
+        }
+    }
+
+    if (Array.isArray(this.reject)) {
+        if (this.reject.length > 0) {
+            valueFilters.push(notInConditionTpl({
+                _column: this.column,
+                _values: this.reject.map(function (value, i) {
+                    return Number.isFinite(value) ? value : escapeStringTpl({_i: i, _value: value});
+                }).join(',')
+            }));
+        } else {
+            valueFilters.push('1 = 1');
+        }
+    }
+
+    debug(filterQueryTpl({
+        _sql: rawSql,
+        _filters: valueFilters.join(' AND ')
+    }));
+
+    return filterQueryTpl({
+        _sql: rawSql,
+        _filters: valueFilters.join(' AND ')
+    });
+};

lib/cartodb/models/filter/camshaft/range.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var dot = require('dot');
+dot.templateSettings.strip = false;
+
+var betweenFilterTpl = dot.template('{{=it._column}} BETWEEN {{=it._min}} AND {{=it._max}}');
+var minFilterTpl = dot.template('{{=it._column}} >= {{=it._min}}');
+var maxFilterTpl = dot.template('{{=it._column}} <= {{=it._max}}');
+var filterQueryTpl = dot.template('SELECT * FROM ({{=it._sql}}) _camshaft_range_filter WHERE {{=it._filter}}');
+
+function Range(column, filterParams) {
+    this.column = column;
+
+    if (!Number.isFinite(filterParams.min) && !Number.isFinite(filterParams.max)) {
+        throw new Error('Range filter expect to have at least one value in min or max numeric params');
+    }
+
+    this.min = filterParams.min;
+    this.max = filterParams.max;
+    this.columnType = filterParams.columnType;
+}
+
+module.exports = Range;
+
+Range.prototype.sql = function(rawSql) {
+    var minMaxFilter;
+    if (Number.isFinite(this.min) && Number.isFinite(this.max)) {
+        minMaxFilter = betweenFilterTpl({
+            _column: this.column,
+            _min: this.min,
+            _max: this.max
+        });
+    } else if (Number.isFinite(this.min)) {
+        minMaxFilter = minFilterTpl({ _column: this.column, _min: this.min });
+    } else {
+        minMaxFilter = maxFilterTpl({ _column: this.column, _max: this.max });
+    }
+
+    return filterQueryTpl({
+        _sql: rawSql,
+        _filter: minMaxFilter
+    });
+};

lib/cartodb/models/mapconfig/adapter/analysis-mapconfig-adapter.js

@@ -11,6 +11,134 @@ function AnalysisMapConfigAdapter(analysisBackend) {
 
 module.exports = AnalysisMapConfigAdapter;
 
+AnalysisMapConfigAdapter.prototype.getMapConfig = function(user, requestMapConfig, params, context, callback) {
+    // jshint maxcomplexity:7
+    var self = this;
+
+    if (!shouldAdaptLayers(requestMapConfig)) {
+        return callback(null, requestMapConfig);
+    }
+
+    var analysisConfiguration = context.analysisConfiguration;
+
+    var filters = {};
+    if (params.filters) {
+        try {
+            filters = JSON.parse(params.filters);
+        } catch (e) {
+            // ignore
+        }
+    }
+
+    var dataviewsFilters = filters.dataviews || {};
+    debug(dataviewsFilters);
+    var dataviews = requestMapConfig.dataviews || {};
+
+    var errors = getDataviewsErrors(dataviews);
+    if (errors.length > 0) {
+        return callback(errors);
+    }
+
+    var dataviewsFiltersBySourceId = Object.keys(dataviewsFilters).reduce(function(bySourceId, dataviewName) {
+        var dataview = dataviews[dataviewName];
+        if (dataview) {
+            var sourceId = dataview.source.id;
+            if (!bySourceId.hasOwnProperty(sourceId)) {
+                bySourceId[sourceId] = {};
+            }
+
+            bySourceId[sourceId][dataviewName] = getFilter(dataview, dataviewsFilters[dataviewName]);
+        }
+        return bySourceId;
+    }, {});
+
+    debug(dataviewsFiltersBySourceId);
+
+    debug('mapconfig input', JSON.stringify(requestMapConfig, null, 4));
+
+    requestMapConfig = appendFiltersToNodes(requestMapConfig, dataviewsFiltersBySourceId);
+
+    function createAnalysis(analysisDefinition, index, done) {
+        self.analysisBackend.create(analysisConfiguration, analysisDefinition, function (err, analysis) {
+            if (err) {
+                var error = new Error(err.message);
+                error.type = 'analysis';
+                error.context = {};
+                error.context.layer = {
+                    index: index,
+                    id: analysisDefinition.id,
+                    type: analysisDefinition.type
+                };
+                return done(error);
+            }
+
+            done(null, analysis);
+        });
+    }
+
+    var analysesQueue = queue(requestMapConfig.analyses.length);
+    requestMapConfig.analyses.forEach(function(analysis, index) {
+        analysesQueue.defer(createAnalysis, analysis, index);
+    });
+
+    analysesQueue.awaitAll(function(err, analysesResults) {
+        if (err) {
+            return callback(err);
+        }
+
+        var sourceId2Node = analysesResults.reduce(function(sourceId2Query, analysis) {
+            var rootNode = analysis.getRoot();
+            if (rootNode.params && rootNode.params.id) {
+                sourceId2Query[rootNode.params.id] = rootNode;
+            }
+
+            analysis.getSortedNodes().forEach(function(node) {
+                if (node.params && node.params.id) {
+                    sourceId2Query[node.params.id] = node;
+                }
+            });
+
+            return sourceId2Query;
+        }, {});
+
+        var missingNodesErrors = [];
+
+        requestMapConfig.layers = requestMapConfig.layers.map(function(layer, layerIndex) {
+            if (getLayerSourceId(layer)) {
+                var layerSourceId = getLayerSourceId(layer);
+                var layerNode = sourceId2Node[layerSourceId];
+                if (layerNode) {
+                    var analysisSql = layerQuery(layerNode);
+                    var sqlQueryWrap = layer.options.sql_wrap;
+                    if (sqlQueryWrap) {
+                        layer.options.sql_raw = analysisSql;
+                        analysisSql = sqlQueryWrap.replace(/<%=\s*sql\s*%>/g, analysisSql);
+                    }
+                    layer.options.sql = analysisSql;
+                    layer.options.columns = getDataviewsColumns(getLayerDataviews(layer, dataviews));
+                } else {
+                    missingNodesErrors.push(
+                        new Error('Missing analysis node.id="' + layerSourceId +'" for layer='+layerIndex)
+                    );
+                }
+            }
+            return layer;
+        });
+
+
+        debug('mapconfig output', JSON.stringify(requestMapConfig, null, 4));
+
+        var missingDataviewsNodesErrors = getMissingDataviewsSourceIds(dataviews, sourceId2Node);
+        if (missingNodesErrors.length > 0 || missingDataviewsNodesErrors.length > 0) {
+            return callback(missingNodesErrors.concat(missingDataviewsNodesErrors));
+        }
+
+        context.analysesResults = analysesResults;
+
+        return callback(null, requestMapConfig);
+    });
+};
+
 var SKIP_COLUMNS = {
     'the_geom': true,
     'the_geom_webmercator': true
@@ -51,8 +179,9 @@ function appendFiltersToNodes(requestMapConfig, dataviewsFiltersBySourceId) {
 }
 
 function shouldAdaptLayers(requestMapConfig) {
-    return Array.isArray(requestMapConfig.layers) &&
-        Array.isArray(requestMapConfig.analyses) && requestMapConfig.analyses.length > 0;
+    return Array.isArray(requestMapConfig.layers) && requestMapConfig.layers.some(getLayerSourceId) ||
+        (Array.isArray(requestMapConfig.analyses) && requestMapConfig.analyses.length > 0) ||
+        requestMapConfig.dataviews;
 }
 
 var DATAVIEW_TYPE_2_FILTER_TYPE = {
@@ -69,108 +198,6 @@ function getFilter(dataview, params) {
     };
 }
 
-AnalysisMapConfigAdapter.prototype.getMapConfig = function(analysisConfiguration, requestMapConfig, filters, callback) {
-    // jshint maxcomplexity:7
-    var self = this;
-    filters = filters || {};
-
-    if (!shouldAdaptLayers(requestMapConfig)) {
-        return callback(null, requestMapConfig);
-    }
-
-    var dataviewsFilters = filters.dataviews || {};
-    debug(dataviewsFilters);
-    var dataviews = requestMapConfig.dataviews || {};
-
-    var errors = getDataviewsErrors(dataviews);
-    if (errors.length > 0) {
-        return callback(errors);
-    }
-
-    var dataviewsFiltersBySourceId = Object.keys(dataviewsFilters).reduce(function(bySourceId, dataviewName) {
-        var dataview = dataviews[dataviewName];
-        if (dataview) {
-            var sourceId = dataview.source.id;
-            if (!bySourceId.hasOwnProperty(sourceId)) {
-                bySourceId[sourceId] = {};
-            }
-
-            bySourceId[sourceId][dataviewName] = getFilter(dataview, dataviewsFilters[dataviewName]);
-        }
-        return bySourceId;
-    }, {});
-
-    debug(dataviewsFiltersBySourceId);
-
-    debug('mapconfig input', JSON.stringify(requestMapConfig, null, 4));
-
-    requestMapConfig = appendFiltersToNodes(requestMapConfig, dataviewsFiltersBySourceId);
-
-    function createAnalysis(analysisDefinition, done) {
-        self.analysisBackend.create(analysisConfiguration, analysisDefinition, done);
-    }
-
-    var analysesQueue = queue(requestMapConfig.analyses.length);
-    requestMapConfig.analyses.forEach(function(analysis) {
-        analysesQueue.defer(createAnalysis, analysis);
-    });
-
-    analysesQueue.awaitAll(function(err, analysesResults) {
-        if (err) {
-            return callback(err);
-        }
-
-        var sourceId2Node = analysesResults.reduce(function(sourceId2Query, analysis) {
-            var rootNode = analysis.getRoot();
-            if (rootNode.params && rootNode.params.id) {
-                sourceId2Query[rootNode.params.id] = rootNode;
-            }
-
-            analysis.getSortedNodes().forEach(function(node) {
-                if (node.params && node.params.id) {
-                    sourceId2Query[node.params.id] = node;
-                }
-            });
-
-            return sourceId2Query;
-        }, {});
-
-        var missingNodesErrors = [];
-
-        requestMapConfig.layers = requestMapConfig.layers.map(function(layer, layerIndex) {
-            if (getLayerSourceId(layer)) {
-                var layerSourceId = getLayerSourceId(layer);
-                var layerNode = sourceId2Node[layerSourceId];
-                if (layerNode) {
-                    var analysisSql = layerQuery(layerNode);
-                    var sqlQueryWrap = layer.options.sql_wrap;
-                    if (sqlQueryWrap) {
-                        analysisSql = sqlQueryWrap.replace(/<%=\s*sql\s*%>/g, analysisSql);
-                    }
-                    layer.options.sql = analysisSql;
-                    var layerDataviews = getLayerDataviews(layer, dataviews);
-                    layer.options.columns = layerDataviews.reduce(function(columns, dataview) {
-                        return columns.concat(getDataviewColumns(dataview));
-                    }, []);
-                } else {
-                    missingNodesErrors.push(
-                        new Error('Missing analysis node.id="' + layerSourceId +'" for layer='+layerIndex)
-                    );
-                }
-            }
-            return layer;
-        });
-
-        debug('mapconfig output', JSON.stringify(requestMapConfig, null, 4));
-
-        if (missingNodesErrors.length > 0) {
-            return callback(missingNodesErrors);
-        }
-
-        return callback(null, requestMapConfig, analysesResults);
-    });
-};
-
 function getLayerSourceId(layer) {
     return layer.options.source && layer.options.source.id;
 }
@@ -195,11 +222,22 @@ function getLayerDataviews(layer, dataviews) {
     return layerDataviews;
 }
 
+function getDataviewsColumns(dataviews) {
+    return Object.keys(dataviews.reduce(function(columnsDict, dataview) {
+        getDataviewColumns(dataview).forEach(function(columnName) {
+            if (!!columnName) {
+                columnsDict[columnName] = true;
+            }
+        });
+        return columnsDict;
+    }, {}));
+}
+
 function getDataviewColumns(dataview) {
     var columns = [];
     var options = dataview.options;
     ['column', 'aggregationColumn'].forEach(function(opt) {
-        if (options.hasOwnProperty(opt)) {
+        if (options.hasOwnProperty(opt) && !!options[opt]) {
             columns.push(options[opt]);
         }
     });
@@ -211,6 +249,15 @@ function getDataviewsList(dataviews) {
 }
 
 function getDataviewsErrors(dataviews) {
+    var dataviewType = typeof dataviews;
+    if (dataviewType !== 'object') {
+        return [new Error('"dataviews" must be a valid JSON object: "' + dataviewType + '" type found')];
+    }
+
+    if (Array.isArray(dataviews)) {
+        return [new Error('"dataviews" must be a valid JSON object: "array" type found')];
+    }
+
     var errors = [];
 
     Object.keys(dataviews).forEach(function(dataviewName) {
@@ -226,3 +273,26 @@ function getDataviewsErrors(dataviews) {
 
     return errors;
 }
+
+function getMissingDataviewsSourceIds(dataviews, sourceId2Node) {
+    var missingDataviewsSourceIds = [];
+    Object.keys(dataviews).forEach(function(dataviewName) {
+        var dataview = dataviews[dataviewName];
+        var dataviewSourceId = getDataviewSourceId(dataview);
+        if (!sourceId2Node.hasOwnProperty(dataviewSourceId)) {
+            missingDataviewsSourceIds.push(new AnalysisError('Node with `source.id="' + dataviewSourceId +'"`' +
+                ' not found in analyses for dataview "' + dataviewName + '"'));
+        }
+    });
+
+    return missingDataviewsSourceIds;
+}
+
+function AnalysisError(message) {
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.type = 'analysis';
+    this.message = message;
+}
+
+require('util').inherits(AnalysisError, Error);

lib/cartodb/models/mapconfig/adapter/dataviews-widgets-adapter.js

@@ -0,0 +1,98 @@
+function DataviewsWidgetsMapConfigAdapter() {
+}
+
+module.exports = DataviewsWidgetsMapConfigAdapter;
+
+
+DataviewsWidgetsMapConfigAdapter.prototype.getMapConfig = function(user, requestMapConfig, params, context, callback) {
+    if (!shouldAdapt(requestMapConfig)) {
+        return callback(null, requestMapConfig);
+    }
+
+    // prepare placeholders for new dataviews created from widgets
+    requestMapConfig.analyses = requestMapConfig.analyses || [];
+    requestMapConfig.dataviews = requestMapConfig.dataviews || {};
+
+    requestMapConfig.layers.forEach(function(layer, index) {
+        var layerSourceId = getLayerSourceId(layer);
+
+        if (!layer.options.widgets) {
+            return;
+        }
+
+        if (!layerSourceId && !layer.options.sql) {
+            return;
+        }
+
+        var dataviewSourceId = layerSourceId || 'cdb-layer-source-' + index;
+        // Append a new analysis if layer has no source id but sql.
+        if (!layerSourceId) {
+            requestMapConfig.analyses.push(
+                {
+                    id: dataviewSourceId,
+                    type: 'source',
+                    params: {
+                        query: layer.options.sql
+                    }
+                }
+            );
+        }
+        var source = { id: dataviewSourceId };
+        var layerWidgets = layer.options.widgets || {};
+        Object.keys(layerWidgets).forEach(function(widgetId) {
+            var dataview = layerWidgets[widgetId];
+            requestMapConfig.dataviews[widgetId] = {
+                source: source,
+                type: dataview.type,
+                options: dataview.options
+            };
+        });
+
+        layer.options.source = source;
+
+        delete layer.options.sql;
+        // don't delete widgets for now as it might be useful for old clients
+        //delete layer.options.widgets;
+    });
+
+    // filters have to be rewritten also
+    var filters = getFilters(params);
+    var layersFilters = filters.layers || [];
+    filters.dataviews = filters.dataviews || {};
+
+    layersFilters.forEach(function(layerFilters) {
+        Object.keys(layerFilters).forEach(function(filterName) {
+            if (!filters.dataviews.hasOwnProperty(filterName)) {
+                filters.dataviews[filterName] = layerFilters[filterName];
+            }
+        });
+    });
+
+    delete filters.layers;
+
+    params.filters = JSON.stringify(filters);
+
+    return callback(null, requestMapConfig);
+};
+
+function shouldAdapt(requestMapConfig) {
+    return Array.isArray(requestMapConfig.layers) && requestMapConfig.layers.some(function hasWidgets(layer) {
+        return layer.options && layer.options.widgets && Object.keys(layer.options.widgets).length > 0;
+    });
+}
+
+function getLayerSourceId(layer) {
+    return layer.options.source && layer.options.source.id;
+}
+
+function getFilters(params) {
+    var filters = {};
+    if (params.filters) {
+        try {
+            filters = JSON.parse(params.filters);
+        } catch (e) {
+            // ignore
+        }
+    }
+    return filters;
+}

lib/cartodb/models/mapconfig/adapter/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+function MapConfigAdapter(adapters) {
+    this.adapters = Array.isArray(adapters) ? adapters : Array.apply(null, arguments);
+}
+
+module.exports = MapConfigAdapter;
+
+MapConfigAdapter.prototype.getMapConfig = function(user, requestMapConfig, params, context, callback) {
+    var self = this;
+    var i = 0;
+    var tasksLeft = this.adapters.length;
+
+    function next(err, _requestMapConfig) {
+        if (err) {
+            return callback(err);
+        }
+        if (tasksLeft-- === 0) {
+            return callback(null, _requestMapConfig);
+        }
+        var nextAdapter = self.adapters[i++];
+        nextAdapter.getMapConfig(user, _requestMapConfig, params, context, next);
+    }
+
+    next(null, requestMapConfig);
+};

lib/cartodb/models/mapconfig/adapter/mapconfig-named-layers-adapter.js

@@ -2,17 +2,20 @@ var queue = require('queue-async');
 var _ = require('underscore');
 var Datasource = require('windshaft').model.Datasource;
 
-function MapConfigNamedLayersAdapter(templateMaps) {
+function MapConfigNamedLayersAdapter(templateMaps, pgConnection) {
     this.templateMaps = templateMaps;
+    this.pgConnection = pgConnection;
 }
 
 module.exports = MapConfigNamedLayersAdapter;
 
-MapConfigNamedLayersAdapter.prototype.getLayers = function(username, layers, dbMetadata, callback) {
+MapConfigNamedLayersAdapter.prototype.getMapConfig = function (user, requestMapConfig, params, context, callback) {
     var self = this;
 
+    var layers = requestMapConfig.layers;
+
     if (!layers) {
-        return callback(null);
+        return callback(null, requestMapConfig);
     }
 
     var adaptLayersQueue = queue(layers.length);
@@ -28,9 +31,9 @@ MapConfigNamedLayersAdapter.prototype.getLayers = function(username, layers, dbM
             var templateConfigParams = layer.options.config || {};
             var templateAuthTokens = layer.options.auth_tokens;
 
-            self.templateMaps.getTemplate(username, templateName, function(err,  template) {
+            self.templateMaps.getTemplate(user, templateName, function(err,  template) {
                 if (err || !template) {
-                    return done(new Error("Template '" + templateName + "' of user '" + username + "' not found"));
+                    return done(new Error("Template '" + templateName + "' of user '" + user + "' not found"));
                 }
 
                 if (self.templateMaps.isAuthorized(template, templateAuthTokens)) {
@@ -96,7 +99,10 @@ MapConfigNamedLayersAdapter.prototype.getLayers = function(username, layers, dbM
 
         });
 
-        return callback(null, layers, datasourceBuilder.build());
+        requestMapConfig.layers = layers;
+        context.datasource = datasourceBuilder.build();
+
+        return callback(null, requestMapConfig);
     }
 
 
@@ -104,7 +110,7 @@ MapConfigNamedLayersAdapter.prototype.getLayers = function(username, layers, dbM
 
     if (_.some(layers, isNamedTypeLayer)) {
         // Lazy load dbAuth
-        dbMetadata.setDBAuth(username, dbAuth, function(err) {
+        this.pgConnection.setDBAuth(user, dbAuth, function(err) {
             if (err) {
                 return callback(err);
             }
@@ -114,7 +120,8 @@ MapConfigNamedLayersAdapter.prototype.getLayers = function(username, layers, dbM
             adaptLayersQueue.awaitAll(layersAdaptQueueFinish);
         });
     } else {
-        return callback(null, layers, datasourceBuilder.build());
+        context.datasource = datasourceBuilder.build();
+        return callback(null, requestMapConfig);
     }
 
 };

lib/cartodb/models/mapconfig/adapter/mapconfig-overviews-adapter.js

@@ -0,0 +1,101 @@
+var step = require('step');
+var queue = require('queue-async');
+var _ = require('underscore');
+
+function MapConfigOverviewsAdapter(overviewsMetadataApi, filterStatsApi) {
+    this.overviewsMetadataApi = overviewsMetadataApi;
+    this.filterStatsApi = filterStatsApi;
+}
+
+module.exports = MapConfigOverviewsAdapter;
+
+MapConfigOverviewsAdapter.prototype.getMapConfig = function(user, requestMapConfig, params, context, callback) {
+  var self = this;
+
+  var layers = requestMapConfig.layers;
+  var analysesResults = context.analysesResults;
+
+  if (!layers || layers.length === 0) {
+      return callback(null, requestMapConfig);
+  }
+
+  var augmentLayersQueue = queue(layers.length);
+
+  function augmentLayer(layer, done) {
+      if ( layer.type !== 'mapnik' && layer.type !== 'cartodb' ) {
+          return done(null, layer);
+      }
+      self.overviewsMetadataApi.getOverviewsMetadata(user, layer.options.sql, function(err, metadata){
+           if (err) {
+               done(err, layer);
+           } else {
+               var query_rewrite_data = { overviews: metadata };
+               step(
+                   function collectFiltersData() {
+                       var filters, unfiltered_query;
+                       if ( layer.options.source && analysesResults ) {
+                           var sourceId = layer.options.source.id;
+                           var node = _.find(analysesResults, function(a){ return a.rootNode.params.id === sourceId; });
+                           if ( node ) {
+                               node = node.rootNode;
+                               filters = node.getFilters();
+                               var filters_disabler = Object.keys(filters).reduce(
+                                   function(disabler, filter_id){ disabler[filter_id] = false; return disabler; },
+                                   {}
+                               );
+                               unfiltered_query = node.getQuery(filters_disabler);
+                               query_rewrite_data.filters = filters;
+                               query_rewrite_data.unfiltered_query = unfiltered_query;
+                           }
+                       }
+                       this(null, filters, unfiltered_query);
+                   },
+                   function collectStatsData(err, filters, unfiltered_query) {
+                       var next_step = this;
+                       if ( filters ) {
+                           self.filterStatsApi.getFilterStats(
+                               user,
+                               unfiltered_query, filters,
+                               function(err, stats) {
+                                 if ( !err ) {
+                                     query_rewrite_data.filter_stats = stats;
+                                 }
+                                 return next_step(err);
+                               }
+                           );
+                       } else {
+                           return next_step(null);
+                       }
+                   },
+                   function addDataToLayer(err) {
+                       if ( !err && !_.isEmpty(metadata) ) {
+                           layer = _.extend({}, layer);
+                           layer.options = _.extend({}, layer.options, { query_rewrite_data: query_rewrite_data });
+                       }
+                       done(null, layer);
+                   }
+               );
+           }
+      });
+  }
+
+  function layersAugmentQueueFinish(err, layers) {
+    if (err) {
+        return callback(err);
+    }
+
+    if (!layers || layers.length === 0) {
+        return callback(new Error('Missing layers array from layergroup config'));
+    }
+
+    requestMapConfig.layers = layers;
+
+    return callback(null, requestMapConfig);
+  }
+
+  layers.forEach(function(layer) {
+      augmentLayersQueue.defer(augmentLayer, layer);
+  });
+  augmentLayersQueue.awaitAll(layersAugmentQueueFinish);
+
+};

lib/cartodb/models/mapconfig/adapter/sql-wrap-mapconfig-adapter.js

@@ -0,0 +1,25 @@
+function SqlWrapMapConfigAdapter() {
+}
+
+module.exports = SqlWrapMapConfigAdapter;
+
+
+SqlWrapMapConfigAdapter.prototype.getMapConfig = function(user, requestMapConfig, params, context, callback) {
+    if (requestMapConfig && Array.isArray(requestMapConfig.layers)) {
+        requestMapConfig.layers = requestMapConfig.layers.map(function(layer) {
+            if (layer.options) {
+                var sqlQueryWrap = layer.options.sql_wrap;
+                if (sqlQueryWrap) {
+                    var layerSql = layer.options.sql;
+                    if (layerSql) {
+                        layer.options.sql_raw = layerSql;
+                        layer.options.sql = sqlQueryWrap.replace(/<%=\s*sql\s*%>/g, layerSql);
+                    }
+                }
+            }
+            return layer;
+        });
+    }
+
+    return callback(null, requestMapConfig);
+};

lib/cartodb/models/mapconfig/adapter/turbo-carto-adapter.js

@@ -0,0 +1,162 @@
+'use strict';
+
+var dot = require('dot');
+dot.templateSettings.strip = false;
+var queue = require('queue-async');
+var PSQL = require('cartodb-psql');
+var turboCarto = require('turbo-carto');
+
+var SubstitutionTokens = require('../../../utils/substitution-tokens');
+var PostgresDatasource = require('../../../backends/turbo-carto-postgres-datasource');
+
+function TurboCartoAdapter() {
+}
+
+module.exports = TurboCartoAdapter;
+
+TurboCartoAdapter.prototype.getMapConfig = function (user, requestMapConfig, params, context, callback) {
+    var self = this;
+
+    var layers = requestMapConfig.layers;
+
+    if (!layers || layers.length === 0) {
+        return callback(null, requestMapConfig);
+    }
+
+    var parseCartoQueue = queue(layers.length);
+
+    layers.forEach(function(layer, index) {
+        parseCartoQueue.defer(self._parseCartoCss.bind(self), user, params, layer, index);
+    });
+
+    parseCartoQueue.awaitAll(function (err, layers) {
+        if (err) {
+            return callback(err);
+        }
+
+        requestMapConfig.layers = layers;
+
+        return callback(null, requestMapConfig);
+    });
+};
+
+var tokensQueryTpl = dot.template([
+    'WITH input_query AS (',
+    '  {{=it._sql}}',
+    '),',
+    'bbox_query AS (',
+    '  SELECT ST_SetSRID(ST_Extent(the_geom_webmercator), 3857) as bbox from input_query',
+    '),',
+    'zoom_query as (',
+    '  SELECT GREATEST(',
+    '  ceil(log(40075017000 / 256 / GREATEST(ST_XMax(bbox) - ST_XMin(bbox), ST_YMax(bbox) - ST_YMin(bbox)))/log(2)),',
+    '  0) as zoom',
+    '  FROM bbox_query',
+    '),',
+    'pixel_size_query as (',
+    '  SELECT 40075017 * cos(radians(ST_Y(ST_Transform(ST_Centroid(bbox), 4326)))) / 2 ^ ((zoom) + 8) as pixel_size',
+    '  FROM bbox_query, zoom_query',
+    '),',
+    'scale_denominator_query as (',
+    '  SELECT (pixel_size / 0.00028)::numeric as scale_denominator',
+    '  FROM pixel_size_query',
+    ')',
+    'select ST_AsText(bbox) bbox, pixel_size, scale_denominator, zoom',
+    'from bbox_query, pixel_size_query, scale_denominator_query, zoom_query'
+].join('\n'));
+
+TurboCartoAdapter.prototype._parseCartoCss = function (username, params, layer, index, callback) {
+    if (!shouldParseLayerCartocss(layer)) {
+        return callback(null, layer);
+    }
+
+    var pg = new PSQL(dbParamsFromReqParams(params));
+    function processCallback(err, cartocss) {
+        // Only return turbo-carto errors
+        if (err && err.name === 'TurboCartoError') {
+            var error = new Error('turbo-carto: ' + err.message);
+            error.http_status = 400;
+            error.type = 'turbo-carto';
+            error.context = err.context;
+            error.context.layer = {
+                index: index,
+                type: layer.type
+            };
+
+            return callback(error);
+        }
+
+        // Try to continue in the rest of the cases
+        if (cartocss) {
+            layer.options.cartocss = cartocss;
+        }
+        return callback(null, layer);
+    }
+
+    var layerSql = layer.options.sql;
+    var layerRawSql = layer.options.sql_raw;
+    if (SubstitutionTokens.hasTokens(layerSql) && layerRawSql) {
+        var self = this;
+        var tokensQuery = tokensQueryTpl({_sql: layerRawSql});
+        return pg.query(tokensQuery, function(err, resultSet) {
+            if (err) {
+                var error = new Error('turbo-carto: ' + err.message);
+                error.type = 'turbo-carto';
+                return callback(error);
+            }
+
+            resultSet = resultSet || {};
+            var rows = resultSet.rows || [];
+            var result = rows[0] || {};
+
+            var tokens = {
+                bbox: 'ST_SetSRID(ST_GeomFromText(\'' + result.bbox + '\'), 3857)',
+                scale_denominator: result.scale_denominator,
+                pixel_width: result.pixel_size,
+                pixel_height: result.pixel_size
+            };
+
+            var sql = SubstitutionTokens.replace(layerSql, tokens);
+            self.process(pg, layer.options.cartocss, sql, processCallback);
+        }, true); // use read-only transaction
+    }
+
+    var tokens = {
+        bbox: 'ST_MakeEnvelope(-20037508.34,-20037508.34,20037508.34,20037508.34,3857)',
+        scale_denominator: '500000001',
+        pixel_width: '156412',
+        pixel_height: '156412'
+    };
+
+    var sql = SubstitutionTokens.replace(layerSql, tokens);
+    this.process(pg, layer.options.cartocss, sql, processCallback);
+};
+
+TurboCartoAdapter.prototype.process = function (psql, cartocss, sql, callback) {
+    var datasource = new PostgresDatasource(psql, sql);
+    turboCarto(cartocss, datasource, callback);
+};
+
+function shouldParseLayerCartocss(layer) {
+    return layer && layer.options && layer.options.cartocss && layer.options.sql;
+}
+
+function dbParamsFromReqParams(params) {
+    var dbParams = {};
+    if ( params.dbuser ) {
+        dbParams.user = params.dbuser;
+    }
+    if ( params.dbpassword ) {
+        dbParams.pass = params.dbpassword;
+    }
+    if ( params.dbhost ) {
+        dbParams.host = params.dbhost;
+    }
+    if ( params.dbport ) {
+        dbParams.port = params.dbport;
+    }
+    if ( params.dbname ) {
+        dbParams.dbname = params.dbname;
+    }
+    return dbParams;
+}

lib/cartodb/models/mapconfig/provider/create-layergroup-provider.js

@@ -1,7 +1,7 @@
 var assert = require('assert');
 var step = require('step');
 
-var MapStoreMapConfigProvider = require('./map_store_provider');
+var MapStoreMapConfigProvider = require('./map-store-provider');
 
 /**
  * @param {MapConfig} mapConfig

lib/cartodb/models/mapconfig/provider/named-map-provider.js

@@ -4,24 +4,20 @@ var crypto = require('crypto');
 var dot = require('dot');
 var step = require('step');
 var MapConfig = require('windshaft').model.MapConfig;
-var templateName = require('../../backends/template_maps').templateName;
+var templateName = require('../../../backends/template_maps').templateName;
 var QueryTables = require('cartodb-query-tables');
 
 /**
  * @constructor
  * @type {NamedMapMapConfigProvider}
  */
-function NamedMapMapConfigProvider(templateMaps, pgConnection, metadataBackend, userLimitsApi,
-                                   namedLayersAdapter, overviewsAdapter, turboCartoAdapter, analysisMapConfigAdapter,
+function NamedMapMapConfigProvider(templateMaps, pgConnection, metadataBackend, userLimitsApi, mapConfigAdapter,
                                    owner, templateId, config, authToken, params) {
     this.templateMaps = templateMaps;
     this.pgConnection = pgConnection;
     this.metadataBackend = metadataBackend;
     this.userLimitsApi = userLimitsApi;
-    this.namedLayersAdapter = namedLayersAdapter;
-    this.turboCartoAdapter = turboCartoAdapter;
-    this.analysisMapConfigAdapter = analysisMapConfigAdapter;
-    this.overviewsAdapter = overviewsAdapter;
+    this.mapConfigAdapter = mapConfigAdapter;
 
     this.owner = owner;
     this.templateName = templateName(templateId);
@@ -54,10 +50,11 @@ NamedMapMapConfigProvider.prototype.getMapConfig = function(callback) {
     var self = this;
 
     var mapConfig = null;
-    var datasource = null;
     var rendererParams;
     var apiKey;
 
+    var context = {};
+
     step(
         function getTemplate() {
             self.getTemplate(this);
@@ -95,9 +92,9 @@ NamedMapMapConfigProvider.prototype.getMapConfig = function(callback) {
             assert.ifError(err);
             return self.templateMaps.instance(self.template, templateParams);
         },
-        function prepareAnalysisLayers(err, requestMapConfig) {
+        function prepareAdapterMapConfig(err, requestMapConfig) {
             assert.ifError(err);
-            var analysisConfiguration = {
+            context.analysisConfiguration = {
                 db: {
                     host: rendererParams.dbhost,
                     port: rendererParams.dbport,
@@ -110,75 +107,17 @@ NamedMapMapConfigProvider.prototype.getMapConfig = function(callback) {
                     apiKey: apiKey
                 }
             };
-
-            var filters = {};
-            if (self.params.filters) {
-                try {
-                    filters = JSON.parse(self.params.filters);
-                } catch (e) {
-                    // ignore
-                }
-            }
-            self.analysisMapConfigAdapter.getMapConfig(analysisConfiguration, requestMapConfig, filters, this);
+            self.mapConfigAdapter.getMapConfig(self.owner, requestMapConfig, rendererParams, context, this);
         },
-        function prepareLayergroup(err, _mapConfig, analysesResults) {
-            assert.ifError(err);
-            var next = this;
-            self.analysesResults = analysesResults || [];
-            self.namedLayersAdapter.getLayers(self.owner, _mapConfig.layers, self.pgConnection,
-                function(err, layers, datasource) {
-                    if (err) {
-                        return next(err);
-                    }
-
-                    if (layers) {
-                        _mapConfig.layers = layers;
-                    }
-                    return next(null, _mapConfig, datasource);
-                }
-            );
-        },
-        function addOverviewsInformation(err, _mapConfig, datasource) {
-            assert.ifError(err);
-            var next = this;
-
-            self.overviewsAdapter.getLayers(self.owner, _mapConfig.layers, function(err, layers) {
-                if (err) {
-                    return next(err);
-                }
-
-                if (layers) {
-                    _mapConfig.layers = layers;
-                }
-
-                return next(null, _mapConfig, datasource);
-            });
-        },
-        function parseTurboCarto(err, _mapConfig, datasource) {
-            assert.ifError(err);
-            var next = this;
-
-            self.turboCartoAdapter.getLayers(self.owner, _mapConfig.layers, function (err, layers) {
-                if (err) {
-                    return next(err);
-                }
-
-                if (layers) {
-                    _mapConfig.layers = layers;
-                }
-
-                return next(null, _mapConfig, datasource);
-            });
-        },
-        function prepareContextLimits(err, _mapConfig, _datasource) {
+        function prepareContextLimits(err, _mapConfig) {
             assert.ifError(err);
             mapConfig = _mapConfig;
-            datasource = _datasource;
             self.userLimitsApi.getRenderLimits(self.owner, this);
         },
         function cacheAndReturnMapConfig(err, renderLimits) {
             self.err = err;
-            self.mapConfig = (mapConfig === null) ? null : new MapConfig(mapConfig, datasource);
+            self.mapConfig = (mapConfig === null) ? null : new MapConfig(mapConfig, context.datasource);
+            self.analysesResults = context.analysesResults || [];
             self.rendererParams = rendererParams;
             self.context.limits = renderLimits || {};
             return callback(self.err, self.mapConfig, self.rendererParams, self.context);

lib/cartodb/models/mapconfig_overviews_adapter.js

@@ -1,53 +0,0 @@
-var queue = require('queue-async');
-var _ = require('underscore');
-
-function MapConfigOverviewsAdapter(overviewsMetadataApi) {
-    this.overviewsMetadataApi = overviewsMetadataApi;
-}
-
-module.exports = MapConfigOverviewsAdapter;
-
-MapConfigOverviewsAdapter.prototype.getLayers = function(username, layers, callback) {
-  var self = this;
-
-  if (!layers || layers.length === 0) {
-      return callback(null, layers);
-  }
-
-  var augmentLayersQueue = queue(layers.length);
-
-  function augmentLayer(layer, done) {
-      if ( layer.type !== 'mapnik' && layer.type !== 'cartodb' ) {
-          return done(null, layer);
-      }
-      self.overviewsMetadataApi.getOverviewsMetadata(username, layer.options.sql, function(err, metadata){
-           if (err) {
-               done(err, layer);
-           } else {
-               if ( !_.isEmpty(metadata) ) {
-                   layer = _.extend({}, layer);
-                   layer.options = _.extend({}, layer.options, { query_rewrite_data: { overviews: metadata } });
-               }
-               done(null, layer);
-           }
-      });
-  }
-
-  function layersAugmentQueueFinish(err, layers) {
-    if (err) {
-        return callback(err);
-    }
-
-    if (!layers || layers.length === 0) {
-        return callback(new Error('Missing layers array from layergroup config'));
-    }
-
-    return callback(null, layers);
-  }
-
-  layers.forEach(function(layer) {
-      augmentLayersQueue.defer(augmentLayer, layer);
-  });
-  augmentLayersQueue.awaitAll(layersAugmentQueueFinish);
-
-};

lib/cartodb/server.js

@@ -3,7 +3,6 @@ var bodyParser = require('body-parser');
 var RedisPool = require('redis-mpool');
 var cartodbRedis = require('cartodb-redis');
 var _ = require('underscore');
-var debug = require('debug')('windshaft:cartodb');
 
 var controller = require('./controllers');
 
@@ -21,6 +20,7 @@ var mapnik = windshaft.mapnik;
 
 var TemplateMaps = require('./backends/template_maps.js');
 var OverviewsMetadataApi = require('./api/overviews_metadata_api');
+var FilterStatsApi = require('./api/filter_stats_api');
 var UserLimitsApi = require('./api/user_limits_api');
 var AuthApi = require('./api/auth_api');
 var LayergroupAffectedTablesCache = require('./cache/layergroup_affected_tables');
@@ -33,10 +33,13 @@ var AnalysisBackend = require('./backends/analysis');
 var timeoutErrorTilePath = __dirname + '/../../assets/render-timeout-fallback.png';
 var timeoutErrorTile = require('fs').readFileSync(timeoutErrorTilePath, {encoding: null});
 
-var MapConfigOverviewsAdapter = require('./models/mapconfig_overviews_adapter');
-
-var TurboCartoParser = require('./utils/style/turbo-carto-parser');
-var TurboCartoAdapter = require('./utils/style/turbo-carto-adapter');
+var SqlWrapMapConfigAdapter = require('./models/mapconfig/adapter/sql-wrap-mapconfig-adapter');
+var MapConfigNamedLayersAdapter = require('./models/mapconfig/adapter/mapconfig-named-layers-adapter');
+var AnalysisMapConfigAdapter = require('./models/mapconfig/adapter/analysis-mapconfig-adapter');
+var MapConfigOverviewsAdapter = require('./models/mapconfig/adapter/mapconfig-overviews-adapter');
+var TurboCartoAdapter = require('./models/mapconfig/adapter/turbo-carto-adapter');
+var DataviewsWidgetsAdapter = require('./models/mapconfig/adapter/dataviews-widgets-adapter');
+var MapConfigAdapter = require('./models/mapconfig/adapter');
 
 module.exports = function(serverOptions) {
     // Make stats client globally accessible
@@ -59,6 +62,7 @@ module.exports = function(serverOptions) {
     var pgConnection = new PgConnection(metadataBackend);
     var pgQueryRunner = new PgQueryRunner(pgConnection);
     var overviewsMetadataApi = new OverviewsMetadataApi(pgQueryRunner);
+    var filterStatsApi = new FilterStatsApi(pgQueryRunner);
     var userLimitsApi = new UserLimitsApi(metadataBackend, {
         limits: {
             cacheOnTimeout: serverOptions.renderer.mapnik.limits.cacheOnTimeout || false,
@@ -148,19 +152,21 @@ module.exports = function(serverOptions) {
     var layergroupAffectedTablesCache = new LayergroupAffectedTablesCache();
     app.layergroupAffectedTablesCache = layergroupAffectedTablesCache;
 
-    var overviewsAdapter = new MapConfigOverviewsAdapter(overviewsMetadataApi);
-
-    var turboCartoParser = new TurboCartoParser(pgQueryRunner);
-    var turboCartoAdapter = new TurboCartoAdapter(turboCartoParser);
+    var mapConfigAdapter = new MapConfigAdapter(
+        new MapConfigNamedLayersAdapter(templateMaps, pgConnection),
+        new SqlWrapMapConfigAdapter(),
+        new DataviewsWidgetsAdapter(),
+        new AnalysisMapConfigAdapter(analysisBackend),
+        new MapConfigOverviewsAdapter(overviewsMetadataApi, filterStatsApi),
+        new TurboCartoAdapter()
+    );
 
     var namedMapProviderCache = new NamedMapProviderCache(
         templateMaps,
         pgConnection,
         metadataBackend,
-        analysisBackend,
         userLimitsApi,
-        overviewsAdapter,
-        turboCartoAdapter
+        mapConfigAdapter
     );
 
     ['update', 'delete'].forEach(function(eventType) {
@@ -172,6 +178,8 @@ module.exports = function(serverOptions) {
     var TablesExtentApi = require('./api/tables_extent_api');
     var tablesExtentApi = new TablesExtentApi(pgQueryRunner);
 
+    var versions = getAndValidateVersions(serverOptions);
+
     /*******************************************************************************************************************
      * Routing
      ******************************************************************************************************************/
@@ -183,7 +191,6 @@ module.exports = function(serverOptions) {
         tileBackend,
         previewBackend,
         attributesBackend,
-        new windshaft.backend.Widget(),
         surrogateKeysCache,
         userLimitsApi,
         layergroupAffectedTablesCache,
@@ -199,9 +206,7 @@ module.exports = function(serverOptions) {
         surrogateKeysCache,
         userLimitsApi,
         layergroupAffectedTablesCache,
-        overviewsAdapter,
-        turboCartoAdapter,
-        analysisBackend
+        mapConfigAdapter
     ).register(app);
 
     new controller.NamedMaps(
@@ -217,7 +222,7 @@ module.exports = function(serverOptions) {
 
     new controller.NamedMapsAdmin(authApi, pgConnection, templateMaps).register(app);
 
-    new controller.ServerInfo().register(app);
+    new controller.ServerInfo(versions).register(app);
 
     /*******************************************************************************************************************
      * END Routing
@@ -230,12 +235,45 @@ function validateOptions(opts) {
     if (!_.isString(opts.base_url) || !_.isString(opts.base_url_mapconfig) || !_.isString(opts.base_url_templated)) {
         throw new Error("Must initialise server with: 'base_url'/'base_url_mapconfig'/'base_url_templated' URLs");
     }
+}
 
-    // Be nice and warn if configured mapnik version is != instaled mapnik version
-    if (mapnik.versions.mapnik !== opts.grainstore.mapnik_version) {
-        debug('WARNING: detected mapnik version (' + mapnik.versions.mapnik + ')' +
-            ' != configured mapnik version (' + opts.grainstore.mapnik_version + ')');
+function getAndValidateVersions(options) {
+    // jshint undef:false
+    var warn = console.warn.bind(console);
+    // jshint undef:true
+
+    var packageDefinition = require('../../package.json');
+
+    var declaredDependencies = packageDefinition.dependencies || {};
+    var installedDependenciesVersions = {
+        camshaft: require('camshaft').version,
+        grainstore: windshaft.grainstore.version(),
+        mapnik: windshaft.mapnik.versions.mapnik,
+        node_mapnik: windshaft.mapnik.version,
+        'turbo-carto': require('turbo-carto').version,
+        windshaft: windshaft.version,
+        windshaft_cartodb: packageDefinition.version
+    };
+
+    var dependenciesToValidate = ['camshaft', 'turbo-carto', 'windshaft'];
+    dependenciesToValidate.forEach(function(depName) {
+        var declaredDependencyVersion = declaredDependencies[depName];
+        var installedDependencyVersion = installedDependenciesVersions[depName];
+        if (declaredDependencyVersion !== installedDependencyVersion) {
+            warn(
+                'Dependency="%s" installed version="%s" does not match declared version="%s". Check your installation.',
+                depName, installedDependencyVersion, declaredDependencyVersion
+            );
+        }
+    });
+
+    // Be nice and warn if configured mapnik version is != installed mapnik version
+    if (mapnik.versions.mapnik !== options.grainstore.mapnik_version) {
+        warn('WARNING: detected mapnik version (' + mapnik.versions.mapnik + ')' +
+            ' != configured mapnik version (' + options.grainstore.mapnik_version + ')');
     }
+
+    return installedDependenciesVersions;
 }
 
 function bootstrapFonts(opts) {

lib/cartodb/utils/overviews_query_rewriter.js

@@ -1,5 +1,26 @@
+var _ = require('underscore');
 var TableNameParser = require('./table_name_parser');
 
+var BBoxFilter = require('../models/filter/bbox');
+var CamshaftFilter = require('../models/filter/camshaft');
+
+// Minimim number of filtered rows to use overviews
+var FILTER_MIN_ROWS = 65536;
+// Maximum filtered fraction to not apply overviews
+var FILTER_MAX_FRACTION = 0.2;
+
+function apply_filters_to_query(query, filters, bbox_filter) {
+    if ( filters && !_.isEmpty(filters)) {
+        var camshaftFilter = new CamshaftFilter(filters);
+        query = camshaftFilter.sql(query);
+    }
+    if ( bbox_filter ) {
+        var bboxFilter = new BBoxFilter(bbox_filter.options, bbox_filter.params);
+        query = bboxFilter.sql(query);
+    }
+    return query;
+}
+
 function OverviewsQueryRewriter(options) {
 
     this.options = options;
@@ -119,26 +140,34 @@ function replace_table_in_query(sql, old_table_name, replacement) {
     return sql.replace(new RegExp(regexp, 'g'), replacement);
 }
 
-function overviews_query(query, overviews, zoom_level_expression) {
+
+function replace_table_in_query_with_schema(query, table, schema, replacement) {
+    if ( replacement ) {
+        query = replace_table_in_query(query, table, replacement);
+        var parsed_table = TableNameParser.parse(table);
+        if (!parsed_table.schema && schema) {
+            // replace also the qualified table name, if the table wasn't qualified
+            parsed_table.schema = schema;
+            table = TableNameParser.table_identifier(parsed_table);
+            query = replace_table_in_query(query, table, replacement);
+        }
+    }
+    return query;
+}
+
+// Build query to use overviews for a variant zoom level (given by a expression to
+// be evaluated by the database server)
+function overviews_query_with_zoom_expression(query, overviews, zoom_level_expression) {
     var replaced_query = query;
     var sql = "WITH\n  _vovw_scale AS ( SELECT " + zoom_level_expression + " AS _vovw_z )";
     var replacement;
-    for ( var table in overviews ) {
-        if (overviews.hasOwnProperty(table)) {
-            var table_overviews = overviews[table];
-            var table_view = overviews_view_name(table);
-            var schema = table_overviews.schema;
-            replacement = "(\n" + overviews_view_for_table(table, table_overviews) + "\n  ) AS " + table_view;
-            replaced_query = replace_table_in_query(replaced_query, table, replacement);
-            var parsed_table = TableNameParser.parse(table);
-            if (!parsed_table.schema && schema) {
-                // replace also the qualified table name, if the table wasn't qualified
-                parsed_table.schema = schema;
-                table = TableNameParser.table_identifier(parsed_table);
-                replaced_query = replace_table_in_query(replaced_query, table, replacement);
-            }
-        }
-    }
+    _.each(Object.keys(overviews), function(table) {
+        var table_overviews = overviews[table];
+        var table_view = overviews_view_name(table);
+        var schema = table_overviews.schema;
+        replacement = "(\n" + overviews_view_for_table(table, table_overviews) + "\n  ) AS " + table_view;
+        replaced_query = replace_table_in_query_with_schema(replaced_query, table, schema, replacement);
+    });
     if ( replaced_query !== query ) {
         sql += "\n";
         sql += replaced_query;
@@ -148,34 +177,128 @@ function overviews_query(query, overviews, zoom_level_expression) {
     return sql;
 }
 
+// Build query to use overviews for a specific zoom level value
+function overviews_query_with_definite_zoom(query, overviews, zoom_level) {
+    var replaced_query = query;
+    var replacement;
+    _.each(Object.keys(overviews), function(table) {
+        var table_overviews = overviews[table];
+        var schema = table_overviews.schema;
+        replacement = overview_table_for_zoom_level(table_overviews, zoom_level);
+        replaced_query = replace_table_in_query_with_schema(replaced_query, table, schema, replacement);
+    });
+    return replaced_query;
+}
+
+// Find a suitable overview table for a specific zoom_level
+function overview_table_for_zoom_level(table_overviews, zoom_level) {
+    var overview_table;
+    if ( table_overviews ) {
+        overview_table = table_overviews[zoom_level];
+        if ( !overview_table ) {
+            _.every(Object.keys(table_overviews).sort(function(x,y){ return x-y; }), function(overview_zoom) {
+              if ( +overview_zoom > +zoom_level ) {
+                  overview_table = table_overviews[overview_zoom];
+                  return false;
+              } else {
+                  return true;
+              }
+            });
+        }
+    }
+    if ( overview_table ) {
+        overview_table = overview_table.table;
+    }
+    return overview_table;
+}
+
 // Transform an SQL query so that it uses overviews.
-// overviews contains metadata about the overviews to be used:
-//     { 'table-name': {1: { table: 'overview-table-1' }, ... }, ... }
 //
 // For a given query `SELECT * FROM table`,  if any of tables in it
 // has overviews as defined by the provided metadat, the query will
 // be transform into something similar to this:
 //
 //     WITH _vovw_scale AS ( ... ), -- define scale level
-//     WITH _vovw_table AS ( ... ), -- define union of overviews and base table
-//     SELECT * FROM _vovw_table -- query with table replaced by _vovw_table
+//     SELECT * FROM                -- in the query the table is replaced by:
+//      ( ... ) AS _vovw_table      -- a union of overviews and base table
 //
-// This transformation can in principle be applied to arbitrary queries
-// (except for the case of queries that include the name of tables with
-// overviews inside text literals: at the current table name substitution
-// doesnn't prevent substitution inside literals).
-// But the transformation will currently only be applied to simple queries
-// of the form detected by the overviews_supported_query function.
-OverviewsQueryRewriter.prototype.query = function(query, data) {
-    var overviews = this.overviews_metadata(data);
-    if ( !overviews || !this.is_supported_query(query)) {
+// The data argument has the form:
+//    {
+//        overviews:             // overview tables metadata
+//             { 'table-name': {1: { table: 'overview-table-1' }, ... }, ... },
+//        zoom_level: ...,       // optional zoom level
+//        filters: ...,          // filters definition
+//        unfiltered_query: ..., // query without the filters
+//        bbox_filter: ...       // bounding-box filter
+//    }
+OverviewsQueryRewriter.prototype.query = function(query, data, options) {
+    options = options || {};
+    data    = data || {};
+
+    var overviews        = data.overviews;
+    var unfiltered_query = data.unfiltered_query;
+    var filters          = data.filters;
+    var bbox_filter      = data.bbox_filter;
+
+    if ( !unfiltered_query ) {
+        unfiltered_query = query;
+    }
+
+    if ( !should_use_overviews(unfiltered_query, data) ) {
         return query;
     }
-    var zoom_level_expression = this.options.zoom_level || '0';
-    return overviews_query(query, overviews, zoom_level_expression);
+
+    var rewritten_query;
+
+    var zoom_level_expression = this.options.zoom_level;
+    var zoom_level = zoom_level_for_query(unfiltered_query, zoom_level_expression, options);
+
+    rewritten_query = overviews_query(unfiltered_query, overviews, zoom_level, zoom_level_expression);
+
+    if ( rewritten_query === unfiltered_query ) {
+        // could not or didn't need to alter the query
+        rewritten_query = query;
+    } else {
+        rewritten_query = apply_filters_to_query(rewritten_query, filters, bbox_filter);
+    }
+
+    return rewritten_query;
 };
 
-OverviewsQueryRewriter.prototype.is_supported_query = function(sql) {
+function zoom_level_for_query(query, zoom_level_expression, options) {
+    var zoom_level = null;
+    if ( _.has(options, 'zoom_level') ) {
+        zoom_level = options.zoom_level || '0';
+    }
+    if ( zoom_level === null && !zoom_level_expression ) {
+        zoom_level = '0';
+    }
+    return zoom_level;
+}
+
+function overviews_query(query, overviews, zoom_level, zoom_level_expression) {
+    if ( zoom_level || zoom_level === '0' || zoom_level === 0 ) {
+        return overviews_query_with_definite_zoom(query, overviews, zoom_level);
+    } else {
+        return overviews_query_with_zoom_expression(query, overviews, zoom_level_expression);
+    }
+}
+
+function should_use_overviews(query, data) {
+    data = data || {};
+    var use_overviews = data.overviews && is_supported_query(query);
+    if ( use_overviews && data.filters && data.filter_stats ) {
+        var filtered_rows = data.filter_stats.filtered_rows;
+        var unfiltered_rows = data.filter_stats.unfiltered_rows;
+        if ( unfiltered_rows && (filtered_rows || filtered_rows === 0) ) {
+            use_overviews = filtered_rows >= FILTER_MIN_ROWS ||
+                            (filtered_rows/unfiltered_rows) > FILTER_MAX_FRACTION;
+        }
+    }
+    return use_overviews;
+}
+
+function is_supported_query(sql) {
     var basic_query =
         /\s*SELECT\s+[\*a-z0-9_,\s]+?\s+FROM\s+((\"[^"]+\"|[a-z0-9_]+)\.)?(\"[^"]+\"|[a-z0-9_]+)\s*;?\s*/i;
     var unwrapped_query = new RegExp("^"+basic_query.source+"$", 'i');
@@ -187,8 +310,4 @@ OverviewsQueryRewriter.prototype.is_supported_query = function(sql) {
         'i'
     );
     return !!(sql.match(unwrapped_query) || sql.match(wrapped_query));
-};
-
-OverviewsQueryRewriter.prototype.overviews_metadata = function(data) {
-    return data && data.overviews;
-};
+}

lib/cartodb/utils/style/postgres-datasource.js

@@ -1,59 +0,0 @@
-'use strict';
-
-var dot = require('dot');
-dot.templateSettings.strip = false;
-
-function createTemplate(method) {
-    return dot.template([
-        'SELECT',
-        method,
-        'FROM ({{=it._sql}}) _table_sql WHERE {{=it._column}} IS NOT NULL'
-    ].join('\n'));
-}
-
-var methods = {
-    quantiles: 'CDB_QuantileBins(array_agg(distinct({{=it._column}}::numeric)), {{=it._buckets}}) as quantiles',
-    equal: 'CDB_EqualIntervalBins(array_agg({{=it._column}}::numeric), {{=it._buckets}}) as equal',
-    jenks: 'CDB_JenksBins(array_agg(distinct({{=it._column}}::numeric)), {{=it._buckets}}) as jenks',
-    headtails: 'CDB_HeadsTailsBins(array_agg(distinct({{=it._column}}::numeric)), {{=it._buckets}}) as headtails'
-};
-
-var methodTemplates = Object.keys(methods).reduce(function(methodTemplates, methodName) {
-    methodTemplates[methodName] = createTemplate(methods[methodName]);
-    return methodTemplates;
-}, {});
-
-var method2strategy = {
-    headtails: 'split'
-};
-
-function PostgresDatasource (pgQueryRunner, username, query) {
-    this.pgQueryRunner = pgQueryRunner;
-    this.username = username;
-    this.query = query;
-}
-
-PostgresDatasource.prototype.getName = function () {
-    return 'PostgresDatasource';
-};
-
-PostgresDatasource.prototype.getRamp = function (column, buckets, method, callback) {
-    var methodName = methods.hasOwnProperty(method) ? method : 'quantiles';
-    var template = methodTemplates[methodName];
-
-    var query = template({ _column: column, _sql: this.query, _buckets: buckets });
-
-    this.pgQueryRunner.run(this.username, query, function (err, result) {
-        if (err) {
-            return callback(err);
-        }
-
-        var ramp = result[0][methodName].sort(function(a, b) {
-            return a - b;
-        });
-
-        return callback(null, { ramp: ramp, strategy: method2strategy[methodName] });
-    });
-};
-
-module.exports = PostgresDatasource;

lib/cartodb/utils/style/turbo-carto-adapter.js

@@ -1,70 +0,0 @@
-'use strict';
-
-var queue = require('queue-async');
-var SubstitutionTokens = require('../substitution-tokens');
-
-function TurboCartoAdapter(turboCartoParser) {
-    this.turboCartoParser = turboCartoParser;
-}
-
-module.exports = TurboCartoAdapter;
-
-TurboCartoAdapter.prototype.getLayers = function (username, layers, callback) {
-    var self = this;
-
-    if (!layers || layers.length === 0) {
-        return callback(null, layers);
-    }
-
-    var parseCartoQueue = queue(layers.length);
-
-    layers.forEach(function(layer) {
-        parseCartoQueue.defer(self._parseCartoCss.bind(self), username, layer);
-    });
-
-    parseCartoQueue.awaitAll(function (err, layers) {
-        if (err) {
-            return callback(err);
-        }
-
-        return callback(null, layers);
-    });
-};
-
-TurboCartoAdapter.prototype._parseCartoCss = function (username, layer, callback) {
-    if (isNotLayerToParseCartocss(layer)) {
-        return process.nextTick(function () {
-            callback(null, layer);
-        });
-    }
-
-    var sql = SubstitutionTokens.replace(layer.options.sql, {
-        bbox: 'ST_MakeEnvelope(-20037508.34,-20037508.34,20037508.34,20037508.34,3857)',
-        scale_denominator: '500000001',
-        pixel_width: '156412',
-        pixel_height: '156412'
-    });
-
-    this.turboCartoParser.process(username, layer.options.cartocss, sql, function (err, cartocss) {
-        // Only return turbo-carto errors
-        if (err && err.name === 'TurboCartoError') {
-            err = new Error('turbo-carto: ' + err.message);
-            err.http_status = 400;
-            return callback(err);
-        }
-
-        // Try to continue in the rest of the cases
-        if (cartocss) {
-            layer.options.cartocss = cartocss;
-        }
-        return callback(null, layer);
-    });
-};
-
-function isNotLayerToParseCartocss(layer) {
-    if (!layer || !layer.options || !layer.options.cartocss || !layer.options.sql) {
-        return true;
-    }
-
-    return false;
-}

lib/cartodb/utils/style/turbo-carto-parser.js

@@ -1,15 +0,0 @@
-'use strict';
-
-var turboCarto = require('turbo-carto');
-var PostgresDatasource = require('./postgres-datasource');
-
-function TurboCartoParser (pgQueryRunner) {
-    this.pgQueryRunner = pgQueryRunner;
-}
-
-module.exports = TurboCartoParser;
-
-TurboCartoParser.prototype.process = function (username, cartocss, sql, callback) {
-    var datasource = new PostgresDatasource(this.pgQueryRunner, username, sql);
-    turboCarto(cartocss, datasource, callback);
-};

lib/cartodb/utils/substitution-tokens.js

@@ -6,6 +6,16 @@ var SUBSTITUTION_TOKENS = {
 };
 
 var SubstitutionTokens = {
+    tokens: function(sql) {
+        return Object.keys(SUBSTITUTION_TOKENS).filter(function(tokenName) {
+            return !!sql.match(SUBSTITUTION_TOKENS[tokenName]);
+        });
+    },
+
+    hasTokens: function(sql) {
+        return this.tokens(sql).length > 0;
+    },
+
     replace: function(sql, replaceValues) {
         Object.keys(replaceValues).forEach(function(token) {
             if (SUBSTITUTION_TOKENS[token]) {

npm-shrinkwrap.json

@@ -1,6 +1,6 @@
 {
   "name": "windshaft-cartodb",
-  "version": "2.42.2",
+  "version": "2.53.4",
   "dependencies": {
     "body-parser": {
       "version": "1.14.2",
@@ -33,9 +33,9 @@
               "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
             },
             "statuses": {
-              "version": "1.2.1",
+              "version": "1.3.0",
               "from": "statuses@>=1.0.0 <2.0.0",
-              "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.2.1.tgz"
+              "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.3.0.tgz"
             }
           }
         },
@@ -62,14 +62,14 @@
           "resolved": "https://registry.npmjs.org/qs/-/qs-5.2.0.tgz"
         },
         "raw-body": {
-          "version": "2.1.6",
+          "version": "2.1.7",
           "from": "raw-body@>=2.1.5 <2.2.0",
-          "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.1.6.tgz",
+          "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.1.7.tgz",
           "dependencies": {
             "bytes": {
-              "version": "2.3.0",
-              "from": "bytes@2.3.0",
-              "resolved": "https://registry.npmjs.org/bytes/-/bytes-2.3.0.tgz"
+              "version": "2.4.0",
+              "from": "bytes@2.4.0",
+              "resolved": "https://registry.npmjs.org/bytes/-/bytes-2.4.0.tgz"
             },
             "unpipe": {
               "version": "1.0.0",
@@ -79,9 +79,9 @@
           }
         },
         "type-is": {
-          "version": "1.6.12",
-          "from": "type-is@>=1.6.6 <1.7.0",
-          "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.12.tgz",
+          "version": "1.6.13",
+          "from": "type-is@>=1.6.10 <1.7.0",
+          "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.13.tgz",
           "dependencies": {
             "media-typer": {
               "version": "0.3.0",
@@ -90,7 +90,7 @@
             },
             "mime-types": {
               "version": "2.1.11",
-              "from": "mime-types@>=2.1.10 <2.2.0",
+              "from": "mime-types@>=2.1.11 <2.2.0",
               "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.11.tgz",
               "dependencies": {
                 "mime-db": {
@@ -105,9 +105,9 @@
       }
     },
     "camshaft": {
-      "version": "0.8.0",
-      "from": "camshaft@0.8.0",
-      "resolved": "https://registry.npmjs.org/camshaft/-/camshaft-0.8.0.tgz",
+      "version": "0.22.4",
+      "from": "camshaft@0.22.4",
+      "resolved": "https://registry.npmjs.org/camshaft/-/camshaft-0.22.4.tgz",
       "dependencies": {
         "async": {
           "version": "1.5.2",
@@ -146,7 +146,7 @@
                     },
                     "inherits": {
                       "version": "2.0.1",
-                      "from": "inherits@>=2.0.1 <2.1.0",
+                      "from": "inherits@>=2.0.0 <3.0.0",
                       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
                     },
                     "isarray": {
@@ -354,9 +354,9 @@
                   "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-0.2.0.tgz"
                 },
                 "jsprim": {
-                  "version": "1.2.2",
+                  "version": "1.3.0",
                   "from": "jsprim@>=1.2.2 <2.0.0",
-                  "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.2.2.tgz",
+                  "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.3.0.tgz",
                   "dependencies": {
                     "extsprintf": {
                       "version": "1.0.2",
@@ -391,9 +391,9 @@
                       "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz"
                     },
                     "dashdash": {
-                      "version": "1.13.1",
+                      "version": "1.14.0",
                       "from": "dashdash@>=1.12.0 <2.0.0",
-                      "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.13.1.tgz"
+                      "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.0.tgz"
                     },
                     "getpass": {
                       "version": "0.1.6",
@@ -757,14 +757,55 @@
           }
         },
         "serve-static": {
-          "version": "1.10.2",
+          "version": "1.10.3",
           "from": "serve-static@>=1.10.2 <1.11.0",
-          "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.10.2.tgz"
+          "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.10.3.tgz",
+          "dependencies": {
+            "send": {
+              "version": "0.13.2",
+              "from": "send@0.13.2",
+              "resolved": "https://registry.npmjs.org/send/-/send-0.13.2.tgz",
+              "dependencies": {
+                "destroy": {
+                  "version": "1.0.4",
+                  "from": "destroy@>=1.0.4 <1.1.0",
+                  "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz"
+                },
+                "http-errors": {
+                  "version": "1.3.1",
+                  "from": "http-errors@>=1.3.1 <1.4.0",
+                  "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.3.1.tgz",
+                  "dependencies": {
+                    "inherits": {
+                      "version": "2.0.1",
+                      "from": "inherits@>=2.0.1 <2.1.0",
+                      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
+                    }
+                  }
+                },
+                "mime": {
+                  "version": "1.3.4",
+                  "from": "mime@1.3.4",
+                  "resolved": "https://registry.npmjs.org/mime/-/mime-1.3.4.tgz"
+                },
+                "ms": {
+                  "version": "0.7.1",
+                  "from": "ms@0.7.1",
+                  "resolved": "https://registry.npmjs.org/ms/-/ms-0.7.1.tgz"
+                },
+                "statuses": {
+                  "version": "1.2.1",
+                  "from": "statuses@>=1.2.1 <1.3.0",
+                  "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.2.1.tgz"
+                }
+              }
+            }
+          }
         },
         "type-is": {
-          "version": "1.6.12",
+          "version": "1.6.13",
           "from": "type-is@>=1.6.6 <1.7.0",
-          "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.12.tgz",
+          "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.13.tgz",
           "dependencies": {
             "media-typer": {
               "version": "0.3.0",
@@ -988,7 +1029,7 @@
         },
         "mime-types": {
           "version": "2.1.11",
-          "from": "mime-types@>=2.1.10 <2.2.0",
+          "from": "mime-types@>=2.1.2 <2.2.0",
           "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.11.tgz",
           "dependencies": {
             "mime-db": {
@@ -1212,12 +1253,13 @@
     },
     "step-profiler": {
       "version": "0.3.0",
-      "from": "step-profiler@>=0.3.0 <0.4.0"
+      "from": "step-profiler@>=0.3.0 <0.4.0",
+      "resolved": "https://registry.npmjs.org/step-profiler/-/step-profiler-0.3.0.tgz"
     },
     "turbo-carto": {
-      "version": "0.9.2",
-      "from": "turbo-carto@0.9.2",
-      "resolved": "https://registry.npmjs.org/turbo-carto/-/turbo-carto-0.9.2.tgz",
+      "version": "0.12.1",
+      "from": "turbo-carto@0.12.1",
+      "resolved": "https://registry.npmjs.org/turbo-carto/-/turbo-carto-0.12.1.tgz",
       "dependencies": {
         "colorbrewer": {
           "version": "1.0.0",
@@ -1276,14 +1318,14 @@
       "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.6.0.tgz"
     },
     "windshaft": {
-      "version": "1.19.0",
-      "from": "windshaft@1.19.0",
-      "resolved": "https://registry.npmjs.org/windshaft/-/windshaft-1.19.0.tgz",
+      "version": "2.3.0",
+      "from": "windshaft@2.3.0",
+      "resolved": "https://registry.npmjs.org/windshaft/-/windshaft-2.3.0.tgz",
       "dependencies": {
         "abaculus": {
-          "version": "1.1.0-cdb4",
-          "from": "https://github.com/CartoDB/abaculus/tarball/1.1.0-cdb4",
-          "resolved": "https://github.com/CartoDB/abaculus/tarball/1.1.0-cdb4"
+          "version": "1.1.0-cdb5",
+          "from": "https://github.com/CartoDB/abaculus/tarball/1.1.0-cdb5",
+          "resolved": "https://github.com/CartoDB/abaculus/tarball/1.1.0-cdb5"
         },
         "canvas": {
           "version": "1.2.7-cdb1",
@@ -1327,9 +1369,9 @@
           }
         },
         "grainstore": {
-          "version": "1.1.1",
-          "from": "grainstore@1.1.1",
-          "resolved": "https://registry.npmjs.org/grainstore/-/grainstore-1.1.1.tgz",
+          "version": "1.2.0",
+          "from": "grainstore@1.2.0",
+          "resolved": "https://registry.npmjs.org/grainstore/-/grainstore-1.2.0.tgz",
           "dependencies": {
             "carto": {
               "version": "0.9.5-cdb2",
@@ -2915,25 +2957,25 @@
                   "resolved": "https://registry.npmjs.org/sqlite3/-/sqlite3-3.1.4.tgz",
                   "dependencies": {
                     "nan": {
-                      "version": "2.3.3",
+                      "version": "2.3.5",
                       "from": "nan@>=2.3.3 <2.4.0",
-                      "resolved": "https://registry.npmjs.org/nan/-/nan-2.3.3.tgz"
+                      "resolved": "https://registry.npmjs.org/nan/-/nan-2.3.5.tgz"
                     },
                     "node-pre-gyp": {
                       "version": "0.6.28",
                       "from": "node-pre-gyp@>=0.6.28 <0.7.0",
                       "resolved": "https://registry.npmjs.org/node-pre-gyp/-/node-pre-gyp-0.6.28.tgz"
                     },
-                    "abbrev": {
-                      "version": "1.0.7",
-                      "from": "abbrev@>=1.0.0 <2.0.0",
-                      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.0.7.tgz"
-                    },
                     "ansi": {
                       "version": "0.3.1",
                       "from": "ansi@>=0.3.1 <0.4.0",
                       "resolved": "https://registry.npmjs.org/ansi/-/ansi-0.3.1.tgz"
                     },
+                    "abbrev": {
+                      "version": "1.0.7",
+                      "from": "abbrev@>=1.0.0 <2.0.0",
+                      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.0.7.tgz"
+                    },
                     "ansi-regex": {
                       "version": "2.0.0",
                       "from": "ansi-regex@>=2.0.0 <3.0.0",
@@ -2954,16 +2996,16 @@
                       "from": "asn1@>=0.2.3 <0.3.0",
                       "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.3.tgz"
                     },
-                    "async": {
-                      "version": "1.5.2",
-                      "from": "async@>=1.5.2 <2.0.0",
-                      "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz"
-                    },
                     "assert-plus": {
                       "version": "0.2.0",
                       "from": "assert-plus@>=0.2.0 <0.3.0",
                       "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-0.2.0.tgz"
                     },
+                    "async": {
+                      "version": "1.5.2",
+                      "from": "async@>=1.5.2 <2.0.0",
+                      "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz"
+                    },
                     "aws-sign2": {
                       "version": "0.6.0",
                       "from": "aws-sign2@>=0.6.0 <0.7.0",
@@ -2989,16 +3031,16 @@
                       "from": "boom@>=2.0.0 <3.0.0",
                       "resolved": "https://registry.npmjs.org/boom/-/boom-2.10.1.tgz"
                     },
-                    "brace-expansion": {
-                      "version": "1.1.4",
-                      "from": "brace-expansion@>=1.0.0 <2.0.0",
-                      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.4.tgz"
-                    },
                     "caseless": {
                       "version": "0.11.0",
                       "from": "caseless@>=0.11.0 <0.12.0",
                       "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.11.0.tgz"
                     },
+                    "brace-expansion": {
+                      "version": "1.1.4",
+                      "from": "brace-expansion@>=1.0.0 <2.0.0",
+                      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.4.tgz"
+                    },
                     "chalk": {
                       "version": "1.1.3",
                       "from": "chalk@>=1.1.1 <2.0.0",
@@ -3034,16 +3076,16 @@
                       "from": "debug@>=2.2.0 <2.3.0",
                       "resolved": "https://registry.npmjs.org/debug/-/debug-2.2.0.tgz"
                     },
-                    "deep-extend": {
-                      "version": "0.4.1",
-                      "from": "deep-extend@>=0.4.0 <0.5.0",
-                      "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.4.1.tgz"
-                    },
                     "delayed-stream": {
                       "version": "1.0.0",
                       "from": "delayed-stream@>=1.0.0 <1.1.0",
                       "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz"
                     },
+                    "deep-extend": {
+                      "version": "0.4.1",
+                      "from": "deep-extend@>=0.4.0 <0.5.0",
+                      "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.4.1.tgz"
+                    },
                     "delegates": {
                       "version": "1.0.0",
                       "from": "delegates@>=1.0.0 <2.0.0",
@@ -3059,16 +3101,16 @@
                       "from": "escape-string-regexp@>=1.0.2 <2.0.0",
                       "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz"
                     },
-                    "extend": {
-                      "version": "3.0.0",
-                      "from": "extend@>=3.0.0 <3.1.0",
-                      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.0.tgz"
-                    },
                     "extsprintf": {
                       "version": "1.0.2",
                       "from": "extsprintf@1.0.2",
                       "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.0.2.tgz"
                     },
+                    "extend": {
+                      "version": "3.0.0",
+                      "from": "extend@>=3.0.0 <3.1.0",
+                      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.0.tgz"
+                    },
                     "forever-agent": {
                       "version": "0.6.1",
                       "from": "forever-agent@>=0.6.1 <0.7.0",
@@ -3104,16 +3146,16 @@
                       "from": "generate-object-property@>=1.1.0 <2.0.0",
                       "resolved": "https://registry.npmjs.org/generate-object-property/-/generate-object-property-1.2.0.tgz"
                     },
-                    "glob": {
-                      "version": "7.0.3",
-                      "from": "glob@>=7.0.0 <8.0.0",
-                      "resolved": "https://registry.npmjs.org/glob/-/glob-7.0.3.tgz"
-                    },
                     "graceful-fs": {
                       "version": "4.1.4",
                       "from": "graceful-fs@>=4.1.2 <5.0.0",
                       "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.4.tgz"
                     },
+                    "glob": {
+                      "version": "7.0.3",
+                      "from": "glob@>=7.0.0 <8.0.0",
+                      "resolved": "https://registry.npmjs.org/glob/-/glob-7.0.3.tgz"
+                    },
                     "graceful-readlink": {
                       "version": "1.0.1",
                       "from": "graceful-readlink@>=1.0.0",
@@ -3129,16 +3171,16 @@
                       "from": "has-ansi@>=2.0.0 <3.0.0",
                       "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz"
                     },
-                    "has-unicode": {
-                      "version": "2.0.0",
-                      "from": "has-unicode@>=2.0.0 <3.0.0",
-                      "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.0.tgz"
-                    },
                     "hawk": {
                       "version": "3.1.3",
                       "from": "hawk@>=3.1.3 <3.2.0",
                       "resolved": "https://registry.npmjs.org/hawk/-/hawk-3.1.3.tgz"
                     },
+                    "has-unicode": {
+                      "version": "2.0.0",
+                      "from": "has-unicode@>=2.0.0 <3.0.0",
+                      "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.0.tgz"
+                    },
                     "hoek": {
                       "version": "2.16.3",
                       "from": "hoek@>=2.0.0 <3.0.0",
@@ -3384,16 +3426,16 @@
                       "from": "tar@>=2.2.0 <2.3.0",
                       "resolved": "https://registry.npmjs.org/tar/-/tar-2.2.1.tgz"
                     },
-                    "tough-cookie": {
-                      "version": "2.2.2",
-                      "from": "tough-cookie@>=2.2.0 <2.3.0",
-                      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.2.2.tgz"
-                    },
                     "tunnel-agent": {
                       "version": "0.4.3",
                       "from": "tunnel-agent@>=0.4.1 <0.5.0",
                       "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.4.3.tgz"
                     },
+                    "tough-cookie": {
+                      "version": "2.2.2",
+                      "from": "tough-cookie@>=2.2.0 <2.3.0",
+                      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.2.2.tgz"
+                    },
                     "tweetnacl": {
                       "version": "0.13.3",
                       "from": "tweetnacl@>=0.13.0 <0.14.0",
@@ -3537,9 +3579,9 @@
           }
         },
         "mapnik": {
-          "version": "1.4.15-cdb6",
-          "from": "https://github.com/CartoDB/node-mapnik/tarball/1.4.15-cdb6",
-          "resolved": "https://github.com/CartoDB/node-mapnik/tarball/1.4.15-cdb6",
+          "version": "1.4.15-cdb8",
+          "from": "https://github.com/CartoDB/node-mapnik/tarball/1.4.15-cdb8",
+          "resolved": "https://github.com/CartoDB/node-mapnik/tarball/1.4.15-cdb8",
           "dependencies": {
             "nan": {
               "version": "1.2.0",
@@ -3956,14 +3998,14 @@
           }
         },
         "tilelive-bridge": {
-          "version": "1.3.0-cdb4",
-          "from": "https://github.com/CartoDB/tilelive-bridge/tarball/1.3.0-cdb4",
-          "resolved": "https://github.com/CartoDB/tilelive-bridge/tarball/1.3.0-cdb4",
+          "version": "1.3.0-cdb5",
+          "from": "https://github.com/CartoDB/tilelive-bridge/tarball/1.3.0-cdb5",
+          "resolved": "https://github.com/CartoDB/tilelive-bridge/tarball/1.3.0-cdb5",
           "dependencies": {
             "mapnik-pool": {
-              "version": "0.1.1-cdb4",
-              "from": "https://github.com/CartoDB/mapnik-pool/tarball/0.1.1-cdb4",
-              "resolved": "https://github.com/CartoDB/mapnik-pool/tarball/0.1.1-cdb4",
+              "version": "0.1.1-cdb5",
+              "from": "https://github.com/CartoDB/mapnik-pool/tarball/0.1.1-cdb5",
+              "resolved": "https://github.com/CartoDB/mapnik-pool/tarball/0.1.1-cdb5",
               "dependencies": {
                 "generic-pool": {
                   "version": "2.1.1",
@@ -3980,9 +4022,9 @@
           }
         },
         "tilelive-mapnik": {
-          "version": "0.6.15-cdb5",
-          "from": "https://github.com/CartoDB/tilelive-mapnik/tarball/0.6.15-cdb5",
-          "resolved": "https://github.com/CartoDB/tilelive-mapnik/tarball/0.6.15-cdb5",
+          "version": "0.6.15-cdb7",
+          "from": "https://github.com/CartoDB/tilelive-mapnik/tarball/0.6.15-cdb7",
+          "resolved": "https://github.com/CartoDB/tilelive-mapnik/tarball/0.6.15-cdb7",
           "dependencies": {
             "generic-pool": {
               "version": "2.1.1",

package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "windshaft-cartodb",
-  "version": "2.42.2",
+  "version": "2.53.4",
   "description": "A map tile server for CartoDB",
   "keywords": [
     "cartodb"
@@ -20,7 +20,7 @@
   ],
   "dependencies": {
     "body-parser": "~1.14.0",
-    "camshaft": "0.8.0",
+    "camshaft": "0.22.4",
     "cartodb-psql": "~0.6.1",
     "cartodb-query-tables": "~0.1.0",
     "cartodb-redis": "~0.13.0",
@@ -37,9 +37,9 @@
     "request": "~2.62.0",
     "step": "~0.0.6",
     "step-profiler": "~0.3.0",
-    "turbo-carto": "0.9.2",
+    "turbo-carto": "0.12.1",
     "underscore": "~1.6.0",
-    "windshaft": "1.19.0"
+    "windshaft": "2.3.0"
   },
   "devDependencies": {
     "istanbul": "~0.4.3",

run_tests.sh

@@ -5,6 +5,7 @@ OPT_CREATE_PGSQL=yes # create the PostgreSQL test environment
 OPT_DROP_REDIS=yes   # drop the redis test environment
 OPT_DROP_PGSQL=yes   # drop the PostgreSQL test environment
 OPT_COVERAGE=no      # run tests with coverage
+OPT_DOWNLOAD_SQL=yes # download a fresh copy of sql files
 
 export PGAPPNAME=cartodb_tiler_tester
 
@@ -73,6 +74,10 @@ while [ -n "$1" ]; do
                 OPT_CREATE_REDIS=no
                 shift
                 continue
+        elif test "$1" = "--no-sql-download"; then
+                OPT_DOWNLOAD_SQL=no
+                shift
+                continue
         elif test "$1" = "--with-coverage"; then
                 OPT_COVERAGE=yes
                 shift
@@ -113,6 +118,9 @@ fi
 if test x"$OPT_CREATE_REDIS" != xyes; then
   PREPARE_DB_OPTS="$PREPARE_DB_OPTS --skip-redis"
 fi
+if test x"$OPT_DOWNLOAD_SQL" != xyes; then
+  PREPARE_DB_OPTS="$PREPARE_DB_OPTS --no-sql-download"
+fi
 
 echo "Preparing the environment"
 cd ${BASEDIR}/test/support

test/acceptance/analysis/error-cases.js

@@ -20,6 +20,13 @@ describe('analysis-layers error cases', function() {
         }
     };
 
+    var AUTH_ERROR_RESPONSE = {
+        status: 403,
+        headers: {
+            'Content-Type': 'application/json; charset=utf-8'
+        }
+    };
+
     it('should handle missing analysis nodes for layers', function(done) {
         var mapConfig = createMapConfig(
             [
@@ -64,4 +71,200 @@ describe('analysis-layers error cases', function() {
             testClient.drain(done);
         });
     });
+
+    it('should handle missing analyses when layers point to nonexistent one', function(done) {
+        var mapConfig = createMapConfig(
+            [
+                {
+                    "type": "http",
+                    "options": {
+                        "urlTemplate": "http://{s}.basemaps.cartocdn.com/light_only_labels/{z}/{x}/{y}.png",
+                        "subdomains": "abcd"
+                    }
+                },
+                {
+                    "type": "cartodb",
+                    "options": {
+                        "source": {
+                            "id": "ID-FOR-NONEXISTENT-ANALYSIS"
+                        },
+                        "cartocss": '#polygons { polygon-fill: red; }',
+                        "cartocss_version": "2.3.0"
+                    }
+                }
+            ]
+        );
+
+        var testClient = new TestClient(mapConfig, 1234);
+
+        testClient.getLayergroup(ERROR_RESPONSE, function(err, layergroupResult) {
+            assert.ok(!err, err);
+
+            assert.equal(layergroupResult.errors.length, 1);
+            assert.equal(
+                layergroupResult.errors[0],
+                'Missing analysis node.id="ID-FOR-NONEXISTENT-ANALYSIS" for layer=1'
+            );
+
+            testClient.drain(done);
+        });
+    });
+
+    it('should handle missing analyses when dataviews point to nonexistent one', function(done) {
+        var mapConfig = createMapConfig(
+            [
+                {
+                    "type": "http",
+                    "options": {
+                        "urlTemplate": "http://{s}.basemaps.cartocdn.com/light_only_labels/{z}/{x}/{y}.png",
+                        "subdomains": "abcd"
+                    }
+                },
+                {
+                    "type": "cartodb",
+                    "options": {
+                        "sql": "select * from populated_places_simple_reduced",
+                        "cartocss": '#polygons { polygon-fill: red; }',
+                        "cartocss_version": "2.3.0"
+                    }
+                }
+            ],
+            {
+                pop_max_histogram: {
+                    source: {
+                        id: 'ID-FOR-NONEXISTENT-ANALYSIS'
+                    },
+                    type: 'histogram',
+                    options: {
+                        column: 'pop_max'
+                    }
+                }
+            }
+        );
+
+        var testClient = new TestClient(mapConfig, 1234);
+
+        testClient.getLayergroup(ERROR_RESPONSE, function(err, layergroupResult) {
+            assert.ok(!err, err);
+
+            assert.equal(layergroupResult.errors.length, 1);
+            assert.equal(layergroupResult.errors[0], 'Node with `source.id="ID-FOR-NONEXISTENT-ANALYSIS"`' +
+                ' not found in analyses for dataview "pop_max_histogram"');
+
+            testClient.drain(done);
+        });
+    });
+
+    it('camshaft: should return error missing analysis nodes for layers with some context', function(done) {
+        var mapConfig = createMapConfig(
+            [
+                {
+                    "type": "cartodb",
+                    "options": {
+                        "source": {
+                            "id": "HEAD"
+                        },
+                        "cartocss": '#polygons { polygon-fill: red; }',
+                        "cartocss_version": "2.3.0"
+                    }
+                }
+            ],
+            {},
+            [
+                {
+                    "id": "HEAD",
+                    "type": "buffer",
+                    "params": {
+                        "source": {
+                            "id": "HEAD",
+                            "type": "source",
+                            "params": {
+                                "query": "select * from populated_places_simple_reduced"
+                            }
+                        },
+                        "radius": 50000
+                    }
+                }
+            ]
+        );
+
+        var testClient = new TestClient(mapConfig, 11111);
+
+        testClient.getLayergroup(AUTH_ERROR_RESPONSE, function(err, layergroupResult) {
+            assert.ok(!err, err);
+
+            assert.equal(layergroupResult.errors.length, 1);
+            assert.equal(
+                layergroupResult.errors[0],
+                'Analysis requires authentication with API key: permission denied.'
+            );
+
+            assert.equal(layergroupResult.errors_with_context[0].type, 'analysis');
+            assert.equal(
+                layergroupResult.errors_with_context[0].message,
+                'Analysis requires authentication with API key: permission denied.'
+            );
+            assert.equal(layergroupResult.errors_with_context[0].context.layer.index, 0);
+            assert.equal(layergroupResult.errors_with_context[0].context.layer.id, 'HEAD');
+            assert.equal(layergroupResult.errors_with_context[0].context.layer.type, 'buffer');
+
+            testClient.drain(done);
+        });
+    });
+
+
+    it('camshaft: should return error: Missing required param "radius"; with context', function(done) {
+        var mapConfig = createMapConfig(
+            [
+                {
+                    "type": "cartodb",
+                    "options": {
+                        "source": {
+                            "id": "HEAD"
+                        },
+                        "cartocss": '#polygons { polygon-fill: red; }',
+                        "cartocss_version": "2.3.0"
+                    }
+                }
+            ],
+            {},
+            [
+                {
+                    "id": "HEAD",
+                    "type": "buffer",
+                    "params": {
+                        "source": {
+                            "id": "HEAD",
+                            "type": "source",
+                            "params": {
+                                "query": "select * from populated_places_simple_reduced"
+                            }
+                        }
+                    }
+                }
+            ]
+        );
+
+        var testClient = new TestClient(mapConfig, 1234);
+
+        testClient.getLayergroup(ERROR_RESPONSE, function(err, layergroupResult) {
+            assert.ok(!err, err);
+
+            assert.equal(layergroupResult.errors.length, 1);
+            assert.equal(
+                layergroupResult.errors[0],
+                'Missing required param "radius"'
+            );
+
+            assert.equal(layergroupResult.errors_with_context[0].type, 'analysis');
+            assert.equal(layergroupResult.errors_with_context[0].message, 'Missing required param "radius"');
+            assert.equal(layergroupResult.errors_with_context[0].context.layer.index, 0);
+            assert.equal(layergroupResult.errors_with_context[0].context.layer.id, 'HEAD');
+            assert.equal(layergroupResult.errors_with_context[0].context.layer.type, 'buffer');
+
+            testClient.drain(done);
+        });
+    });
+
+
 });

test/acceptance/analysis/named-maps.js

@@ -7,7 +7,7 @@ var serverOptions = require('../../../lib/cartodb/server_options');
 var server = new CartodbWindshaft(serverOptions);
 var TestClient = require('../../support/test-client');
 
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 
 describe('named-maps analysis', function() {
 

test/acceptance/dataviews/aggregation.js

@@ -0,0 +1,59 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var TestClient = require('../../support/test-client');
+
+describe('aggregations', function() {
+
+    afterEach(function(done) {
+        if (this.testClient) {
+            this.testClient.drain(done);
+        } else {
+            done();
+        }
+    });
+
+    function aggregationOperationMapConfig(operation) {
+        return {
+            version: '1.5.0',
+            layers: [
+                {
+                    type: 'mapnik',
+                    options: {
+                        sql: 'select * from populated_places_simple_reduced',
+                        cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                        cartocss_version: '2.0.1',
+                        widgets: {
+                            adm0name: {
+                                type: 'aggregation',
+                                options: {
+                                    column: 'adm0name',
+                                    aggregation: operation,
+                                    aggregationColumn: 'pop_max'
+                                }
+                            }
+                        }
+                    }
+                }
+            ]
+        };
+    }
+
+    var operations = ['count', 'sum', 'avg', 'max', 'min'];
+
+    operations.forEach(function(operation) {
+        it('should be able to use "' + operation + '" as aggregation operation', function(done) {
+
+            this.testClient = new TestClient(aggregationOperationMapConfig(operation));
+            this.testClient.getDataview('adm0name', { own_filter: 0 }, function (err, aggregation) {
+                assert.ok(!err, err);
+                assert.ok(aggregation);
+
+                assert.equal(aggregation.type, 'aggregation');
+                assert.equal(aggregation.aggregation, operation);
+
+                done();
+            });
+        });
+    });
+});

test/acceptance/dataviews/error-cases.js

@@ -0,0 +1,87 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var TestClient = require('../../support/test-client');
+
+describe('histogram-dataview', function() {
+
+    afterEach(function(done) {
+        if (this.testClient) {
+            this.testClient.drain(done);
+        } else {
+            done();
+        }
+    });
+
+    var ERROR_RESPONSE = {
+        status: 400,
+        headers: {
+            'Content-Type': 'application/json; charset=utf-8'
+        }
+    };
+
+    function createMapConfig(dataviews) {
+        return {
+            version: '1.5.0',
+            layers: [
+                {
+                    "type": "cartodb",
+                    "options": {
+                        "source": {
+                            "id": "HEAD"
+                        },
+                        "cartocss": "#points { marker-width: 10; marker-fill: red; }",
+                        "cartocss_version": "2.3.0"
+                    }
+                }
+            ],
+            dataviews: dataviews,
+            analyses: [
+                {
+                    "id": "HEAD",
+                    "type": "source",
+                    "params": {
+                        "query": "select null::geometry the_geom_webmercator, x from generate_series(0,1000) x"
+                    }
+                }
+            ]
+        };
+    }
+
+    it('should fail when invalid dataviews object is provided, string case', function(done) {
+        var mapConfig = createMapConfig("wadus-string");
+        this.testClient = new TestClient(mapConfig, 1234);
+        this.testClient.getLayergroup(ERROR_RESPONSE, function(err, errObj) {
+            assert.ok(!err, err);
+
+            assert.deepEqual(errObj.errors, [ '"dataviews" must be a valid JSON object: "string" type found' ]);
+
+            done();
+        });
+    });
+
+    it('should fail when invalid dataviews object is provided, array case', function(done) {
+        var mapConfig = createMapConfig([]);
+        this.testClient = new TestClient(mapConfig, 1234);
+        this.testClient.getLayergroup(ERROR_RESPONSE, function(err, errObj) {
+            assert.ok(!err, err);
+
+            assert.deepEqual(errObj.errors, [ '"dataviews" must be a valid JSON object: "array" type found' ]);
+
+            done();
+        });
+    });
+
+    it('should work with empty but valid objects', function(done) {
+        var mapConfig = createMapConfig({});
+        this.testClient = new TestClient(mapConfig, 1234);
+        this.testClient.getLayergroup(function(err, layergroup) {
+            assert.ok(!err, err);
+
+            assert.ok(layergroup);
+            assert.ok(layergroup.layergroupid);
+
+            done();
+        });
+    });
+});

test/acceptance/dataviews/histogram.js

@@ -0,0 +1,80 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var TestClient = require('../../support/test-client');
+
+describe('histogram-dataview', function() {
+
+    afterEach(function(done) {
+        if (this.testClient) {
+            this.testClient.drain(done);
+        } else {
+            done();
+        }
+    });
+
+    function createMapConfig(layers, dataviews, analysis) {
+        return {
+            version: '1.5.0',
+            layers: layers,
+            dataviews: dataviews || {},
+            analyses: analysis || []
+        };
+    }
+
+    var mapConfig = createMapConfig(
+        [
+            {
+                "type": "cartodb",
+                "options": {
+                    "source": {
+                        "id": "2570e105-7b37-40d2-bdf4-1af889598745"
+                    },
+                    "cartocss": "#points { marker-width: 10; marker-fill: red; }",
+                    "cartocss_version": "2.3.0"
+                }
+            }
+        ],
+        {
+            pop_max_histogram: {
+                source: {
+                    id: '2570e105-7b37-40d2-bdf4-1af889598745'
+                },
+                type: 'histogram',
+                options: {
+                    column: 'x'
+                }
+            }
+        },
+        [
+            {
+                "id": "2570e105-7b37-40d2-bdf4-1af889598745",
+                "type": "source",
+                "params": {
+                    "query": "select null::geometry the_geom_webmercator, x from generate_series(0,1000) x"
+                }
+            }
+        ]
+    );
+
+    it('should get bin_width right when max > min in filter', function(done) {
+        var params = {
+            bins: 10,
+            start: 1e3,
+            end: 0
+        };
+
+        this.testClient = new TestClient(mapConfig, 1234);
+        this.testClient.getDataview('pop_max_histogram', params, function(err, dataview) {
+            assert.ok(!err, err);
+
+            assert.equal(dataview.type, 'histogram');
+            assert.ok(dataview.bin_width > 0, 'Unexpected bin width: ' + dataview.bin_width);
+            dataview.bins.forEach(function(bin) {
+                assert.ok(bin.min <= bin.max, 'bin min < bin max: ' + JSON.stringify(bin));
+            });
+
+            done();
+        });
+    });
+});

test/acceptance/dataviews/overviews.js

@@ -0,0 +1,358 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var TestClient = require('../../support/test-client');
+
+describe('dataviews using tables without overviews', function() {
+
+    var nonOverviewsMapConfig =  {
+        version: '1.5.0',
+        analyses: [
+            { id: 'data-source',
+                type: 'source',
+                params: {
+                  query: 'select * from populated_places_simple_reduced'
+                }
+            }
+        ],
+        dataviews:  {
+            country_places_count: {
+                type: 'formula',
+                source: {id: 'data-source'},
+                options: {
+                    column: 'adm0_a3',
+                    operation: 'count'
+                }
+            },
+            country_categories: {
+                type: 'aggregation',
+                source: {id: 'data-source'},
+                options: {
+                    column: 'adm0_a3',
+                    aggregation: 'count'
+                }
+            }
+        },
+        layers: [
+            {
+                type: 'mapnik',
+                options: {
+                    sql: 'select * from populated_places_simple_reduced',
+                    cartocss: '#layer { marker-fill: red; marker-width: 32; marker-allow-overlap: true; }',
+                    cartocss_version: '2.3.0',
+                    source: { id: 'data-source' }
+                }
+            }
+        ]
+    };
+
+    it("should expose a formula", function(done) {
+        var testClient = new TestClient(nonOverviewsMapConfig);
+        testClient.getDataview('country_places_count', { own_filter: 0 }, function(err, formula_result) {
+            if (err) {
+                return done(err);
+            }
+            assert.deepEqual(formula_result, { operation: 'count', result: 7313, nulls: 0, type: 'formula' });
+
+            testClient.drain(done);
+        });
+    });
+
+    it("should admit a bbox", function(done) {
+        var params = {
+            bbox: "-170,-80,170,80"
+        };
+        var testClient = new TestClient(nonOverviewsMapConfig);
+        testClient.getDataview('country_places_count', params, function(err, formula_result) {
+            if (err) {
+                return done(err);
+            }
+            assert.deepEqual(formula_result, { operation: 'count', result: 7253, nulls: 0, type: 'formula' });
+
+            testClient.drain(done);
+        });
+    });
+
+    describe('filters', function() {
+
+        describe('category', function () {
+
+            it("should expose a filtered formula", function (done) {
+                var params = {
+                    filters: {
+                        dataviews: {country_categories: {accept: ['CAN']}}
+                    }
+                };
+                var testClient = new TestClient(nonOverviewsMapConfig);
+                testClient.getDataview('country_places_count', params, function (err, formula_result) {
+                    if (err) {
+                        return done(err);
+                    }
+                    assert.deepEqual(formula_result, { operation: 'count', result: 256, nulls: 0, type: 'formula' });
+                    testClient.drain(done);
+                });
+            });
+
+            it("should expose a filtered formula and admit a bbox", function (done) {
+                var params = {
+                    filters: {
+                        dataviews: {country_categories: {accept: ['CAN']}}
+                    },
+                    bbox: "-170,-80,170,80"
+                };
+                var testClient = new TestClient(nonOverviewsMapConfig);
+                testClient.getDataview('country_places_count', params, function (err, formula_result) {
+                    if (err) {
+                        return done(err);
+                    }
+                    assert.deepEqual(formula_result, { operation: 'count', result: 254, nulls: 0, type: 'formula' });
+                    testClient.drain(done);
+                });
+            });
+        });
+
+    });
+});
+
+describe('dataviews using tables with overviews', function() {
+
+    var overviewsMapConfig =  {
+        version: '1.5.0',
+        analyses: [
+            { id: 'data-source',
+                type: 'source',
+                params: {
+                  query: 'select * from test_table_overviews'
+                }
+            }
+        ],
+        dataviews:  {
+            test_sum: {
+                type: 'formula',
+                source: {id: 'data-source'},
+                options: {
+                    column: 'value',
+                    operation: 'sum'
+                }
+            },
+            test_categories: {
+                type: 'aggregation',
+                source: {id: 'data-source'},
+                options: {
+                    column: 'name',
+                    aggregation: 'count',
+                    aggregationColumn: 'name',
+                }
+            },
+            test_avg: {
+                type: 'formula',
+                source: {id: 'data-source'},
+                options: {
+                    column: 'value',
+                    operation: 'avg'
+                }
+            },
+            test_count: {
+                type: 'formula',
+                source: {id: 'data-source'},
+                options: {
+                    column: 'value',
+                    operation: 'count'
+                }
+            },
+            test_min: {
+                type: 'formula',
+                source: {id: 'data-source'},
+                options: {
+                    column: 'value',
+                    operation: 'min'
+                }
+            },
+            test_max: {
+                type: 'formula',
+                source: {id: 'data-source'},
+                options: {
+                    column: 'value',
+                    operation: 'max'
+                }
+            }
+        },
+        layers: [
+            {
+                type: 'mapnik',
+                options: {
+                    sql: 'select * from test_table_overviews',
+                    cartocss: '#layer { marker-fill: red; marker-width: 32; marker-allow-overlap: true; }',
+                    cartocss_version: '2.3.0',
+                    source: { id: 'data-source' }
+                }
+            }
+        ]
+    };
+
+    it("should expose a sum formula", function(done) {
+        var testClient = new TestClient(overviewsMapConfig);
+        testClient.getDataview('test_sum', { own_filter: 0 }, function(err, formula_result) {
+            if (err) {
+                return done(err);
+            }
+            assert.deepEqual(formula_result, {"operation":"sum","result":15,"nulls":0,"type":"formula"});
+
+            testClient.drain(done);
+        });
+    });
+
+    it("should expose an avg formula", function(done) {
+        var testClient = new TestClient(overviewsMapConfig);
+        testClient.getDataview('test_avg', { own_filter: 0 }, function(err, formula_result) {
+            if (err) {
+                return done(err);
+            }
+            assert.deepEqual(formula_result, {"operation":"avg","result":3,"nulls":0,"type":"formula"});
+
+            testClient.drain(done);
+        });
+    });
+
+    it("should expose a count formula", function(done) {
+        var testClient = new TestClient(overviewsMapConfig);
+        testClient.getDataview('test_count', { own_filter: 0 }, function(err, formula_result) {
+            if (err) {
+                return done(err);
+            }
+            assert.deepEqual(formula_result, {"operation":"count","result":5,"nulls":0,"type":"formula"});
+
+            testClient.drain(done);
+        });
+    });
+
+    it("should expose a max formula", function(done) {
+        var testClient = new TestClient(overviewsMapConfig);
+        testClient.getDataview('test_max', { own_filter: 0 }, function(err, formula_result) {
+            if (err) {
+                return done(err);
+            }
+            assert.deepEqual(formula_result, {"operation":"max","result":5,"nulls":0,"type":"formula"});
+
+            testClient.drain(done);
+        });
+    });
+
+    it("should expose a min formula", function(done) {
+        var testClient = new TestClient(overviewsMapConfig);
+        testClient.getDataview('test_min', { own_filter: 0 }, function(err, formula_result) {
+            if (err) {
+                return done(err);
+            }
+            assert.deepEqual(formula_result, {"operation":"min","result":1,"nulls":0,"type":"formula"});
+
+            testClient.drain(done);
+        });
+    });
+
+    it("should admit a bbox", function(done) {
+        var params = {
+            bbox: "-170,-80,170,80"
+        };
+        var testClient = new TestClient(overviewsMapConfig);
+        testClient.getDataview('test_sum', params, function(err, formula_result) {
+            if (err) {
+                return done(err);
+            }
+            assert.deepEqual(formula_result, {"operation":"sum","result":15,"nulls":0,"type":"formula"});
+
+            testClient.drain(done);
+        });
+    });
+
+    describe('filters', function() {
+
+        describe('category', function () {
+
+            var params = {
+                filters: {
+                    dataviews: {test_categories: {accept: ['Hawai']}}
+                }
+            };
+
+            it("should expose a filtered sum formula", function (done) {
+                var testClient = new TestClient(overviewsMapConfig);
+                testClient.getDataview('test_sum', params, function (err, formula_result) {
+                    if (err) {
+                        return done(err);
+                    }
+                    assert.deepEqual(formula_result, {"operation":"sum","result":1,"nulls":0,"type":"formula"});
+                    testClient.drain(done);
+                });
+            });
+
+            it("should expose a filtered  avg formula", function(done) {
+                var testClient = new TestClient(overviewsMapConfig);
+                testClient.getDataview('test_avg', params, function(err, formula_result) {
+                    if (err) {
+                        return done(err);
+                    }
+                    assert.deepEqual(formula_result, {"operation":"avg","result":1,"nulls":0,"type":"formula"});
+
+                    testClient.drain(done);
+                });
+            });
+
+            it("should expose a filtered count formula", function(done) {
+                var testClient = new TestClient(overviewsMapConfig);
+                testClient.getDataview('test_count', params, function(err, formula_result) {
+                    if (err) {
+                        return done(err);
+                    }
+                    assert.deepEqual(formula_result, {"operation":"count","result":1,"nulls":0,"type":"formula"});
+
+                    testClient.drain(done);
+                });
+            });
+
+            it("should expose a filterd max formula", function(done) {
+                var testClient = new TestClient(overviewsMapConfig);
+                testClient.getDataview('test_max', params, function(err, formula_result) {
+                    if (err) {
+                        return done(err);
+                    }
+                    assert.deepEqual(formula_result, {"operation":"max","result":1,"nulls":0,"type":"formula"});
+
+                    testClient.drain(done);
+                });
+            });
+
+            it("should expose a filterd min formula", function(done) {
+                var testClient = new TestClient(overviewsMapConfig);
+                testClient.getDataview('test_min', params, function(err, formula_result) {
+                    if (err) {
+                        return done(err);
+                    }
+                    assert.deepEqual(formula_result, {"operation":"min","result":1,"nulls":0,"type":"formula"});
+
+                    testClient.drain(done);
+                });
+            });
+
+            it("should expose a filtered sum formula with bbox", function (done) {
+                var bboxparams = {
+                    filters: {
+                        dataviews: {test_categories: {accept: ['Hawai']}}
+                    },
+                    bbox: "-170,-80,170,80"
+                };
+                var testClient = new TestClient(overviewsMapConfig);
+                testClient.getDataview('test_sum', bboxparams, function (err, formula_result) {
+                    if (err) {
+                        return done(err);
+                    }
+                    assert.deepEqual(formula_result, {"operation":"sum","result":1,"nulls":0,"type":"formula"});
+                    testClient.drain(done);
+                });
+            });
+
+
+        });
+
+    });
+});

test/acceptance/dynamic-styling-named-maps.js

@@ -1,6 +1,6 @@
 var assert = require('../support/assert');
 var step = require('step');
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../support/layergroup-token');
 var testHelper = require(__dirname + '/../support/test_helper');
 var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
 var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');

test/acceptance/geojson-renderer.js

@@ -0,0 +1,343 @@
+require('../support/test_helper');
+
+var assert = require('../support/assert');
+var TestClient = require('../support/test-client');
+
+
+describe('use only needed columns', function() {
+
+    function getFeatureByCartodbId(features, cartodbId) {
+        for (var i = 0, len = features.length; i < len; i++) {
+            if (features[i].properties.cartodb_id === cartodbId) {
+                return features[i];
+            }
+        }
+        return {};
+    }
+
+    var options = { format: 'geojson', layer: 0 };
+
+    afterEach(function(done) {
+        if (this.testClient) {
+            this.testClient.drain(done);
+        } else {
+            done();
+        }
+    });
+
+    it('with aggregation widget, interactivity and cartocss columns', function(done) {
+        var widgetMapConfig = {
+            version: '1.5.0',
+            layers: [{
+                type: 'mapnik',
+                options: {
+                    sql: 'select * from populated_places_simple_reduced',
+                    cartocss: '#layer0 { marker-fill: red; marker-width: 10; [name="Madrid"] { marker-fill: green; } }',
+                    cartocss_version: '2.0.1',
+                    widgets: {
+                        adm0name: {
+                            type: 'aggregation',
+                            options: {
+                                column: 'adm0name',
+                                aggregation: 'sum',
+                                aggregationColumn: 'pop_max'
+                            }
+                        }
+                    },
+                    interactivity: "cartodb_id,pop_min"
+                }
+            }]
+        };
+
+        this.testClient = new TestClient(widgetMapConfig);
+        this.testClient.getTile(0, 0, 0, options, function (err, res, geojsonTile) {
+            assert.ok(!err, err);
+            assert.deepEqual(getFeatureByCartodbId(geojsonTile.features, 1109).properties, {
+                cartodb_id: 1109,
+                name: 'Mardin',
+                adm0name: 'Turkey',
+                pop_max: 71373,
+                pop_min: 57586
+            });
+            done();
+        });
+    });
+
+    it('should not duplicate columns', function(done) {
+        var widgetMapConfig = {
+            version: '1.5.0',
+            layers: [{
+                type: 'mapnik',
+                options: {
+                    sql: 'select * from populated_places_simple_reduced',
+                    cartocss: ['#layer0 {',
+                        'marker-fill: red;',
+                        'marker-width: 10;',
+                        '[name="Madrid"] { marker-fill: green; } ',
+                        '[pop_max>100000] { marker-fill: black; } ',
+                        '}'].join('\n'),
+                    cartocss_version: '2.3.0',
+                    widgets: {
+                        adm0name: {
+                            type: 'aggregation',
+                            options: {
+                                column: 'adm0name',
+                                aggregation: 'sum',
+                                aggregationColumn: 'pop_max'
+                            }
+                        }
+                    },
+                    interactivity: "cartodb_id,pop_max"
+                }
+            }]
+        };
+
+        this.testClient = new TestClient(widgetMapConfig);
+        this.testClient.getTile(0, 0, 0, options, function (err, res, geojsonTile) {
+            assert.ok(!err, err);
+            assert.deepEqual(getFeatureByCartodbId(geojsonTile.features, 1109).properties, {
+                cartodb_id: 1109,
+                name: 'Mardin',
+                adm0name: 'Turkey',
+                pop_max: 71373
+            });
+            done();
+        });
+    });
+
+    it('with formula widget, no interactivity and no cartocss columns', function(done) {
+        var formulaWidgetMapConfig = {
+            version: '1.5.0',
+            layers: [{
+                type: 'mapnik',
+                options: {
+                    sql: 'select * from populated_places_simple_reduced where pop_max > 0 and pop_max < 600000',
+                    cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                    cartocss_version: '2.0.1',
+                    interactivity: 'cartodb_id',
+                    widgets: {
+                        pop_max_f: {
+                            type: 'formula',
+                            options: {
+                                column: 'pop_max',
+                                operation: 'count'
+                            }
+                        }
+                    }
+                }
+            }]
+        };
+
+        this.testClient = new TestClient(formulaWidgetMapConfig);
+        this.testClient.getTile(0, 0, 0, options, function (err, res, geojsonTile) {
+            assert.ok(!err, err);
+            assert.deepEqual(getFeatureByCartodbId(geojsonTile.features, 1109).properties, {
+                cartodb_id: 1109,
+                pop_max: 71373
+            });
+            done();
+        });
+    });
+    it('with cartocss with multiple expressions', function(done) {
+        var formulaWidgetMapConfig = {
+            version: '1.5.0',
+            layers: [{
+                type: 'mapnik',
+                options: {
+                    sql: 'select * from populated_places_simple_reduced where pop_max > 0 and pop_max < 600000',
+                    cartocss: '#layer0 { marker-fill: red; marker-width: 10; }' +
+                        '#layer0 { marker-width: 14; [name="Madrid"] { marker-width: 20; } }' +
+                        '#layer0[pop_max>1000] { marker-width: 14; [name="Madrid"] { marker-width: 20; } }' +
+                        '#layer0[adm0name=~".*Turkey*"] { marker-width: 14; [name="Madrid"] { marker-width: 20; } }',
+                    cartocss_version: '2.0.1',
+                    interactivity: 'cartodb_id'
+                }
+            }]
+        };
+
+        this.testClient = new TestClient(formulaWidgetMapConfig);
+        this.testClient.getTile(0, 0, 0, options, function (err, res, geojsonTile) {
+            assert.ok(!err, err);
+            assert.deepEqual(getFeatureByCartodbId(geojsonTile.features, 1109).properties, {
+                cartodb_id: 1109,
+                pop_max:71373,
+                name:"Mardin",
+                adm0name:"Turkey"
+            });
+            done();
+        });
+    });
+
+    it('should work with mapnik substitution tokens', function(done) {
+        var cartocss = [
+            "#layer {",
+            "  line-width: 2;",
+            "  line-color: #3B3B58;",
+            "  line-opacity: 1;",
+            "  polygon-opacity: 0.7;",
+            "  polygon-fill: ramp([points_count], (#E5F5F9,#99D8C9,#2CA25F))",
+            "}"
+        ].join('\n');
+
+        var sql = [
+            'WITH hgrid AS (',
+            '  SELECT CDB_HexagonGrid(',
+            '    ST_Expand(!bbox!, greatest(!pixel_width!,!pixel_height!) * 100),',
+            '    greatest(!pixel_width!,!pixel_height!) * 100',
+            '  ) as cell',
+            ')',
+            'SELECT',
+            '  hgrid.cell as the_geom_webmercator,',
+            '  count(1) as points_count,',
+            '  count(1)/power(100 * CDB_XYZ_Resolution(CDB_ZoomFromScale(!scale_denominator!)), 2) as points_density,',
+            '  1 as cartodb_id',
+            'FROM hgrid, (SELECT * FROM populated_places_simple_reduced) i',
+            'where ST_Intersects(i.the_geom_webmercator, hgrid.cell)',
+            'GROUP BY hgrid.cell'
+        ].join('\n');
+
+        var mapConfig = {
+            "version": "1.4.0",
+            "layers": [
+                {
+                    "type": 'mapnik',
+                    "options": {
+                        "cartocss_version": '2.3.0',
+                        "sql": sql,
+                        "cartocss": cartocss
+                    }
+                }
+            ]
+        };
+
+        this.testClient = new TestClient(mapConfig);
+        this.testClient.getTile(0, 0, 0, { format: 'geojson', layer: 0 }, function(err, res, geojson) {
+            assert.ok(!err, err);
+
+            assert.ok(geojson);
+            assert.equal(geojson.features.length, 5);
+
+            done();
+        });
+    });
+
+    it('should skip empty and null columns for geojson tiles', function(done) {
+
+        var mapConfig = {
+            "analyses": [
+                {
+                    "id": "a0",
+                    "params": {
+                        "query": "SELECT * FROM test_table"
+                    },
+                    "type": "source"
+                }
+            ],
+            "dataviews": {
+                "4e7b0e07-6d21-4b83-9adb-6d7e17eea6ca": {
+                    "options": {
+                        "aggregationColumn": null,
+                        "column": "cartodb_id",
+                        "operation": "avg"
+                    },
+                    "source": {
+                        "id": "a0"
+                    },
+                    "type": "formula"
+                },
+                "74f590f8-625c-4e95-922f-34ad3e9919c0": {
+                    "options": {
+                        "aggregation": "sum",
+                        "aggregationColumn": "cartodb_id",
+                        "column": "name"
+                    },
+                    "source": {
+                        "id": "a0"
+                    },
+                    "type": "aggregation"
+                },
+                "98a75757-3006-400a-b028-fb613a6c0b69": {
+                    "options": {
+                        "aggregationColumn": null,
+                        "column": "cartodb_id",
+                        "operation": "sum"
+                    },
+                    "source": {
+                        "id": "a0"
+                    },
+                    "type": "formula"
+                },
+                "ebbc97b2-87d2-4895-9e1f-2f012df3679d": {
+                    "options": {
+                        "aggregationColumn": null,
+                        "bins": "12",
+                        "column": "cartodb_id"
+                    },
+                    "source": {
+                        "id": "a0"
+                    },
+                    "type": "histogram"
+                },
+                "ebc0653f-3581-469c-8b31-c969e440a865": {
+                    "options": {
+                        "aggregationColumn": null,
+                        "column": "cartodb_id",
+                        "operation": "avg"
+                    },
+                    "source": {
+                        "id": "a0"
+                    },
+                    "type": "formula"
+                }
+            },
+            "layers": [
+                {
+                    "options": {
+                        "subdomains": "abcd",
+                        "urlTemplate": "http://{s}.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}.png"
+                    },
+                    "type": "http"
+                },
+                {
+                    "options": {
+                        "attributes": {
+                            "columns": [
+                                "name",
+                                "address"
+                            ],
+                            "id": "cartodb_id"
+                        },
+                        "cartocss": "#layer { marker-width: 10; marker-fill: red; }",
+                        "cartocss_version": "2.3.0",
+                        "interactivity": "cartodb_id",
+                        "layer_name": "wadus",
+                        "source": {
+                            "id": "a0"
+                        }
+                    },
+                    "type": "cartodb"
+                },
+                {
+                    "options": {
+                        "subdomains": "abcd",
+                        "urlTemplate": "http://{s}.basemaps.cartocdn.com/light_only_labels/{z}/{x}/{y}.png"
+                    },
+                    "type": "http"
+                }
+            ]
+        };
+
+        this.testClient = new TestClient(mapConfig);
+        this.testClient.getTile(0, 0, 0, { format: 'geojson', layer: 0 }, function(err, res, geojson) {
+            assert.ok(!err, err);
+
+            assert.ok(geojson);
+            assert.equal(geojson.features.length, 5);
+
+            assert.deepEqual(Object.keys(geojson.features[0].properties), ['cartodb_id', 'name']);
+
+            done();
+        });
+    });
+
+});

test/acceptance/limits.js

@@ -7,7 +7,7 @@ var redis = require('redis');
 var CartodbWindshaft = require('../../lib/cartodb/server');
 var serverOptions = require('../../lib/cartodb/server_options');
 
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../support/layergroup-token');
 
 describe('render limits', function() {
 
@@ -106,7 +106,7 @@ describe('render limits', function() {
                     },
                     function(res) {
                         var parsed = JSON.parse(res.body);
-                        assert.deepEqual(parsed, { errors: [ 'Render timed out' ] });
+                        assert.deepEqual(parsed.errors, [ 'Render timed out' ]);
                         done();
                     }
                 );
@@ -171,7 +171,7 @@ describe('render limits', function() {
                             },
                             function(res) {
                                 var parsed = JSON.parse(res.body);
-                                assert.deepEqual(parsed, { errors: ['Render timed out'] });
+                                assert.deepEqual(parsed.errors, ['Render timed out']);
                                 done();
                             }
                         );

test/acceptance/multilayer.js

@@ -6,7 +6,7 @@ var strftime    = require('strftime');
 var redis_stats_db = 5;
 
 var helper = require(__dirname + '/../support/test_helper');
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../support/layergroup-token');
 
 var windshaft_fixtures = __dirname + '/../../node_modules/windshaft/test/fixtures';
 

test/acceptance/multilayer_server.js

@@ -4,7 +4,7 @@ var assert = require('../support/assert');
 
 var _ = require('underscore');
 
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../support/layergroup-token');
 
 var PgQueryRunner = require('../../lib/cartodb/backends/pg_query_runner');
 var QueryTables = require('cartodb-query-tables');
@@ -228,7 +228,7 @@ describe('tests from old api translated to multilayer', function() {
                 },
                 function(res) {
                     var parsed = JSON.parse(res.body);
-                    assert.deepEqual(parsed, { errors: [ 'Unexpected token W' ] });
+                    assert.deepEqual(parsed.errors, [ 'Unexpected token W' ]);
 
                     done();
                 }
@@ -334,9 +334,7 @@ describe('tests from old api translated to multilayer', function() {
                 assert.ok(!res.headers.hasOwnProperty('x-cache-channel'));
 
                 var parsed = JSON.parse(res.body);
-                assert.deepEqual(parsed, {
-                    errors: ["fake error message"]
-                });
+                assert.deepEqual(parsed.errors, ["fake error message"]);
 
                 done();
             }

test/acceptance/named_layers.js

@@ -5,7 +5,7 @@ var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
 var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
 var server = new CartodbWindshaft(serverOptions);
 
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../support/layergroup-token');
 
 var RedisPool = require('redis-mpool');
 var TemplateMaps = require('../../lib/cartodb/backends/template_maps.js');
@@ -181,7 +181,7 @@ describe('named_layers', function() {
                 }
 
                 var parsedBody = JSON.parse(response.body);
-                assert.deepEqual(parsedBody, { errors: ["Template 'nonexistent' of user 'localhost' not found"] });
+                assert.deepEqual(parsedBody.errors, ["Template 'nonexistent' of user 'localhost' not found"]);
 
                 return null;
             },
@@ -234,10 +234,7 @@ describe('named_layers', function() {
                 }
 
                 var parsedBody = JSON.parse(response.body);
-                assert.deepEqual(
-                    parsedBody,
-                    { errors: [ "Unauthorized 'auth_valid_template' template instantiation" ] }
-                );
+                assert.deepEqual(parsedBody.errors, [ "Unauthorized 'auth_valid_template' template instantiation" ]);
 
                 return null;
             },
@@ -347,7 +344,7 @@ describe('named_layers', function() {
                 }
 
                 var parsedBody = JSON.parse(response.body);
-                assert.deepEqual(parsedBody, { errors: [ 'Nested named layers are not allowed' ] });
+                assert.deepEqual(parsedBody.errors, ['Nested named layers are not allowed' ]);
 
                 return null;
             },

test/acceptance/named_maps_authentication.js

@@ -169,8 +169,8 @@ describe('named maps authentication', function() {
             getNamedTile(nonexistentName, 0, 0, 0, { status: 404 }, function(err, res) {
                 assert.ok(!err);
                 assert.deepEqual(
-                    JSON.parse(res.body),
-                    { errors: ["Template '" + nonexistentName + "' of user '" + username + "' not found"] }
+                    JSON.parse(res.body).errors,
+                    ["Template '" + nonexistentName + "' of user '" + username + "' not found"]
                 );
                 done();
             });
@@ -179,7 +179,7 @@ describe('named maps authentication', function() {
         it('should return 403 if not properly authorized', function(done) {
             getNamedTile(tokenAuthTemplateName, 0, 0, 0, { status: 403 }, function(err, res) {
                 assert.ok(!err);
-                assert.deepEqual(JSON.parse(res.body), { errors: ['Unauthorized template instantiation'] });
+                assert.deepEqual(JSON.parse(res.body).errors, ['Unauthorized template instantiation']);
                 done();
             });
         });
@@ -238,8 +238,8 @@ describe('named maps authentication', function() {
             getStaticMap(nonexistentName, { status: 404 }, function(err, res) {
                 assert.ok(!err);
                 assert.deepEqual(
-                    JSON.parse(res.body),
-                    { errors: ["Template '" + nonexistentName + "' of user '" + username + "' not found"] }
+                    JSON.parse(res.body).errors,
+                    ["Template '" + nonexistentName + "' of user '" + username + "' not found"]
                 );
                 done();
             });
@@ -248,7 +248,7 @@ describe('named maps authentication', function() {
         it('should return 403 if not properly authorized', function(done) {
             getStaticMap(tokenAuthTemplateName, { status: 403 }, function(err, res) {
                 assert.ok(!err);
-                assert.deepEqual(JSON.parse(res.body), { errors: ['Unauthorized template instantiation'] });
+                assert.deepEqual(JSON.parse(res.body).errors, ['Unauthorized template instantiation']);
                 done();
             });
         });

test/acceptance/named_maps_cache.js

@@ -124,8 +124,8 @@ describe('named maps provider cache', function() {
                         getNamedTile({ statusCode: 404 }, function(err, res) {
                             assert.ok(!err);
                             assert.deepEqual(
-                                JSON.parse(res.body),
-                                { errors: ["Template 'template_with_color' of user 'localhost' not found"] }
+                                JSON.parse(res.body).errors,
+                                ["Template 'template_with_color' of user 'localhost' not found"]
                             );
 
                             // add template again so it's clean in afterEach

test/acceptance/overviews_metadata.js

@@ -5,7 +5,7 @@ var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
 var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
 var server = new CartodbWindshaft(serverOptions);
 
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../support/layergroup-token');
 
 var RedisPool = require('redis-mpool');
 
@@ -109,3 +109,118 @@ describe('overviews metadata', function() {
         );
     });
 });
+
+describe('overviews metadata with filters', function() {
+    // configure redis pool instance to use in tests
+    var redisPool = new RedisPool(global.environment.redis);
+
+    var keysToDelete;
+
+    beforeEach(function() {
+        keysToDelete = {};
+    });
+
+    afterEach(function(done) {
+        test_helper.deleteRedisKeys(keysToDelete, done);
+    });
+
+    it("layers with overviews", function(done) {
+
+        var layergroup =  {
+            version: '1.5.0',
+            layers: [
+              {
+                  type: 'cartodb',
+                  options: {
+                      sql: 'SELECT * FROM test_table_overviews',
+                      source: { id: 'with_overviews' },
+                      cartocss: '#layer { marker-fill: black; }',
+                      cartocss_version: '2.3.0'
+                  }
+              }
+            ],
+            dataviews:  {
+                test_names: {
+                    type: 'aggregation',
+                    source: {id: 'with_overviews'},
+                    options: {
+                        column: 'name',
+                        aggregation: 'count'
+                    }
+                }
+            },
+            analyses: [
+                { id: 'with_overviews',
+                    type: 'source',
+                    params: {
+                      query: 'select * from test_table_overviews'
+                    }
+                }
+            ]
+        };
+
+        var filters = {
+            dataviews: {
+                test_names: { accept: ['Hawai'] }
+            }
+        };
+
+        var layergroup_url = '/api/v1/map';
+
+        var expected_token;
+        step(
+            function do_post()
+            {
+              var next = this;
+              assert.response(server, {
+                  url: layergroup_url + '?filters=' + JSON.stringify(filters),
+                  method: 'POST',
+                  headers: {host: 'localhost', 'Content-Type': 'application/json' },
+                  data: JSON.stringify(layergroup)
+              }, {}, function(res) {
+                  assert.equal(res.statusCode, 200, res.body);
+                  var parsedBody = JSON.parse(res.body);
+                  assert.equal(res.headers['x-layergroup-id'], parsedBody.layergroupid);
+                  expected_token = parsedBody.layergroupid;
+                  next(null, res);
+              });
+            },
+            function do_get_mapconfig(err)
+            {
+                assert.ifError(err);
+                var next = this;
+
+                var mapStore  = new windshaft.storage.MapStore({
+                    pool: redisPool,
+                    expire_time: 500000
+                });
+                mapStore.load(LayergroupToken.parse(expected_token).token, function(err, mapConfig) {
+                    assert.ifError(err);
+                    assert.equal(mapConfig._cfg.layers[0].type, 'cartodb');
+                    assert.ok(mapConfig._cfg.layers[0].options.query_rewrite_data);
+                    var expected_data = {
+                        overviews: {
+                            test_table_overviews: {
+                                schema: 'public',
+                                1: { table: '_vovw_1_test_table_overviews' },
+                                2: { table: '_vovw_2_test_table_overviews' }
+                            }
+                        },
+                        filters: { test_names: { type: 'category', column: 'name', params: { accept: [ 'Hawai' ] } } },
+                        unfiltered_query: 'select * from test_table_overviews',
+                        filter_stats: { unfiltered_rows: 5, filtered_rows: 1 }
+                      };
+                    assert.deepEqual(mapConfig._cfg.layers[0].options.query_rewrite_data, expected_data);
+
+                  });
+
+                  next(err);
+            },
+            function finish(err) {
+                keysToDelete['map_cfg|' + LayergroupToken.parse(expected_token).token] = 0;
+                keysToDelete['user:localhost:mapviews:global'] = 5;
+                done(err);
+            }
+        );
+    });
+});

test/acceptance/overviews_metadata_named_maps.js

@@ -5,7 +5,7 @@ var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
 var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
 var server = new CartodbWindshaft(serverOptions);
 
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../support/layergroup-token');
 
 var RedisPool = require('redis-mpool');
 

test/acceptance/ported/attributes.js

@@ -6,7 +6,7 @@ var cartodbServer = require('../../../lib/cartodb/server');
 var PortedServerOptions = require('./support/ported_server_options');
 var BaseController = require('../../../lib/cartodb/controllers/base');
 
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 
 
 describe('attributes', function() {
@@ -231,7 +231,11 @@ describe('attributes', function() {
                 assert.equal(res.statusCode, 200, res.statusCode + ': ' + res.body);
                 assert.equal(
                     res.body,
-                    '/**/ typeof test === \'function\' && test({"errors":["Layer 0 has no exposed attributes"]});'
+                    '/**/ typeof test === \'function\' && ' +
+                    'test({"errors":["Layer 0 has no exposed attributes"],' +
+                    '"errors_with_context":[{' +
+                    '"type":"unknown","message":"Layer 0 has no exposed attributes","context":"unknown"' +
+                    '}]});'
                 );
                 return null;
             },

test/acceptance/ported/blend_http_fallback.js

@@ -138,11 +138,9 @@ describe('blend http fallback', function() {
         testClient.getTileLayer(mapConfig, tileRequest, expectedResponse, function(err, res) {
             assert.ok(!err);
             var parsedBody = JSON.parse(res.body);
-            assert.deepEqual(parsedBody, {
-                errors: [
-                    "Unable to fetch http tile: http://127.0.0.1:8033/error404/1/0/0.png [404]"
-                ]
-            });
+            assert.deepEqual(parsedBody.errors, [
+                "Unable to fetch http tile: http://127.0.0.1:8033/error404/1/0/0.png [404]"
+            ]);
             done();
         });
     });

test/acceptance/ported/external_resources.js

@@ -119,12 +119,11 @@ describe('external resources', function() {
         var mapConfig = testClient.defaultTableMapConfig('test_table_3', style);
 
         testClient.createLayergroup(mapConfig, { statusCode: 400 }, function(err, res) {
-            assert.deepEqual(JSON.parse(res.body), {
-                errors: ["Unable to download '" + url + "' for 'style0' (server returned 404)"]
-            });
+            assert.deepEqual(JSON.parse(res.body).errors, [
+                "Unable to download '" + url + "' for 'style0' (server returned 404)"]
+            );
             done();
         });
     });
 
 });
-

test/acceptance/ported/multilayer.js

@@ -7,7 +7,7 @@ var step = require('step');
 var mapnik = require('windshaft').mapnik;
 var cartodbServer = require('../../../lib/cartodb/server');
 var ServerOptions = require('./support/ported_server_options');
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 var BaseController = require('../../../lib/cartodb/controllers/base');
 
 describe('multilayer', function() {

test/acceptance/ported/multilayer_error_cases.js

@@ -31,7 +31,7 @@ describe('multilayer error cases', function() {
         }, {}, function(res) {
             assert.equal(res.statusCode, 400, res.body);
             var parsedBody = JSON.parse(res.body);
-            assert.deepEqual(parsedBody, {"errors":["layergroup POST data must be of type application/json"]});
+            assert.deepEqual(parsedBody.errors, ["layergroup POST data must be of type application/json"]);
             done();
         });
     });
@@ -44,7 +44,7 @@ describe('multilayer error cases', function() {
         }, {}, function(res) {
             assert.equal(res.statusCode, 400, res.body);
             var parsedBody = JSON.parse(res.body);
-            assert.deepEqual(parsedBody, {"errors":["Missing layers array from layergroup config"]});
+            assert.deepEqual(parsedBody.errors, ["Missing layers array from layergroup config"]);
             done();
         });
     });
@@ -58,7 +58,10 @@ describe('multilayer error cases', function() {
             assert.equal(res.statusCode, 200);
             assert.equal(
                 res.body,
-                '/**/ typeof test === \'function\' && test({"errors":["Missing layers array from layergroup config"]});'
+                '/**/ typeof test === \'function\' && ' +
+                'test({"errors":["Missing layers array from layergroup config"],' +
+                '"errors_with_context":[{"type":"unknown",' +
+                '"message":"Missing layers array from layergroup config","context":"unknown"}]});'
             );
             done();
         });
@@ -83,7 +86,7 @@ describe('multilayer error cases', function() {
       }, {}, function(res) {
           assert.equal(res.statusCode, 400, res.body);
           var parsedBody = JSON.parse(res.body);
-          assert.deepEqual(parsedBody, {errors:["Missing cartocss_version for layer 0 options"]});
+          assert.deepEqual(parsedBody.errors, ["Missing cartocss_version for layer 0 options"]);
           done();
       });
     });
@@ -355,7 +358,7 @@ describe('multilayer error cases', function() {
         var mapConfig = testClient.singleLayerMapConfig('select * from test_table', null, null, 'name');
 
         testClient.getGrid(mapConfig, 1, 13, 4011, 3088, defaultErrorExpectedResponse, function(err, res) {
-            assert.deepEqual(JSON.parse(res.body), { errors: ["Layer '1' not found in layergroup"] });
+            assert.deepEqual(JSON.parse(res.body).errors, ["Layer '1' not found in layergroup"]);
             done();
         });
     });
@@ -383,7 +386,7 @@ describe('multilayer error cases', function() {
           // FIXME: should be 404
           assert.equal(res.statusCode, 400, res.statusCode + ':' + res.body);
           var parsed = JSON.parse(res.body);
-          assert.deepEqual(parsed, {"errors": ["Invalid or nonexistent map configuration token 'deadbeef'"]});
+          assert.deepEqual(parsed.errors, ["Invalid or nonexistent map configuration token 'deadbeef'"]);
           return null;
         },
         function finish(err) {

test/acceptance/ported/multilayer_interactivity.js

@@ -5,7 +5,7 @@ var _             = require('underscore');
 var cartodbServer = require('../../../lib/cartodb/server');
 var getLayerTypeFn = require('windshaft').model.MapConfig.prototype.getType;
 var PortedServerOptions = require('./support/ported_server_options');
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 
 var BaseController = require('../../../lib/cartodb/controllers/base');
 

test/acceptance/ported/raster.js

@@ -6,7 +6,7 @@ var cartodbServer = require('../../../lib/cartodb/server');
 var ServerOptions = require('./support/ported_server_options');
 
 var BaseController = require('../../../lib/cartodb/controllers/base');
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 
 describe('raster', function() {
 
@@ -148,11 +148,10 @@ describe('raster', function() {
                 assert.ok(!err);
                 checkCORSHeaders(res);
                 var parsedBody = JSON.parse(res.body);
-                assert.deepEqual(parsedBody, { errors: [ 'Mapnik raster layers do not support interactivity' ] });
+                assert.deepEqual(parsedBody.errors, [ 'Mapnik raster layers do not support interactivity' ]);
                 done();
             }
         );
     });
 
 });
-

test/acceptance/ported/regressions.js

@@ -29,7 +29,7 @@ describe('regressions', function() {
                 contentType: 'application/json; charset=utf-8'
             };
             requestTile('/0/0/0.png?testUnexpectedError=1', options, function(err, res) {
-                assert.deepEqual(JSON.parse(res.body), { "errors": ["test unexpected error"] });
+                assert.deepEqual(JSON.parse(res.body).errors, ["test unexpected error"]);
                 finish(done);
             });
         });

test/acceptance/ported/retina.js

@@ -6,7 +6,7 @@ var cartodbServer = require('../../../lib/cartodb/server');
 var ServerOptions = require('./support/ported_server_options');
 
 var BaseController = require('../../../lib/cartodb/controllers/base');
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 
 describe('retina support', function() {
 
@@ -129,7 +129,7 @@ describe('retina support', function() {
             },
             function(res, err) {
                 assert.ok(!err, 'Failed to request 0/0/0' + scaleFactor + '.png tile');
-                assert.deepEqual(JSON.parse(res.body), { errors: ["Tile with specified resolution not found"] } );
+                assert.deepEqual(JSON.parse(res.body).errors, ["Tile with specified resolution not found"]);
 
                 done();
             }

test/acceptance/ported/server.js

@@ -112,7 +112,7 @@ describe('server', function() {
             }
         };
         testClient.getGrid(mapConfig, 0, 13, 4011, 3088, expectedResponse, function(err, res) {
-            assert.deepEqual(JSON.parse(res.body), {"errors":["Tileset has no interactivity"]});
+            assert.deepEqual(JSON.parse(res.body).errors, ["Tileset has no interactivity"]);
             done();
         });
     });

test/acceptance/ported/server_png8_format.js

@@ -7,7 +7,7 @@ var cartodbServer = require('../../../lib/cartodb/server');
 var ServerOptions = require('./support/ported_server_options');
 
 var BaseController = require('../../../lib/cartodb/controllers/base');
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 
 var IMAGE_EQUALS_TOLERANCE_PER_MIL = 85;
 

test/acceptance/ported/support/ported_server_options.js

@@ -1,6 +1,6 @@
 var _ = require('underscore');
 var serverOptions = require('../../../../lib/cartodb/server_options');
-var LayergroupToken = require('../../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../../support/layergroup-token');
 var mapnik = require('windshaft').mapnik;
 var OverviewsQueryRewriter = require('../../../../lib/cartodb/utils/overviews_query_rewriter');
 var overviewsQueryRewriter = new OverviewsQueryRewriter({

test/acceptance/ported/support/test_client.js

@@ -1,5 +1,5 @@
 var testHelper = require('../../../support/test_helper');
-var LayergroupToken = require('../../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../../support/layergroup-token');
 
 var step = require('step');
 var assert = require('../../../support/assert');

test/acceptance/ported/torque.js

@@ -7,7 +7,7 @@ var cartodbServer = require('../../../lib/cartodb/server');
 var ServerOptions = require('./support/ported_server_options');
 
 var BaseController = require('../../../lib/cartodb/controllers/base');
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 
 describe('torque', function() {
 

test/acceptance/ported/torque_boundaries.js

@@ -5,7 +5,7 @@ var cartodbServer = require('../../../lib/cartodb/server');
 var ServerOptions = require('./support/ported_server_options');
 
 var BaseController = require('../../../lib/cartodb/controllers/base');
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 
 describe('torque boundary points', function() {
 

test/acceptance/sql-wrap.js

@@ -0,0 +1,52 @@
+require('../support/test_helper');
+
+var assert = require('../support/assert');
+var TestClient = require('../support/test-client');
+
+describe('sql-wrap', function() {
+
+    afterEach(function(done) {
+        if (this.testClient) {
+            this.testClient.drain(done);
+        } else {
+            return done();
+        }
+    });
+
+    it('should use sql_wrap from layer options', function(done) {
+        var mapConfig = {
+            version: '1.5.0',
+            layers: [
+                {
+                    "type": "cartodb",
+                    "options": {
+                        "sql": "SELECT * FROM populated_places_simple_reduced",
+                        "sql_wrap": "SELECT * FROM (<%= sql %>) _w WHERE adm0_a3 = 'USA'",
+                        "cartocss": [
+                            "#points {",
+                            "  marker-fill-opacity: 1;",
+                            "  marker-line-color: #FFF;",
+                            "  marker-line-width: 0.5;",
+                            "  marker-line-opacity: 1;",
+                            "  marker-placement: point;",
+                            "  marker-type: ellipse;",
+                            "  marker-width: 8;",
+                            "  marker-fill: red;",
+                            "  marker-allow-overlap: true;",
+                            "}"
+                        ].join('\n'),
+                        "cartocss_version": "2.3.0"
+                    }
+                }
+            ]
+        };
+
+        this.testClient = new TestClient(mapConfig, 1234);
+        this.testClient.getTile(0, 0, 0, function(err, tile, img) {
+            assert.ok(!err, err);
+            var fixtureImg = './test/fixtures/sql-wrap-usa-filter.png';
+            assert.imageIsSimilarToFile(img, fixtureImg, 20, done);
+        });
+    });
+
+});

test/acceptance/templates.js

@@ -23,7 +23,7 @@ var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
 var server = new CartodbWindshaft(serverOptions);
 server.setMaxListeners(0);
 
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../support/layergroup-token');
 
 describe('template_api', function() {
     server.layergroupAffectedTablesCache.cache.reset();
@@ -1927,9 +1927,8 @@ describe('template_api', function() {
                 if (err) {
                     return done(err);
                 }
-                assert.deepEqual(JSON.parse(res.body), {
-                    errors: ["Invalid or nonexistent map configuration token '" + nonexistentToken + "'"]
-                });
+                assert.deepEqual(JSON.parse(res.body).errors,
+                    ["Invalid or nonexistent map configuration token '" + nonexistentToken + "'"]);
 
                 done();
             };

test/acceptance/turbo-cartocss/anonymous-maps.js

@@ -53,6 +53,20 @@ describe('turbo-carto for anonymous maps', function() {
             var fixturePath = 'test_turbo_carto_greens_13_4011_3088.png';
             this.testClient.getTile(13, 4011, 3088, imageCompareFn(fixturePath, done));
         });
+
+        it('should work for different char case in quantification names', function(done) {
+            this.testClient = new TestClient(
+                makeMapconfig('#layer { marker-fill: ramp([price], colorbrewer(Greens, 3), jeNkS); }')
+            );
+            this.testClient.getLayergroup(function(err, layergroup) {
+                assert.ok(!err, err);
+
+                assert.ok(layergroup.hasOwnProperty('layergroupid'));
+                assert.ok(!layergroup.hasOwnProperty('errors'));
+
+                done();
+            });
+        });
     });
 
     describe('parsing ramp function with colorbrewer for reds and mapnik renderer', function () {

test/acceptance/turbo-cartocss/error-cases.js

@@ -78,6 +78,21 @@ describe('turbo-carto error cases', function() {
         });
     });
 
+    it('should return invalid method from datasource', function(done) {
+        this.testClient = new TestClient(makeMapconfig(null, 'ramp([wadus_column], (red, green, blue), wadusmethod)'));
+        this.testClient.getLayergroup(ERROR_RESPONSE, function(err, layergroup) {
+            assert.ok(!err, err);
+
+            assert.ok(layergroup.hasOwnProperty('errors'));
+            assert.equal(layergroup.errors.length, 1);
+            assert.ok(layergroup.errors[0].match(/^turbo-carto/));
+            assert.ok(layergroup.errors[0].match(/unable\sto\scompute\sramp/i));
+            assert.ok(layergroup.errors[0].match(/invalid\smethod\s\"wadusmethod\"/i));
+
+            done();
+        });
+    });
+
     it('should fail by falling back to normal carto parser', function(done) {
         this.testClient = new TestClient(makeMapconfig('ramp([price], (8,24,96), (8,24,96));//(red, green, blue))'));
         this.testClient.getLayergroup(ERROR_RESPONSE, function(err, layergroup) {
@@ -91,4 +106,34 @@ describe('turbo-carto error cases', function() {
             done();
         });
     });
+
+    it('turbo-carto: should return error invalid column from datasource with some context', function(done) {
+        this.testClient = new TestClient(makeMapconfig(null, 'ramp([wadus_column], (red, green, blue))'));
+        this.testClient.getLayergroup(ERROR_RESPONSE, function(err, layergroup) {
+            assert.ok(!err, err);
+
+            assert.ok(layergroup.hasOwnProperty('errors'));
+            assert.equal(layergroup.errors_with_context.length, 1);
+            assert.equal(layergroup.errors_with_context[0].type, 'turbo-carto');
+            assert.ok(layergroup.errors_with_context[0].message.match(/^turbo-carto/));
+            assert.ok(layergroup.errors_with_context[0].message.match(/unable\sto\scompute\sramp/i));
+            assert.ok(layergroup.errors_with_context[0].message.match(/wadus_column/));
+
+            assert.equal(layergroup.errors_with_context[0].context.layer.index, 0);
+            assert.equal(layergroup.errors_with_context[0].context.layer.type, 'mapnik');
+
+            assert.equal(layergroup.errors_with_context[0].context.selector, '#populated_places_simple_reduced');
+            assert.deepEqual(layergroup.errors_with_context[0].context.source, {
+                start: {
+                    line: 10,
+                    column: 3
+                },
+                end: {
+                    line: 10,
+                    column: 56
+                }
+            });
+            done();
+        });
+    });
 });

test/acceptance/turbo-cartocss/named-maps.js

@@ -1,6 +1,6 @@
 var assert = require('../../support/assert');
 var step = require('step');
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 var testHelper = require('../../support/test_helper');
 var CartodbWindshaft = require('../../../lib/cartodb/server');
 var serverOptions = require('../../../lib/cartodb/server_options');
@@ -22,215 +22,231 @@ describe('turbo-carto for named maps', function() {
 
     var templateId = 'turbo-carto-template-1';
 
-    var template = {
-        version: '0.0.1',
-        name: templateId,
-        auth: { method: 'open' },
-        placeholders: {
-            color: {
-                type: "css_color",
-                default: "Reds"
-            }
-        },
-        layergroup:  {
-            version: '1.0.0',
-                layers: [{
-                    options: {
-                        sql: [
-                            'SELECT test_table.*, _prices.price FROM test_table JOIN (' +
-                            '  SELECT 1 AS cartodb_id, 10.00 AS price',
-                            '  UNION',
-                            '  SELECT 2, 10.50',
-                            '  UNION',
-                            '  SELECT 3, 11.00',
-                            '  UNION',
-                            '  SELECT 4, 12.00',
-                            '  UNION',
-                            '  SELECT 5, 21.00',
-                            ') _prices ON _prices.cartodb_id = test_table.cartodb_id'
-                        ].join('\n'),
-                        cartocss: [
-                            '#layer {',
-                            '  marker-fill: ramp([price], colorbrewer(<%= color %>));',
-                            '  marker-allow-overlap:true;',
-                            '}'
-                        ].join('\n'),
-                        cartocss_version: '2.0.2'
-                    }
+    function template(table) {
+        return {
+            version: '0.0.1',
+            name: templateId,
+            auth: { method: 'open' },
+            placeholders: {
+                color: {
+                    type: "css_color",
+                    default: "Reds"
                 }
-            ]
-        }
-    };
+            },
+            layergroup: {
+                version: '1.0.0',
+                layers: [
+                    {
+                        options: {
+                            sql: [
+                                'SELECT ' + table + '.*, _prices.price FROM ' + table + ' JOIN (' +
+                                '  SELECT 1 AS cartodb_id, 10.00 AS price',
+                                '  UNION',
+                                '  SELECT 2, 10.50',
+                                '  UNION',
+                                '  SELECT 3, 11.00',
+                                '  UNION',
+                                '  SELECT 4, 12.00',
+                                '  UNION',
+                                '  SELECT 5, 21.00',
+                                ') _prices ON _prices.cartodb_id = ' + table + '.cartodb_id'
+                            ].join('\n'),
+                            cartocss: [
+                                '#layer {',
+                                '  marker-fill: ramp([price], colorbrewer(<%= color %>));',
+                                '  marker-allow-overlap:true;',
+                                '}'
+                            ].join('\n'),
+                            cartocss_version: '2.0.2'
+                        }
+                    }
+                ]
+            }
+        };
+    }
 
     var templateParamsReds = { color: 'Reds' };
     var templateParamsBlues = { color: 'Blues' };
 
-    it('should create a template with turbo-carto parsed properly', function (done) {
-        step(
-            function postTemplate() {
-                var next = this;
+    var scenarios = [
+        {
+            desc: 'with public tables',
+            table: 'test_table'
+        },
+        {
+            desc: 'with private tables',
+            table: 'test_table_private_1'
+        }
+    ];
 
-                assert.response(server, {
-                    url: '/api/v1/map/named?api_key=1234',
-                    method: 'POST',
-                    headers: { host: 'localhost', 'Content-Type': 'application/json' },
-                    data: JSON.stringify(template)
-                }, {},
-                function (res, err) {
-                    next(err, res);
-                });
-            },
-            function checkTemplate(err, res) {
-                assert.ifError(err);
-                assert.equal(res.statusCode, 200);
-                assert.deepEqual(JSON.parse(res.body), {
-                    template_id: templateId
-                });
+    scenarios.forEach(function(scenario) {
+        it('should create a template with turbo-carto parsed properly: ' + scenario.desc, function (done) {
+            step(
+                function postTemplate() {
+                    var next = this;
 
-                return null;
-            },
-            function instantiateTemplateWithReds(err) {
-                assert.ifError(err);
+                    assert.response(server, {
+                        url: '/api/v1/map/named?api_key=1234',
+                        method: 'POST',
+                        headers: { host: 'localhost', 'Content-Type': 'application/json' },
+                        data: JSON.stringify(template(scenario.table))
+                    }, {},
+                    function (res, err) {
+                        next(err, res);
+                    });
+                },
+                function checkTemplate(err, res) {
+                    assert.ifError(err);
+                    assert.equal(res.statusCode, 200);
+                    assert.deepEqual(JSON.parse(res.body), {
+                        template_id: templateId
+                    });
 
-                var next = this;
-                assert.response(server, {
-                    url: '/api/v1/map/named/' + templateId,
-                    method: 'POST',
-                    headers: {
-                        host: 'localhost',
-                        'Content-Type': 'application/json'
-                    },
-                    data: JSON.stringify(templateParamsReds)
-                }, {},
-                function(res, err) {
-                    return next(err, res);
-                });
-            },
-            function checkInstanciationWithReds(err, res) {
-                assert.ifError(err);
+                    return null;
+                },
+                function instantiateTemplateWithReds(err) {
+                    assert.ifError(err);
 
-                assert.equal(res.statusCode, 200);
+                    var next = this;
+                    assert.response(server, {
+                        url: '/api/v1/map/named/' + templateId,
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(templateParamsReds)
+                    }, {},
+                    function(res, err) {
+                        return next(err, res);
+                    });
+                },
+                function checkInstanciationWithReds(err, res) {
+                    assert.ifError(err);
 
-                var parsedBody = JSON.parse(res.body);
+                    assert.equal(res.statusCode, 200);
 
-                keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
-                keysToDelete['user:localhost:mapviews:global'] = 5;
+                    var parsedBody = JSON.parse(res.body);
 
-                assert.ok(parsedBody.layergroupid);
-                assert.ok(parsedBody.last_updated);
+                    keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
+                    keysToDelete['user:localhost:mapviews:global'] = 5;
 
-                return parsedBody.layergroupid;
-            },
-            function requestTileReds(err, layergroupId) {
-                assert.ifError(err);
+                    assert.ok(parsedBody.layergroupid);
+                    assert.ok(parsedBody.last_updated);
 
-                var next = this;
+                    return parsedBody.layergroupid;
+                },
+                function requestTileReds(err, layergroupId) {
+                    assert.ifError(err);
 
-                assert.response(server, {
-                    url: '/api/v1/map/' + layergroupId + '/0/0/0.png',
-                    method: 'GET',
-                    headers: { host: 'localhost' },
-                    encoding: 'binary'
-                }, {},
-                function(res, err) {
-                    next(err, res);
-                });
-            },
-            function checkTileReds(err, res) {
-                assert.ifError(err);
+                    var next = this;
 
-                var next = this;
+                    assert.response(server, {
+                        url: '/api/v1/map/' + layergroupId + '/0/0/0.png',
+                        method: 'GET',
+                        headers: { host: 'localhost' },
+                        encoding: 'binary'
+                    }, {},
+                    function(res, err) {
+                        next(err, res);
+                    });
+                },
+                function checkTileReds(err, res) {
+                    assert.ifError(err);
 
-                assert.equal(res.statusCode, 200);
-                assert.equal(res.headers['content-type'], 'image/png');
+                    var next = this;
 
-                var fixturePath = './test/fixtures/turbo-carto-named-maps-reds.png';
-                var image = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
+                    assert.equal(res.statusCode, 200);
+                    assert.equal(res.headers['content-type'], 'image/png');
 
-                assert.imageIsSimilarToFile(image, fixturePath, IMAGE_TOLERANCE_PER_MIL, next);
-            },
-            function instantiateTemplateWithBlues(err) {
-                assert.ifError(err);
+                    var fixturePath = './test/fixtures/turbo-carto-named-maps-reds.png';
+                    var image = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
 
-                var next = this;
-                assert.response(server, {
-                    url: '/api/v1/map/named/' + templateId,
-                    method: 'POST',
-                    headers: {
-                        host: 'localhost',
-                        'Content-Type': 'application/json'
-                    },
-                    data: JSON.stringify(templateParamsBlues)
-                }, {},
-                function(res, err) {
-                    return next(err, res);
-                });
-            },
-            function checkInstanciationWithBlues(err, res) {
-                assert.ifError(err);
-                assert.equal(res.statusCode, 200);
+                    assert.imageIsSimilarToFile(image, fixturePath, IMAGE_TOLERANCE_PER_MIL, next);
+                },
+                function instantiateTemplateWithBlues(err) {
+                    assert.ifError(err);
 
-                var parsedBody = JSON.parse(res.body);
+                    var next = this;
+                    assert.response(server, {
+                        url: '/api/v1/map/named/' + templateId,
+                        method: 'POST',
+                        headers: {
+                            host: 'localhost',
+                            'Content-Type': 'application/json'
+                        },
+                        data: JSON.stringify(templateParamsBlues)
+                    }, {},
+                    function(res, err) {
+                        return next(err, res);
+                    });
+                },
+                function checkInstanciationWithBlues(err, res) {
+                    assert.ifError(err);
+                    assert.equal(res.statusCode, 200);
 
-                keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
-                keysToDelete['user:localhost:mapviews:global'] = 5;
+                    var parsedBody = JSON.parse(res.body);
 
-                assert.ok(parsedBody.layergroupid);
-                assert.ok(parsedBody.last_updated);
+                    keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
+                    keysToDelete['user:localhost:mapviews:global'] = 5;
 
-                return parsedBody.layergroupid;
-            },
-            function requestTileBlues(err, layergroupId) {
-                assert.ifError(err);
+                    assert.ok(parsedBody.layergroupid);
+                    assert.ok(parsedBody.last_updated);
 
-                var next = this;
+                    return parsedBody.layergroupid;
+                },
+                function requestTileBlues(err, layergroupId) {
+                    assert.ifError(err);
 
-                assert.response(server, {
-                    url: '/api/v1/map/' + layergroupId + '/0/0/0.png',
-                    method: 'GET',
-                    headers: { host: 'localhost' },
-                    encoding: 'binary'
-                }, {},
-                function(res, err) {
-                    next(err, res);
-                });
-            },
-            function checkTileBlues(err, res) {
-                assert.ifError(err);
+                    var next = this;
 
-                var next = this;
+                    assert.response(server, {
+                        url: '/api/v1/map/' + layergroupId + '/0/0/0.png',
+                        method: 'GET',
+                        headers: { host: 'localhost' },
+                        encoding: 'binary'
+                    }, {},
+                    function(res, err) {
+                        next(err, res);
+                    });
+                },
+                function checkTileBlues(err, res) {
+                    assert.ifError(err);
 
-                assert.equal(res.statusCode, 200);
-                assert.equal(res.headers['content-type'], 'image/png');
+                    var next = this;
 
-                var fixturePath = './test/fixtures/turbo-carto-named-maps-blues.png';
-                var image = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
+                    assert.equal(res.statusCode, 200);
+                    assert.equal(res.headers['content-type'], 'image/png');
 
-                assert.imageIsSimilarToFile(image, fixturePath, IMAGE_TOLERANCE_PER_MIL, next);
-            },
-            function deleteTemplate(err) {
-                assert.ifError(err);
+                    var fixturePath = './test/fixtures/turbo-carto-named-maps-blues.png';
+                    var image = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
 
-                var next = this;
+                    assert.imageIsSimilarToFile(image, fixturePath, IMAGE_TOLERANCE_PER_MIL, next);
+                },
+                function deleteTemplate(err) {
+                    assert.ifError(err);
 
-                assert.response(server, {
-                    url: '/api/v1/map/named/' + templateId + '?api_key=1234',
-                    method: 'DELETE',
-                    headers: { host: 'localhost' }
-                }, {}, function (res, err) {
-                    next(err, res);
-                });
-            },
-            function checkDeleteTemplate(err, res) {
-                assert.ifError(err);
-                assert.equal(res.statusCode, 204);
-                assert.ok(!res.body);
+                    var next = this;
 
-                return null;
-            },
-            function finish(err) {
-                done(err);
-            }
-        );
+                    assert.response(server, {
+                        url: '/api/v1/map/named/' + templateId + '?api_key=1234',
+                        method: 'DELETE',
+                        headers: { host: 'localhost' }
+                    }, {}, function (res, err) {
+                        next(err, res);
+                    });
+                },
+                function checkDeleteTemplate(err, res) {
+                    assert.ifError(err);
+                    assert.equal(res.statusCode, 204);
+                    assert.ok(!res.body);
+
+                    return null;
+                },
+                function finish(err) {
+                    done(err);
+                }
+            );
+        });
     });
 });

test/acceptance/turbo-cartocss/regressions.js

@@ -24,6 +24,8 @@ describe('turbo-carto regressions', function() {
     afterEach(function (done) {
         if (this.testClient) {
             this.testClient.drain(done);
+        } else {
+            done();
         }
     });
 
@@ -64,6 +66,57 @@ describe('turbo-carto regressions', function() {
         });
     });
 
+    it('should fail for private tables', function(done) {
+        var cartocss = [
+            "#private_table {",
+            "  marker-placement: point;",
+            "  marker-allow-overlap: true;",
+            "  marker-line-width: 0;",
+            "  marker-fill-opacity: 1.0;",
+            "  marker-width: ramp([cartodb_id], 10, 20);",
+            "  marker-fill: red;",
+            "}"
+        ].join('\n');
+
+        this.testClient = new TestClient(makeMapconfig('SELECT * FROM test_table_private_1', cartocss));
+        this.testClient.getLayergroup(TestClient.RESPONSE.ERROR, function(err, layergroup) {
+            assert.ok(!err, err);
+
+            assert.ok(!layergroup.hasOwnProperty('layergroupid'));
+            assert.ok(layergroup.hasOwnProperty('errors'));
+
+            var turboCartoError = layergroup.errors_with_context[0];
+            assert.ok(turboCartoError);
+            assert.equal(turboCartoError.type, 'turbo-carto');
+            assert.ok(turboCartoError.message.match(/permission\sdenied\sfor\srelation\stest_table_private_1/));
+
+            done();
+        });
+    });
+
+    it('should work for private tables with api key', function(done) {
+        var cartocss = [
+            "#private_table {",
+            "  marker-placement: point;",
+            "  marker-allow-overlap: true;",
+            "  marker-line-width: 0;",
+            "  marker-fill-opacity: 1.0;",
+            "  marker-width: ramp([cartodb_id], 10, 20);",
+            "  marker-fill: red;",
+            "}"
+        ].join('\n');
+
+        this.testClient = new TestClient(makeMapconfig('SELECT * FROM test_table_private_1', cartocss), 1234);
+        this.testClient.getLayergroup(function(err, layergroup) {
+            assert.ok(!err, err);
+
+            assert.ok(layergroup.hasOwnProperty('layergroupid'));
+            assert.ok(!layergroup.hasOwnProperty('errors'));
+
+            done();
+        });
+    });
+
     it('should work with mapnik substitution tokens', function(done) {
         var cartocss = [
             "#layer {",
@@ -102,4 +155,148 @@ describe('turbo-carto regressions', function() {
             done();
         });
     });
+
+    it('should work with mapnik substitution tokens and analyses', function(done) {
+        var cartocss = [
+            "#layer {",
+            "  line-width: 2;",
+            "  line-color: #3B3B58;",
+            "  line-opacity: 1;",
+            "  polygon-opacity: 0.7;",
+            "  polygon-fill: ramp([points_count], (#E5F5F9,#99D8C9,#2CA25F))",
+            "}"
+        ].join('\n');
+
+        var sqlWrap = [
+            'WITH hgrid AS (',
+            '  SELECT CDB_HexagonGrid(',
+            '    ST_Expand(!bbox!, greatest(!pixel_width!,!pixel_height!) * 100),',
+            '    greatest(!pixel_width!,!pixel_height!) * 100',
+            '  ) as cell',
+            ')',
+            'SELECT',
+            '  hgrid.cell as the_geom_webmercator,',
+            '  count(1) as points_count,',
+            '  count(1)/power(100 * CDB_XYZ_Resolution(CDB_ZoomFromScale(!scale_denominator!)), 2) as points_density,',
+            '  1 as cartodb_id',
+            'FROM hgrid, (<%= sql %>) i',
+            'where ST_Intersects(i.the_geom_webmercator, hgrid.cell)',
+            'GROUP BY hgrid.cell'
+        ].join('\n');
+
+        var mapConfig = {
+            "version": "1.5.0",
+            "layers": [
+                {
+                    "type": 'mapnik',
+                    "options": {
+                        "cartocss_version": '2.3.0',
+                        "source": {
+                            "id": "head"
+                        },
+                        sql_wrap: sqlWrap,
+                        "cartocss": cartocss
+                    }
+                }
+            ],
+            "analyses": [
+                {
+                    "id": "head",
+                    "type": "source",
+                    "params": {
+                        "query": "SELECT * FROM populated_places_simple_reduced"
+                    }
+                }
+            ]
+        };
+
+        this.testClient = new TestClient(mapConfig, 1234);
+        this.testClient.getLayergroup(function(err, layergroup) {
+            assert.ok(!err, err);
+
+            assert.ok(layergroup.hasOwnProperty('layergroupid'));
+            assert.ok(!layergroup.hasOwnProperty('errors'));
+
+            done();
+        });
+    });
+
+    describe('empty datasource results', function() {
+
+        afterEach(function (done) {
+            if (this.testClient) {
+                this.testClient.drain(done);
+            } else {
+                done();
+            }
+        });
+
+        function emptyResultMapConfig(markerFillRule) {
+            var cartocss = [
+                "#county_points_with_population {",
+                "  marker-placement: point;",
+                "  marker-allow-overlap: true;",
+                "  marker-fill-opacity: 1.0;",
+                "  marker-fill: " + markerFillRule + ';',
+                "  marker-line-width: 0;",
+                "}"
+            ].join('\n');
+
+            return {
+                "version": "1.5.0",
+                "layers": [
+                    {
+                        "type": 'mapnik',
+                        "options": {
+                            "cartocss_version": '2.3.0',
+                            "source": {
+                                "id": "head"
+                            },
+                            "cartocss": cartocss
+                        }
+                    }
+                ],
+                "analyses": [
+                    {
+                        "id": "head",
+                        "type": "source",
+                        "params": {
+                            "query": "SELECT * FROM populated_places_simple_reduced limit 0"
+                        }
+                    }
+                ]
+            };
+        }
+
+        it('should work for numeric ramps', function(done) {
+
+            var makerFillRule = 'ramp([pop_max], (#E5F5F9,#99D8C9,#2CA25F), jenks)';
+
+            this.testClient = new TestClient(emptyResultMapConfig(makerFillRule), 1234);
+            this.testClient.getLayergroup(function(err, layergroup) {
+                assert.ok(!err, err);
+
+                assert.ok(layergroup.hasOwnProperty('layergroupid'));
+                assert.ok(!layergroup.hasOwnProperty('errors'));
+
+                done();
+            });
+        });
+
+        it('should work for category ramps', function(done) {
+
+            var makerFillRule = 'ramp([adm0name], (#E5F5F9,#99D8C9,#2CA25F), category)';
+
+            this.testClient = new TestClient(emptyResultMapConfig(makerFillRule), 1234);
+            this.testClient.getLayergroup(function(err, layergroup) {
+                assert.ok(!err, err);
+
+                assert.ok(layergroup.hasOwnProperty('layergroupid'));
+                assert.ok(!layergroup.hasOwnProperty('errors'));
+
+                done();
+            });
+        });
+    });
+
 });

test/acceptance/widgets/named-maps.js

@@ -10,7 +10,7 @@ var CartodbWindshaft = require('../../../lib/cartodb/server');
 var serverOptions = require('../../../lib/cartodb/server_options');
 var server = new CartodbWindshaft(serverOptions);
 
-var LayergroupToken = require('../../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../../support/layergroup-token');
 
 describe('named-maps widgets', function() {
 

test/acceptance/widgets/ported/aggregation.js

@@ -0,0 +1,329 @@
+require('../../../support/test_helper');
+
+var assert = require('../../../support/assert');
+var TestClient = require('../../../support/test-client');
+
+describe('widgets', function() {
+
+    describe('aggregations', function() {
+
+        afterEach(function(done) {
+            if (this.testClient) {
+                this.testClient.drain(done);
+            } else {
+                done();
+            }
+        });
+
+        var aggregationMapConfig = {
+            version: '1.5.0',
+            layers: [
+                {
+                    type: 'mapnik',
+                    options: {
+                        sql: 'select * from populated_places_simple_reduced',
+                        cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                        cartocss_version: '2.0.1',
+                        widgets: {
+                            adm0name: {
+                                type: 'aggregation',
+                                options: {
+                                    column: 'adm0name',
+                                    aggregation: 'count'
+                                }
+                            }
+                        }
+                    }
+                }
+            ]
+        };
+
+        it('can be fetched from a valid aggregation', function(done) {
+            this.testClient = new TestClient(aggregationMapConfig);
+            this.testClient.getWidget('adm0name', { own_filter: 0 }, function (err, res, aggregation) {
+                assert.ok(!err, err);
+                assert.ok(aggregation);
+                assert.equal(aggregation.type, 'aggregation');
+
+                assert.equal(aggregation.categories.length, 6);
+
+                assert.deepEqual(
+                    aggregation.categories[0],
+                    { category: 'United States of America', value: 769, agg: false }
+                );
+
+                assert.deepEqual(
+                    aggregation.categories[aggregation.categories.length - 1],
+                    { category: 'Other', value: 4914, agg: true }
+                );
+
+                done();
+            });
+        });
+
+        var filteredCategoriesScenarios = [
+            { accept: ['Canada'], values: [256] },
+            { accept: ['Canada', 'Spain', 'Chile', 'Thailand'], values: [256, 49, 83, 79] },
+            { accept: ['Canada', 'Spain', 'Chile', 'Thailand', 'Japan'], values: [256, 49, 83, 79, 69] },
+            { accept: ['Canada', 'Spain', 'Chile', 'Thailand', 'Japan', 'France'], values: [256, 49, 83, 79, 69, 71] },
+            {
+                accept: ['United States of America', 'Canada', 'Spain', 'Chile', 'Thailand', 'Japan', 'France'],
+                values: [769, 256, 49, 83, 79, 69, 71]
+            }
+        ];
+
+        filteredCategoriesScenarios.forEach(function(scenario) {
+            it('can filter some categories: ' + scenario.accept.join(', '), function(done) {
+                this.testClient = new TestClient(aggregationMapConfig);
+                var adm0nameFilter = {
+                    adm0name: {
+                        accept: scenario.accept
+                    }
+                };
+                var params = {
+                    own_filter: 1,
+                    filters: {
+                        layers: [
+                            adm0nameFilter
+                        ]
+                    }
+                };
+                this.testClient.getWidget('adm0name', params, function (err, res, aggregation) {
+                    assert.ok(!err, err);
+                    assert.ok(aggregation);
+                    assert.equal(aggregation.type, 'aggregation');
+
+                    assert.equal(aggregation.categories.length, scenario.accept.length);
+
+                    var categoriesByCategory = aggregation.categories.reduce(function(byCategory, row) {
+                        byCategory[row.category] = row;
+                        return byCategory;
+                    }, {});
+
+                    var scenarioByCategory = scenario.accept.reduce(function(byCategory, category, index) {
+                        byCategory[category] = { category: category, value: scenario.values[index], agg: false };
+                        return byCategory;
+                    }, {});
+
+                    Object.keys(categoriesByCategory).forEach(function(category) {
+                        assert.deepEqual(categoriesByCategory[category], scenarioByCategory[category]);
+                    });
+
+                    done();
+                });
+            });
+        });
+
+        var aggregationSumMapConfig = {
+            version: '1.5.0',
+            layers: [
+                {
+                    type: 'mapnik',
+                    options: {
+                        sql: 'select * from populated_places_simple_reduced',
+                        cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                        cartocss_version: '2.0.1',
+                        widgets: {
+                            adm0name: {
+                                type: 'aggregation',
+                                options: {
+                                    column: 'adm0name',
+                                    aggregation: 'sum',
+                                    aggregationColumn: 'pop_max'
+                                }
+                            }
+                        }
+                    }
+                }
+            ]
+        };
+
+        it('can sum other column for aggregation value', function(done) {
+
+            this.testClient = new TestClient(aggregationSumMapConfig);
+            this.testClient.getWidget('adm0name', { own_filter: 0 }, function (err, res, aggregation) {
+                assert.ok(!err, err);
+                assert.ok(aggregation);
+                assert.equal(aggregation.type, 'aggregation');
+
+                assert.equal(aggregation.categories.length, 6);
+
+                assert.deepEqual(
+                    aggregation.categories[0],
+                    { category: 'China', value: 374537585, agg: false }
+                );
+
+                assert.deepEqual(
+                    aggregation.categories[aggregation.categories.length - 1],
+                    { category: 'Other', value: 1412626289, agg: true }
+                );
+
+                done();
+            });
+        });
+
+        var filteredCategoriesSumScenarios = [
+            { accept: [], values: [] },
+            { accept: ['Canada'], values: [23955084] },
+            { accept: ['Canada', 'Spain', 'Chile', 'Thailand'], values: [23955084, 22902774, 14356263, 17492483] },
+            {
+                accept: ['United States of America', 'Canada', 'Spain', 'Chile', 'Thailand', 'Japan', 'France'],
+                values: [239098994, 23955084, 22902774, 14356263, 17492483, 93577001, 25473876]
+            }
+        ];
+
+        filteredCategoriesSumScenarios.forEach(function(scenario) {
+            it('can filter some categories with sum aggregation: ' + scenario.accept.join(', '), function(done) {
+                this.testClient = new TestClient(aggregationSumMapConfig);
+                var adm0nameFilter = {
+                    adm0name: {
+                        accept: scenario.accept
+                    }
+                };
+                var params = {
+                    own_filter: 1,
+                    filters: {
+                        layers: [
+                            adm0nameFilter
+                        ]
+                    }
+                };
+                this.testClient.getWidget('adm0name', params, function (err, res, aggregation) {
+                    assert.ok(!err, err);
+                    assert.ok(aggregation);
+                    assert.equal(aggregation.type, 'aggregation');
+
+                    assert.equal(aggregation.categories.length, scenario.accept.length);
+
+                    var categoriesByCategory = aggregation.categories.reduce(function(byCategory, row) {
+                        byCategory[row.category] = row;
+                        return byCategory;
+                    }, {});
+
+                    var scenarioByCategory = scenario.accept.reduce(function(byCategory, category, index) {
+                        byCategory[category] = { category: category, value: scenario.values[index], agg: false };
+                        return byCategory;
+                    }, {});
+
+                    Object.keys(categoriesByCategory).forEach(function(category) {
+                        assert.deepEqual(categoriesByCategory[category], scenarioByCategory[category]);
+                    });
+
+                    done();
+                });
+            });
+        });
+
+        var numericAggregationMapConfig = {
+            version: '1.5.0',
+            layers: [
+                {
+                    type: 'mapnik',
+                    options: {
+                        sql: 'select * from populated_places_simple_reduced',
+                        cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                        cartocss_version: '2.3.0',
+                        widgets: {
+                            scalerank: {
+                                type: 'aggregation',
+                                options: {
+                                    column: 'scalerank',
+                                    aggregation: 'count'
+                                }
+                            }
+                        }
+                    }
+                }
+            ]
+        };
+
+        ['1', 1].forEach(function(filterValue) {
+            it('can filter numeric categories: ' + (typeof filterValue), function(done) {
+                this.testClient = new TestClient(numericAggregationMapConfig);
+                var scalerankFilter = {
+                    scalerank: {
+                        accept: [filterValue]
+                    }
+                };
+                var params = {
+                    own_filter: 1,
+                    filters: {
+                        layers: [scalerankFilter]
+                    }
+                };
+                this.testClient.getWidget('scalerank', params, function (err, res, aggregation) {
+                    assert.ok(!err, err);
+                    assert.ok(aggregation);
+                    assert.equal(aggregation.type, 'aggregation');
+
+                    assert.equal(aggregation.categories.length, 1);
+                    assert.deepEqual(aggregation.categories[0], { category: '1', value: 179, agg: false });
+
+                    done();
+                });
+            });
+        });
+
+        describe('search', function() {
+            afterEach(function(done) {
+                if (this.testClient) {
+                    this.testClient.drain(done);
+                } else {
+                    done();
+                }
+            });
+
+            ['1', 1].forEach(function(userQuery) {
+                it('can search numeric categories: ' + (typeof userQuery), function(done) {
+                    this.testClient = new TestClient(numericAggregationMapConfig);
+                    var scalerankFilter = {
+                        scalerank: {
+                            accept: [userQuery]
+                        }
+                    };
+                    var params = {
+                        own_filter: 0,
+                        filters: {
+                            layers: [scalerankFilter]
+                        }
+                    };
+                    this.testClient.widgetSearch('scalerank', userQuery, params, function (err, res, searchResult) {
+                        assert.ok(!err, err);
+                        assert.ok(searchResult);
+                        assert.equal(searchResult.type, 'aggregation');
+
+                        assert.equal(searchResult.categories.length, 2);
+                        assert.deepEqual(
+                            searchResult.categories,
+                            [{ category: 10, value: 515 }, { category: 1, value: 179 }]
+                        );
+
+                        done();
+                    });
+                });
+            });
+
+            var adm0name = 'Argentina';
+            [adm0name, adm0name.toLowerCase(), adm0name.toUpperCase()].forEach(function(userQuery) {
+                it('should search with case insensitive: ' + userQuery, function(done) {
+                    this.testClient = new TestClient(aggregationMapConfig);
+                    this.testClient.widgetSearch('adm0name', userQuery, function (err, res, searchResult) {
+                        assert.ok(!err, err);
+                        assert.ok(searchResult);
+                        assert.equal(searchResult.type, 'aggregation');
+
+                        assert.equal(searchResult.categories.length, 1);
+                        assert.deepEqual(
+                            searchResult.categories,
+                            [{ category:"Argentina", value:159 }]
+                        );
+
+                        done();
+                    });
+                });
+            });
+        });
+
+    });
+
+});

test/acceptance/widgets/ported/formula.js

@@ -0,0 +1,89 @@
+require('../../../support/test_helper');
+
+var assert        = require('../../../support/assert');
+var TestClient = require('../../../support/test-client');
+
+describe('widgets', function() {
+
+    describe('formula', function() {
+
+        afterEach(function(done) {
+            if (this.testClient) {
+                this.testClient.drain(done);
+            } else {
+                done();
+            }
+        });
+
+        function widgetsMapConfig(widgets) {
+            return {
+                version: '1.5.0',
+                layers: [
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from populated_places_simple_reduced where pop_max > 0 and pop_max < 600000',
+                            cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                            cartocss_version: '2.0.1',
+                            widgets: widgets
+                        }
+                    }
+                ]
+            };
+        }
+
+        var operations = {
+            min: [10, 0],
+            max: [599579, 0],
+            count: [5822, 0],
+            avg: [112246.00893163861, 0],
+            sum: [653496264, 0]
+        };
+
+        Object.keys(operations).forEach(function(operation) {
+            it('should do ' + operation + ' over column', function(done) {
+                var widgets = {
+                    pop_max_f: {
+                        type: 'formula',
+                        options: {
+                            column: 'pop_max',
+                            operation: operation
+                        }
+                    }
+                };
+                this.testClient = new TestClient(widgetsMapConfig(widgets));
+                this.testClient.getWidget('pop_max_f', function (err, res, result) {
+                    assert.ok(!err, err);
+                    assert.equal(result.operation, operation);
+                    assert.equal(result.result, operations[operation][0]);
+                    assert.equal(result.nulls, operations[operation][1]);
+
+                    done();
+                });
+            });
+        });
+
+        it('does not require column for count formula', function(done) {
+           var operation = 'count';
+            var widgets = {
+                pop_max_count_f: {
+                    type: 'formula',
+                    options: {
+                        operation: operation
+                    }
+                }
+            };
+            this.testClient = new TestClient(widgetsMapConfig(widgets));
+            this.testClient.getWidget('pop_max_count_f', function (err, res, result) {
+                assert.ok(!err, err);
+                assert.equal(result.operation, operation);
+                assert.equal(result.result, operations[operation][0]);
+                assert.equal(result.nulls, operations[operation][1]);
+
+                done();
+            });
+        });
+
+    });
+
+});

test/acceptance/widgets/ported/histogram.js

@@ -0,0 +1,373 @@
+require('../../../support/test_helper');
+
+var assert        = require('../../../support/assert');
+var TestClient = require('../../../support/test-client');
+
+describe('widgets', function() {
+
+    describe('histograms', function() {
+
+        afterEach(function(done) {
+            if (this.testClient) {
+                this.testClient.drain(done);
+            } else {
+                done();
+            }
+        });
+
+        function histogramsMapConfig(widgets) {
+            return {
+                version: '1.5.0',
+                layers: [
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from populated_places_simple_reduced',
+                            cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                            cartocss_version: '2.0.1',
+                            widgets: widgets || {
+                                scalerank: {
+                                    type: 'histogram',
+                                    options: {
+                                        column: 'scalerank'
+                                    }
+                                },
+                                pop_max: {
+                                    type: 'histogram',
+                                    options: {
+                                        column: 'pop_max'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            };
+        }
+
+        it('can be fetched from a valid histogram', function(done) {
+            this.testClient = new TestClient(histogramsMapConfig());
+            this.testClient.getWidget('scalerank', function (err, res, histogram) {
+                assert.ok(!err, err);
+                assert.ok(histogram);
+                assert.equal(histogram.type, 'histogram');
+                validateHistogramBins(histogram);
+
+                assert.ok(histogram.bins.length);
+
+                assert.deepEqual(histogram.bins[0], { bin: 0, freq: 179, min: 1, max: 1, avg: 1 });
+
+                done();
+            });
+        });
+
+        it('can be fetched from a valid histogram', function(done) {
+            this.testClient = new TestClient(histogramsMapConfig());
+            this.testClient.getWidget('pop_max', function (err, res, histogram) {
+                assert.ok(!err, err);
+                assert.ok(histogram);
+                assert.equal(histogram.type, 'histogram');
+                validateHistogramBins(histogram);
+
+                assert.ok(histogram.bins.length);
+
+                assert.deepEqual(
+                    histogram.bins[histogram.bins.length - 1],
+                    { bin: 47, freq: 1, min: 35676000, max: 35676000, avg: 35676000 }
+                );
+
+                done();
+            });
+        });
+
+        it('can be fetched from a valid filtered histogram', function(done) {
+            this.testClient = new TestClient(histogramsMapConfig());
+            var popMaxFilter = {
+                pop_max: {
+                    min: 1e5,
+                    max: 1e7
+                }
+            };
+            var params = {
+                own_filter: 1,
+                filters: {
+                    layers: [popMaxFilter]
+                }
+            };
+            this.testClient.getWidget('pop_max', params, function (err, res, histogram) {
+                assert.ok(!err, err);
+                assert.ok(histogram);
+                assert.equal(histogram.type, 'histogram');
+                validateHistogramBins(histogram);
+
+                assert.ok(histogram.bins.length);
+
+                assert.deepEqual(
+                    histogram.bins[histogram.bins.length - 1],
+                    { bin: 7, min: 8829000, max: 9904000, avg: 9340914.714285715, freq: 7 }
+                );
+
+                done();
+            });
+        });
+
+        it('returns array with freq=0 entries for empty bins', function(done) {
+            var histogram20binsMapConfig = {
+                version: '1.5.0',
+                layers: [
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from populated_places_simple_reduced',
+                            cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                            cartocss_version: '2.0.1',
+                            widgets: {
+                                pop_max: {
+                                    type: 'histogram',
+                                    options: {
+                                        column: 'pop_max'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            };
+
+            this.testClient = new TestClient(histogram20binsMapConfig);
+            this.testClient.getWidget('pop_max', { start: 0, end: 35676000, bins: 20 }, function (err, res, histogram) {
+                assert.ok(!err, err);
+                assert.equal(histogram.type, 'histogram');
+                validateHistogramBins(histogram);
+                assert.ok(histogram.bins.length);
+                assert.deepEqual(
+                    histogram.bins[histogram.bins.length - 1],
+                    { bin: 19, freq: 1, min: 35676000, max: 35676000, avg: 35676000 }
+                );
+
+                var emptyBin = histogram.bins[18];
+                assert.ok(!emptyBin);
+
+                done();
+            });
+        });
+
+        it('can use a fixed number of bins', function(done) {
+            var fixedBinsHistogramMapConfig = histogramsMapConfig({
+                pop_max: {
+                    type: 'histogram',
+                    options: {
+                        column: 'pop_max'
+                    }
+                }
+            });
+
+            this.testClient = new TestClient(fixedBinsHistogramMapConfig);
+            this.testClient.getWidget('pop_max', { bins: 5 }, function (err, res, histogram) {
+                assert.ok(!err, err);
+                assert.equal(histogram.type, 'histogram');
+
+                assert.equal(histogram.bins_count, 5);
+
+                validateHistogramBins(histogram);
+
+                assert.ok(histogram.bins.length);
+                assert.deepEqual(
+                    histogram.bins[0],
+                    { bin: 0, min: 0, max: 7067423, avg: 280820.0057731959, freq: 7275 }
+                );
+                assert.deepEqual(
+                    histogram.bins[histogram.bins.length - 1],
+                    { bin: 4, freq: 1, min: 35676000, max: 35676000, avg: 35676000 }
+                );
+
+                done();
+            });
+        });
+
+        function validateHistogramBins(histogram) {
+            var binWidth = histogram.bin_width;
+            var start = histogram.bins_start;
+            var end = start + (histogram.bins_count * binWidth);
+
+            var firstBin = histogram.bins[0];
+            assert.equal(firstBin.min, start,
+                'First bin does not match min and start ' + JSON.stringify({
+                    min: firstBin.min,
+                    start: start
+                })
+            );
+
+            var lastBin = histogram.bins[histogram.bins.length - 1];
+            assert.equal(lastBin.max, end,
+                'Last bin does not match max and end ' + JSON.stringify({
+                    max: lastBin.max,
+                    end: end
+                })
+            );
+
+            function getBinStartEnd(binIndex) {
+                return {
+                    start: start + (binIndex * binWidth),
+                    end: start + ((binIndex + 1) * binWidth)
+                };
+            }
+
+            histogram.bins.forEach(function(bin) {
+                var binStartEnd = getBinStartEnd(bin.bin);
+
+                assert.ok(binStartEnd.start <= bin.min,
+                    'Bin start bigger than bin min ' + JSON.stringify({
+                        bin: bin.bin,
+                        min: bin.min,
+                        start: binStartEnd.start
+                    })
+                );
+
+                assert.ok(binStartEnd.end >= bin.max,
+                    'Bin end smaller than bin max ' + JSON.stringify({
+                        bin: bin.bin,
+                        max: bin.max,
+                        end: binStartEnd.end
+                    })
+                );
+
+                assert.ok(bin.avg >= bin.min && bin.avg <= bin.max,
+                        'Bin avg not between min and max values' + JSON.stringify({
+                        bin: bin.bin,
+                        avg: bin.avg,
+                        min: bin.min,
+                        max: bin.max
+                    })
+                );
+            });
+        }
+
+        describe('datetime column', function() {
+            afterEach(function(done) {
+                if (this.testClient) {
+                    this.testClient.drain(done);
+                } else {
+                    done();
+                }
+            });
+
+            var updatedAtFilter = {
+                updated_at: {
+                    min: 0
+                }
+            };
+
+            it('can use a datetime column', function(done) {
+                this.testClient = new TestClient(histogramsMapConfig({
+                    updated_at: {
+                        type: 'histogram',
+                        options: {
+                            column: 'updated_at'
+                        }
+                    }
+                }));
+                this.testClient.getWidget('updated_at', function (err, res, histogram) {
+                    assert.ok(!err, err);
+                    assert.ok(histogram);
+                    assert.equal(histogram.type, 'histogram');
+
+                    assert.ok(histogram.bins.length);
+
+                    done();
+                });
+            });
+
+            it('can use a datetime filtered column', function(done) {
+                this.testClient = new TestClient(histogramsMapConfig({
+                    updated_at: {
+                        type: 'histogram',
+                        options: {
+                            column: 'updated_at'
+                        }
+                    }
+                }));
+                var params = {
+                    own_filter: 1,
+                    filters: {
+                        layers: [updatedAtFilter]
+                    }
+                };
+                this.testClient.getWidget('updated_at', params, function (err, res, histogram) {
+                    assert.ok(!err, err);
+                    assert.ok(histogram);
+                    assert.equal(histogram.type, 'histogram');
+
+                    assert.ok(histogram.bins.length);
+
+                    done();
+                });
+            });
+
+            it('can getTile with datetime filtered column', function(done) {
+                this.testClient = new TestClient(histogramsMapConfig({
+                    updated_at: {
+                        type: 'histogram',
+                        options: {
+                            column: 'updated_at'
+                        }
+                    }
+                }));
+                var params = {
+                    own_filter: 1,
+                    filters: {
+                        layers: [updatedAtFilter]
+                    }
+                };
+                this.testClient.getTile(0, 0, 0, params, function (err, res, tile) {
+                    assert.ok(!err, err);
+                    assert.ok(tile);
+
+                    done();
+                });
+            });
+
+            it('can use two columns with different types', function(done) {
+                this.testClient = new TestClient(histogramsMapConfig({
+                    updated_at: {
+                        type: 'histogram',
+                        options: {
+                            column: 'updated_at'
+                        }
+                    },
+                    pop_max: {
+                        type: 'histogram',
+                        options: {
+                            column: 'pop_max'
+                        }
+                    }
+                }));
+
+                var popMaxFilter = {
+                    pop_max: {
+                        max: 1e7
+                    }
+                };
+
+                var params = {
+                    own_filter: 1,
+                    filters: {
+                        layers: [popMaxFilter]
+                    }
+                };
+
+                this.testClient.getWidget('updated_at', params, function (err, res, histogram) {
+                    assert.ok(!err, err);
+                    assert.ok(histogram);
+                    assert.equal(histogram.type, 'histogram');
+
+                    assert.ok(histogram.bins.length);
+
+                    done();
+                });
+            });
+        });
+
+    });
+
+});

test/acceptance/widgets/ported/list.js

@@ -0,0 +1,106 @@
+require('../../../support/test_helper');
+
+var assert        = require('../../../support/assert');
+var TestClient = require('../../../support/test-client');
+var _ = require('underscore');
+
+describe('widgets', function() {
+
+    describe('lists', function() {
+
+        afterEach(function(done) {
+            if (this.testClient) {
+                this.testClient.drain(done);
+            } else {
+                done();
+            }
+        });
+
+        function listsMapConfig(columns) {
+            return {
+                version: '1.5.0',
+                layers: [
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from test_table',
+                            cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                            cartocss_version: '2.0.1',
+                            widgets: {
+                                places: {
+                                    type: 'list',
+                                    options: {
+                                        columns: columns || ['name', 'address']
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            };
+        }
+
+        var EXPECTED_NAMES = ['Hawai', 'El Estocolmo', 'El Rey del Tallarín', 'El Lacón', 'El Pico'];
+
+        it('can be fetched from a valid list', function(done) {
+            var columns = ['name', 'address'];
+            this.testClient = new TestClient(listsMapConfig(columns));
+            this.testClient.getWidget('places', function (err, res, list) {
+                assert.ok(!err, err);
+                assert.ok(list);
+                assert.equal(list.type, 'list');
+                assert.equal(list.rows.length, 5);
+
+                assert.ok(onlyHasFields(list, columns));
+
+                var names = list.rows.map(function (item) {
+                    return item.name;
+                });
+                assert.deepEqual(names, EXPECTED_NAMES);
+
+                var expectedAddresses = [
+                    'Calle de Pérez Galdós 9, Madrid, Spain',
+                    'Calle de la Palma 72, Madrid, Spain',
+                    'Plaza Conde de Toreno 2, Madrid, Spain',
+                    'Manuel Fernández y González 8, Madrid, Spain',
+                    'Calle Divino Pastor 12, Madrid, Spain'
+                ];
+                var addresses = list.rows.map(function (item) {
+                    return item.address;
+                });
+                assert.deepEqual(addresses, expectedAddresses);
+
+                done();
+            });
+        });
+
+        it('should fetch just one column', function(done) {
+            var columns = ['name'];
+            this.testClient = new TestClient(listsMapConfig(columns));
+            this.testClient.getWidget('places', function (err, res, list) {
+                assert.ok(!err, err);
+                assert.ok(list);
+                assert.equal(list.type, 'list');
+                assert.equal(list.rows.length, 5);
+
+                assert.ok(onlyHasFields(list, columns));
+
+                var names = list.rows.map(function (item) {
+                    return item.name;
+                });
+                assert.deepEqual(names, EXPECTED_NAMES);
+
+                done();
+            });
+        });
+
+        function onlyHasFields(list, expectedFields) {
+            var fields = (!!list.rows[0]) ? Object.keys(list.rows[0]) : [];
+
+            return _.difference(fields, expectedFields).length === 0 &&
+                _.difference(expectedFields, fields).length === 0;
+        }
+
+    });
+
+});

test/acceptance/widgets/regressions.js

@@ -0,0 +1,223 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var TestClient = require('../../support/test-client');
+
+describe('widgets-regressions', function() {
+
+    describe('aggregations', function() {
+
+        afterEach(function(done) {
+            if (this.testClient) {
+                this.testClient.drain(done);
+            } else {
+                done();
+            }
+        });
+
+        it('should work when there is a mix of layers with and without widgets', function(done) {
+            var layersWithNoWidgetsMapConfig = {
+                version: '1.5.0',
+                layers: [
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from populated_places_simple_reduced',
+                            cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                            cartocss_version: '2.0.1',
+                            widgets: {
+                                adm0name: {
+                                    type: 'aggregation',
+                                    options: {
+                                        column: 'adm0name',
+                                        aggregation: 'sum',
+                                        aggregationColumn: 'pop_max'
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from populated_places_simple_reduced limit 100',
+                            cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                            cartocss_version: '2.0.1'
+                        }
+                    }
+                ]
+            };
+
+            this.testClient = new TestClient(layersWithNoWidgetsMapConfig);
+            this.testClient.getWidget('adm0name', { own_filter: 0 }, function (err, res, aggregation) {
+                assert.ok(!err, err);
+                assert.ok(aggregation);
+                assert.equal(aggregation.type, 'aggregation');
+
+                assert.equal(aggregation.categories.length, 6);
+
+                assert.deepEqual(
+                    aggregation.categories[0],
+                    { category: 'China', value: 374537585, agg: false }
+                );
+
+                assert.deepEqual(
+                    aggregation.categories[aggregation.categories.length - 1],
+                    { category: 'Other', value: 1412626289, agg: true }
+                );
+
+                done();
+            });
+        });
+
+        it('should work when there is a mix of layers with and without widgets, source and sql', function(done) {
+            var mixOfLayersMapConfig = {
+                version: '1.5.0',
+                layers: [
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from populated_places_simple_reduced',
+                            cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                            cartocss_version: '2.0.1',
+                            widgets: {
+                                adm0name_categories: {
+                                    type: 'aggregation',
+                                    options: {
+                                        column: 'adm0name',
+                                        aggregation: 'sum',
+                                        aggregationColumn: 'pop_max'
+                                    }
+                                },
+                                adm1name_categories: {
+                                    type: 'aggregation',
+                                    options: {
+                                        column: 'adm1name',
+                                        aggregation: 'sum',
+                                        aggregationColumn: 'pop_max'
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    {
+                        type: 'mapnik',
+                        options: {
+                            source: {id: 'head-limited'},
+                            cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                            cartocss_version: '2.0.1',
+                            widgets: {
+                                pop_max_histogram: {
+                                    type: 'histogram',
+                                    options: {
+                                        column: 'pop_max'
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    {
+                        "type": "http",
+                        "options": {
+                            "urlTemplate": "http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png",
+                            "subdomains": "abcd"
+                        }
+                    }
+                ],
+                analyses: [
+                    {
+                        id: 'head-limited',
+                        type: 'source',
+                        params: {
+                            query: 'select * from populated_places_simple_reduced limit 100'
+                        }
+                    }
+                ],
+                dataviews: {
+                    wadus: {
+                        type: 'histogram',
+                        source: {
+                            id: 'head-limited'
+                        },
+                        options: {
+                            column: 'population'
+                        }
+                    }
+                }
+            };
+
+            this.testClient = new TestClient(mixOfLayersMapConfig);
+            this.testClient.getLayergroup(function(err, layergroup) {
+                assert.ok(!err, err);
+                assert.ok(layergroup.metadata);
+                var metadata = layergroup.metadata;
+                assert.equal(metadata.layers.length, 3);
+                assert.equal(metadata.analyses.length, 2);
+                assert.equal(Object.keys(metadata.dataviews).length, 4);
+                assert.deepEqual(
+                    Object.keys(metadata.dataviews),
+                    ['wadus', 'adm0name_categories', 'adm1name_categories', 'pop_max_histogram']
+                );
+
+
+                done();
+            });
+        });
+
+        it('should work with layers not containing sql', function(done) {
+            var nonSqlLayersMapConfig = {
+                version: '1.5.0',
+                layers: [
+                    {
+                        type: 'mapnik',
+                        options: {
+                            sql: 'select * from populated_places_simple_reduced',
+                            cartocss: '#layer0 { marker-fill: red; marker-width: 10; }',
+                            cartocss_version: '2.0.1',
+                            widgets: {
+                                adm0name: {
+                                    type: 'aggregation',
+                                    options: {
+                                        column: 'adm0name',
+                                        aggregation: 'sum',
+                                        aggregationColumn: 'pop_max'
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    {
+                        "type": "http",
+                        "options": {
+                            "urlTemplate": "http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png",
+                            "subdomains": "abcd"
+                        }
+                    }
+                ]
+            };
+
+            this.testClient = new TestClient(nonSqlLayersMapConfig);
+            this.testClient.getWidget('adm0name', { own_filter: 0 }, function (err, res, aggregation) {
+                assert.ok(!err, err);
+                assert.ok(aggregation);
+                assert.equal(aggregation.type, 'aggregation');
+
+                assert.equal(aggregation.categories.length, 6);
+
+                assert.deepEqual(
+                    aggregation.categories[0],
+                    { category: 'China', value: 374537585, agg: false }
+                );
+
+                assert.deepEqual(
+                    aggregation.categories[aggregation.categories.length - 1],
+                    { category: 'Other', value: 1412626289, agg: true }
+                );
+
+                done();
+            });
+        });
+
+    });
+
+});

test/acceptance/x_cache_channel.js

@@ -8,7 +8,7 @@ var serverOptions = require('../../lib/cartodb/server_options');
 var server = new CartodbWindshaft(serverOptions);
 server.setMaxListeners(0);
 
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('../support/layergroup-token');
 
 describe('get requests x-cache-channel', function() {
 

test/integration/mapconfig_named_layers_datasource.js

@@ -4,7 +4,7 @@ var assert = require('assert');
 var RedisPool = require('redis-mpool');
 var TemplateMaps = require('../../lib/cartodb/backends/template_maps.js');
 var PgConnection = require(__dirname + '/../../lib/cartodb/backends/pg_connection');
-var MapConfigNamedLayersAdapter = require('../../lib/cartodb/models/mapconfig_named_layers_adapter');
+var MapConfigNamedLayersAdapter = require('../../lib/cartodb/models/mapconfig/adapter/mapconfig-named-layers-adapter');
 
 // configure redis pool instance to use in tests
 var redisPool = new RedisPool(global.environment.redis);
@@ -14,7 +14,7 @@ var templateMaps = new TemplateMaps(redisPool, {
     max_user_templates: global.environment.maxUserTemplates
 });
 
-var mapConfigNamedLayersAdapter = new MapConfigNamedLayersAdapter(templateMaps);
+var mapConfigNamedLayersAdapter = new MapConfigNamedLayersAdapter(templateMaps, pgConnection);
 
 var wadusSql = 'select 1 wadusLayer, null::geometry the_geom_webmercator';
 var wadusLayer = {
@@ -294,9 +294,11 @@ describe('named_layers datasources', function() {
 
     testScenarios.forEach(function(testScenario) {
         it('should return a list of layers ' + testScenario.desc, function(done) {
-            mapConfigNamedLayersAdapter.getLayers(username, testScenario.config.layers, pgConnection,
-                function(err, layers, datasource) {
-                    testScenario.test(err, layers, datasource, done);
+            var params = {};
+            var context = {};
+            mapConfigNamedLayersAdapter.getMapConfig(username, testScenario.config, params, context,
+                function(err, mapConfig) {
+                    testScenario.test(err, mapConfig.layers, context.datasource, done);
                 }
             );
         });

test/integration/mapconfig_named_layers_expanded.js

@@ -4,9 +4,9 @@ var assert = require('assert');
 var RedisPool = require('redis-mpool');
 var TemplateMaps = require('../../lib/cartodb/backends/template_maps.js');
 var PgConnection = require(__dirname + '/../../lib/cartodb/backends/pg_connection');
-var MapConfigNamedLayersAdapter = require('../../lib/cartodb/models/mapconfig_named_layers_adapter');
+var MapConfigNamedLayersAdapter = require('../../lib/cartodb/models/mapconfig/adapter/mapconfig-named-layers-adapter');
 
-describe('mapconfig_named_layers_adapter', function() {
+describe('mapconfig-named-layers-adapter', function() {
 
     // configure redis pool instance to use in tests
     var redisPool = new RedisPool(global.environment.redis);
@@ -16,7 +16,7 @@ describe('mapconfig_named_layers_adapter', function() {
         max_user_templates: global.environment.maxUserTemplates
     });
 
-    var mapConfigNamedLayersAdapter = new MapConfigNamedLayersAdapter(templateMaps);
+    var mapConfigNamedLayersAdapter = new MapConfigNamedLayersAdapter(templateMaps, pgConnection);
 
     var wadusLayer = {
         type: 'cartodb',
@@ -134,6 +134,8 @@ describe('mapconfig_named_layers_adapter', function() {
         };
     }
 
+    var params = {};
+    var context = {};
 
     beforeEach(function(done) {
         templateMaps.addTemplate(username, template, done);
@@ -147,11 +149,11 @@ describe('mapconfig_named_layers_adapter', function() {
         var missingNamedMapLayerConfig = makeNamedMapLayerConfig({
             config: {}
         });
-        mapConfigNamedLayersAdapter.getLayers(username, missingNamedMapLayerConfig.layers, pgConnection,
-            function(err, layers, datasource) {
+        mapConfigNamedLayersAdapter.getMapConfig(username, missingNamedMapLayerConfig, params, context,
+            function(err, mapConfig) {
                 assert.ok(err);
-                assert.ok(!layers);
-                assert.ok(!datasource);
+                assert.ok(!mapConfig);
+                assert.ok(!context.datasource);
                 assert.equal(err.message, 'Missing Named Map `name` in layer options');
 
                 done();
@@ -164,11 +166,11 @@ describe('mapconfig_named_layers_adapter', function() {
         var nonExistentNamedMapLayerConfig = makeNamedMapLayerConfig({
             name: missingTemplateName
         });
-        mapConfigNamedLayersAdapter.getLayers(username, nonExistentNamedMapLayerConfig.layers, pgConnection,
-            function(err, layers, datasource) {
+        mapConfigNamedLayersAdapter.getMapConfig(username, nonExistentNamedMapLayerConfig, params, context,
+            function(err, mapConfig) {
                 assert.ok(err);
-                assert.ok(!layers);
-                assert.ok(!datasource);
+                assert.ok(!mapConfig);
+                assert.ok(!context.datasource);
                 assert.equal(
                     err.message, "Template '" + missingTemplateName + "' of user '" + username + "' not found"
                 );
@@ -187,11 +189,11 @@ describe('mapconfig_named_layers_adapter', function() {
             var nonAuthTokensNamedMapLayerConfig = makeNamedMapLayerConfig({
                 name: tokenAuthTemplateName
             });
-            mapConfigNamedLayersAdapter.getLayers(username, nonAuthTokensNamedMapLayerConfig.layers, pgConnection,
-                function(err, layers, datasource) {
+            mapConfigNamedLayersAdapter.getMapConfig(username, nonAuthTokensNamedMapLayerConfig, params, context,
+                function(err, mapConfig) {
                     assert.ok(err);
-                    assert.ok(!layers);
-                    assert.ok(!datasource);
+                    assert.ok(!mapConfig);
+                    assert.ok(!context.datasource);
                     assert.equal(err.message, "Unauthorized '" + tokenAuthTemplateName + "' template instantiation");
 
                     templateMaps.delTemplate(username, tokenAuthTemplateName, done);
@@ -209,11 +211,11 @@ describe('mapconfig_named_layers_adapter', function() {
             var nestedNamedMapLayerConfig = makeNamedMapLayerConfig({
                 name: nestedNamedMapTemplateName
             });
-            mapConfigNamedLayersAdapter.getLayers(username, nestedNamedMapLayerConfig.layers, pgConnection,
-                function(err, layers, datasource) {
+            mapConfigNamedLayersAdapter.getMapConfig(username, nestedNamedMapLayerConfig, params, context,
+                function(err, mapConfig) {
                     assert.ok(err);
-                    assert.ok(!layers);
-                    assert.ok(!datasource);
+                    assert.ok(!mapConfig);
+                    assert.ok(!context.datasource);
                     assert.equal(err.message, 'Nested named layers are not allowed');
 
                     templateMaps.delTemplate(username, nestedNamedMapTemplateName, done);
@@ -226,12 +228,13 @@ describe('mapconfig_named_layers_adapter', function() {
         var validNamedMapMapLayerConfig = makeNamedMapLayerConfig({
             name: templateName
         });
-        mapConfigNamedLayersAdapter.getLayers(username, validNamedMapMapLayerConfig.layers, pgConnection,
-            function(err, layers, datasource) {
+        mapConfigNamedLayersAdapter.getMapConfig(username, validNamedMapMapLayerConfig, params, context,
+            function(err, mapConfig) {
                 assert.ok(!err);
+                var layers = mapConfig.layers;
                 assert.ok(layers.length, 1);
                 assert.ok(layers[0].type, 'cartodb');
-                assert.notEqual(datasource.getLayerDatasource(0), undefined);
+                assert.notEqual(context.datasource.getLayerDatasource(0), undefined);
 
                 done();
             }
@@ -248,11 +251,12 @@ describe('mapconfig_named_layers_adapter', function() {
                 name: tokenAuthTemplateName,
                 auth_tokens: ['valid1']
             });
-            mapConfigNamedLayersAdapter.getLayers(username, validAuthTokensNamedMapLayerConfig.layers, pgConnection,
-                function(err, layers, datasource) {
+            mapConfigNamedLayersAdapter.getMapConfig(username, validAuthTokensNamedMapLayerConfig, params, context,
+                function(err, mapConfig) {
                     assert.ok(!err);
+                    var layers = mapConfig.layers;
                     assert.equal(layers.length, 1);
-                    assert.notEqual(datasource.getLayerDatasource(0), undefined);
+                    assert.notEqual(context.datasource.getLayerDatasource(0), undefined);
 
                     templateMaps.delTemplate(username, tokenAuthTemplateName, done);
                 }
@@ -270,18 +274,19 @@ describe('mapconfig_named_layers_adapter', function() {
                 name: multipleLayersTemplateName,
                 auth_tokens: ['valid2']
             });
-            mapConfigNamedLayersAdapter.getLayers(username, multipleLayersNamedMapLayerConfig.layers, pgConnection,
-                function(err, layers, datasource) {
+            mapConfigNamedLayersAdapter.getMapConfig(username, multipleLayersNamedMapLayerConfig, params, context,
+                function(err, mapConfig) {
                     assert.ok(!err);
+                    var layers = mapConfig.layers;
                     assert.equal(layers.length, 2);
 
                     assert.equal(layers[0].type, 'mapnik');
                     assert.equal(layers[0].options.cartocss, '#layer { polygon-fill: green; }');
-                    assert.notEqual(datasource.getLayerDatasource(0), undefined);
+                    assert.notEqual(context.datasource.getLayerDatasource(0), undefined);
 
                     assert.equal(layers[1].type, 'cartodb');
                     assert.equal(layers[1].options.cartocss, '#layer { marker-fill: red; }');
-                    assert.notEqual(datasource.getLayerDatasource(1), undefined);
+                    assert.notEqual(context.datasource.getLayerDatasource(1), undefined);
 
                     templateMaps.delTemplate(username, multipleLayersTemplateName, done);
                 }
@@ -306,18 +311,19 @@ describe('mapconfig_named_layers_adapter', function() {
                 },
                 auth_tokens: ['valid2']
             });
-            mapConfigNamedLayersAdapter.getLayers(username, multipleLayersNamedMapLayerConfig.layers, pgConnection,
-                function(err, layers, datasource) {
+            mapConfigNamedLayersAdapter.getMapConfig(username, multipleLayersNamedMapLayerConfig, params, context,
+                function(err, mapConfig) {
                     assert.ok(!err);
+                    var layers = mapConfig.layers;
                     assert.equal(layers.length, 2);
 
                     assert.equal(layers[0].type, 'mapnik');
                     assert.equal(layers[0].options.cartocss, '#layer { polygon-fill: ' + polygonColor + '; }');
-                    assert.notEqual(datasource.getLayerDatasource(0), undefined);
+                    assert.notEqual(context.datasource.getLayerDatasource(0), undefined);
 
                     assert.equal(layers[1].type, 'cartodb');
                     assert.equal(layers[1].options.cartocss, '#layer { marker-fill: ' + color + '; }');
-                    assert.notEqual(datasource.getLayerDatasource(1), undefined);
+                    assert.notEqual(context.datasource.getLayerDatasource(1), undefined);
 
                     templateMaps.delTemplate(username, multipleLayersTemplateName, done);
                 }

test/integration/mapconfig_overviews_adapter.js

@@ -6,20 +6,17 @@ var cartodbRedis = require('cartodb-redis');
 var PgConnection = require(__dirname + '/../../lib/cartodb/backends/pg_connection');
 var PgQueryRunner = require('../../lib/cartodb/backends/pg_query_runner');
 var OverviewsMetadataApi = require('../../lib/cartodb/api/overviews_metadata_api');
-var MapConfigOverviewsAdapter = require('../../lib/cartodb/models/mapconfig_overviews_adapter');
-
-// configure redis pool instance to use in tests
-var redisPool = new RedisPool(global.environment.redis);
-var pgConnection = new PgConnection(require('cartodb-redis')({ pool: redisPool }));
+var FilterStatsApi = require('../../lib/cartodb/api/filter_stats_api');
+var MapConfigOverviewsAdapter = require('../../lib/cartodb/models/mapconfig/adapter/mapconfig-overviews-adapter');
 
 var redisPool = new RedisPool(global.environment.redis);
 var metadataBackend = cartodbRedis({pool: redisPool});
 var pgConnection = new PgConnection(metadataBackend);
 var pgQueryRunner = new PgQueryRunner(pgConnection);
 var overviewsMetadataApi = new OverviewsMetadataApi(pgQueryRunner);
+var filterStatsApi = new FilterStatsApi(pgQueryRunner);
 
-
-var mapConfigOverviewsAdapter = new MapConfigOverviewsAdapter(overviewsMetadataApi);
+var mapConfigOverviewsAdapter = new MapConfigOverviewsAdapter(overviewsMetadataApi, filterStatsApi);
 
 describe('MapConfigOverviewsAdapter', function() {
 
@@ -36,8 +33,16 @@ describe('MapConfigOverviewsAdapter', function() {
             }
         };
 
-        mapConfigOverviewsAdapter.getLayers('localhost', [layer_without_overviews], function(err, layers) {
+        var _mapConfig = {
+            layers: [layer_without_overviews]
+        };
+
+        var params = {};
+        var context = {};
+
+        mapConfigOverviewsAdapter.getMapConfig('localhost', _mapConfig, params, context, function(err, mapConfig) {
             assert.ok(!err);
+            var layers = mapConfig.layers;
             assert.equal(layers.length, 1);
             assert.equal(layers[0].type, 'cartodb');
             assert.equal(layers[0].options.sql, sql);
@@ -55,7 +60,7 @@ describe('MapConfigOverviewsAdapter', function() {
         var sql = 'SELECT * FROM test_table_overviews';
         var cartocss = '#layer { marker-fill: black; }';
         var cartocss_version = '2.3.0';
-        var layer_without_overviews = {
+        var layer_with_overviews = {
             type: 'cartodb',
             options: {
                 sql: sql,
@@ -64,8 +69,16 @@ describe('MapConfigOverviewsAdapter', function() {
             }
         };
 
-        mapConfigOverviewsAdapter.getLayers('localhost', [layer_without_overviews], function(err, layers) {
+        var _mapConfig = {
+            layers: [layer_with_overviews]
+        };
+
+        var params = {};
+        var context = {};
+
+        mapConfigOverviewsAdapter.getMapConfig('localhost', _mapConfig, params, context, function(err, mapConfig) {
             assert.ok(!err);
+            var layers = mapConfig.layers;
             assert.equal(layers.length, 1);
             assert.equal(layers[0].type, 'cartodb');
             assert.equal(layers[0].options.sql, sql);

test/support/prepare_db.sh

@@ -12,6 +12,7 @@
 
 PREPARE_REDIS=yes
 PREPARE_PGSQL=yes
+DOWNLOAD_SQL_FILES=yes
 
 while [ -n "$1" ]; do
   if test "$1" = "--skip-pg"; then
@@ -20,6 +21,9 @@ while [ -n "$1" ]; do
   elif test "$1" = "--skip-redis"; then
     PREPARE_REDIS=no
     shift; continue
+  elif test "$1" = "--no-sql-download"; then
+    DOWNLOAD_SQL_FILES=no
+    shift; continue
   fi
 done
 
@@ -71,26 +75,31 @@ if test x"$PREPARE_PGSQL" = xyes; then
   dropdb "${TEST_DB}"
   createdb -Ttemplate_postgis -EUTF8 "${TEST_DB}" || die "Could not create test database"
 
-  curl -L -s https://raw.githubusercontent.com/CartoDB/camshaft/master/test/fixtures/cdb_analysis_catalog.sql -o sql/cdb_analysis_catalog.sql
-  cat sql/cdb_analysis_catalog.sql | psql -v ON_ERROR_STOP=1 ${TEST_DB} || exit 1
+  LOCAL_SQL_SCRIPTS='windshaft.test gadm4 ported/populated_places_simple_reduced'
+  REMOTE_SQL_SCRIPTS='CDB_QueryStatements CDB_QueryTables CDB_CartodbfyTable CDB_TableMetadata CDB_ForeignTable CDB_UserTables CDB_ColumnNames CDB_AnalysisCatalog CDB_ZoomFromScale CDB_OverviewsSupport CDB_Overviews CDB_QuantileBins CDB_JenksBins CDB_HeadsTailsBins CDB_EqualIntervalBins CDB_Hexagon CDB_XYZ'
 
-  cat sql/windshaft.test.sql sql/gadm4.sql |
-    sed "s/:PUBLICUSER/${PUBLICUSER}/" |
-    sed "s/:PUBLICPASS/${PUBLICPASS}/" |
-    sed "s/:TESTUSER/${TESTUSER}/" |
-    sed "s/:TESTPASS/${TESTPASS}/" |
-    psql -v ON_ERROR_STOP=1 ${TEST_DB} || exit 1
-
-  cat sql/_CDB_QueryStatements.sql | psql -v ON_ERROR_STOP=1 ${TEST_DB} || exit 1
-
-  SQL_SCRIPTS='CDB_QueryTables CDB_CartodbfyTable CDB_TableMetadata CDB_ForeignTable CDB_UserTables CDB_ColumnNames CDB_ZoomFromScale CDB_Overviews CDB_QuantileBins CDB_JenksBins CDB_HeadsTailsBins CDB_EqualIntervalBins CDB_Hexagon CDB_XYZ'
-  for i in ${SQL_SCRIPTS}
+  CURL_ARGS=""
+  for i in ${REMOTE_SQL_SCRIPTS}
   do
-    curl -L -s https://github.com/CartoDB/cartodb-postgresql/raw/master/scripts-available/$i.sql -o sql/$i.sql
-    cat sql/$i.sql | sed -e 's/cartodb\./public./g' -e "s/''cartodb''/''public''/g" \
-        | psql -v ON_ERROR_STOP=1 ${TEST_DB} || exit 1
+    CURL_ARGS="${CURL_ARGS}\"https://github.com/CartoDB/cartodb-postgresql/raw/master/scripts-available/$i.sql\" -o sql/$i.sql "
   done
+  if test x"$DOWNLOAD_SQL_FILES" = xyes; then
+    echo "Downloading and updating: ${REMOTE_SQL_SCRIPTS}"
+    echo ${CURL_ARGS} | xargs curl -L -s
+  fi
 
+  psql -c "CREATE EXTENSION IF NOT EXISTS plpythonu;" ${TEST_DB}
+  ALL_SQL_SCRIPTS="${REMOTE_SQL_SCRIPTS} ${LOCAL_SQL_SCRIPTS}"
+  for i in ${ALL_SQL_SCRIPTS}
+  do
+    cat sql/${i}.sql |
+      sed -e 's/cartodb\./public./g' -e "s/''cartodb''/''public''/g" |
+      sed "s/:PUBLICUSER/${PUBLICUSER}/" |
+      sed "s/:PUBLICPASS/${PUBLICPASS}/" |
+      sed "s/:TESTUSER/${TESTUSER}/" |
+      sed "s/:TESTPASS/${TESTPASS}/" |
+      PGOPTIONS='--client-min-messages=WARNING' psql -q -v ON_ERROR_STOP=1 ${TEST_DB} > /dev/null || exit 1
+  done
 fi
 
 if test x"$PREPARE_REDIS" = xyes; then
@@ -122,17 +131,3 @@ EOF
 fi
 
 echo "Finished preparing data. Ready to run tests"
-
-
-############################ WINDSHAFT TESTS ############################
-
-echo "...Configuring Windshaft test database"
-
-cat sql/ported/populated_places_simple_reduced.sql |
-    sed "s/:PUBLICUSER/${PUBLICUSER}/" |
-    sed "s/:PUBLICPASS/${PUBLICPASS}/" |
-    sed "s/:TESTUSER/${TESTUSER}/" |
-    sed "s/:TESTPASS/${TESTPASS}/" |
-    psql -v ON_ERROR_STOP=1 ${TEST_DB} || exit 1
-
-echo "...Test database configuration complete"

test/support/sql/_CDB_QueryStatements.sql

@@ -1,16 +0,0 @@
--- DUMMY IMPLEMENTATION
--- Ref: https://github.com/CartoDB/cartodb-postgresql/blob/master/scripts-available/CDB_QueryStatements.sql
--- Originally implemented in plpython for performance reasons
-
--- Return an array of statements found in the given query text
---
--- Regexp curtesy of Hubert Lubaczewski (depesz)
---
-CREATE OR REPLACE FUNCTION CDB_QueryStatements(query text)
-RETURNS SETOF TEXT AS $$
-  with matches as (
-    select regexp_matches($1, $regexp$((?:[^'"$;]+|"[^"]*"|'[^']*'|(\$[^$]*\$).*?\2)+)$regexp$, 'g') as m
-  )
-  select btrim(m[1]) from matches
-$$
-LANGUAGE SQL IMMUTABLE STRICT;

test/support/sql/windshaft.test.sql

@@ -247,8 +247,10 @@ CREATE TABLE test_table_overviews (
     cartodb_id integer NOT NULL,
     name character varying,
     address character varying,
+    value float8,
     the_geom geometry,
     the_geom_webmercator geometry,
+    _feature_count integer,
     CONSTRAINT enforce_dims_the_geom CHECK ((st_ndims(the_geom) = 2)),
     CONSTRAINT enforce_dims_the_geom_webmercator CHECK ((st_ndims(the_geom_webmercator) = 2)),
     CONSTRAINT enforce_geotype_the_geom CHECK (((geometrytype(the_geom) = 'POINT'::text) OR (the_geom IS NULL))),
@@ -274,11 +276,11 @@ SELECT pg_catalog.setval('test_table_overviews_cartodb_id_seq', 60, true);
 ALTER TABLE test_table_overviews ALTER COLUMN cartodb_id SET DEFAULT nextval('test_table_overviews_cartodb_id_seq'::regclass);
 
 INSERT INTO test_table_overviews VALUES
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.314252', 1, 'Hawai', 'Calle de Pérez Galdós 9, Madrid, Spain', '0101000020E6100000A6B73F170D990DC064E8D84125364440', '0101000020110F000076491621312319C122D4663F1DCC5241'),
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.319101', 2, 'El Estocolmo', 'Calle de la Palma 72, Madrid, Spain', '0101000020E6100000C90567F0F7AB0DC0AB07CC43A6364440', '0101000020110F0000C4356B29423319C15DD1092DADCC5241'),
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.324', 3, 'El Rey del Tallarín', 'Plaza Conde de Toreno 2, Madrid, Spain', '0101000020E610000021C8410933AD0DC0CB0EF10F5B364440', '0101000020110F000053E71AC64D3419C10F664E4659CC5241'),
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.329509', 4, 'El Lacón', 'Manuel Fernández y González 8, Madrid, Spain', '0101000020E6100000BC5983F755990DC07D923B6C22354440', '0101000020110F00005DACDB056F2319C1EC41A980FCCA5241'),
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.334931', 5, 'El Pico', 'Calle Divino Pastor 12, Madrid, Spain', '0101000020E61000003B6D8D08C6A10DC0371B2B31CF364440', '0101000020110F00005F716E91992A19C17DAAA4D6DACC5241');
+('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.314252', 1, 'Hawai', 'Calle de Pérez Galdós 9, Madrid, Spain', 1.0, '0101000020E6100000A6B73F170D990DC064E8D84125364440', '0101000020110F000076491621312319C122D4663F1DCC5241', 1),
+('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.319101', 2, 'El Estocolmo', 'Calle de la Palma 72, Madrid, Spain', 2.0, '0101000020E6100000C90567F0F7AB0DC0AB07CC43A6364440', '0101000020110F0000C4356B29423319C15DD1092DADCC5241', 1),
+('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.324', 3, 'El Rey del Tallarín', 'Plaza Conde de Toreno 2, Madrid, Spain', 3.0, '0101000020E610000021C8410933AD0DC0CB0EF10F5B364440', '0101000020110F000053E71AC64D3419C10F664E4659CC5241', 1),
+('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.329509', 4, 'El Lacón', 'Manuel Fernández y González 8, Madrid, Spain', 4.0, '0101000020E6100000BC5983F755990DC07D923B6C22354440', '0101000020110F00005DACDB056F2319C1EC41A980FCCA5241', 1),
+('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.334931', 5, 'El Pico', 'Calle Divino Pastor 12, Madrid, Spain', 5.0, '0101000020E61000003B6D8D08C6A10DC0371B2B31CF364440', '0101000020110F00005F716E91992A19C17DAAA4D6DACC5241', 1);
 
 ALTER TABLE ONLY test_table_overviews ADD CONSTRAINT test_table_overviews_pkey PRIMARY KEY (cartodb_id);
 
@@ -294,8 +296,10 @@ CREATE TABLE _vovw_1_test_table_overviews (
     cartodb_id integer NOT NULL,
     name character varying,
     address character varying,
+    value float8,
     the_geom geometry,
     the_geom_webmercator geometry,
+    _feature_count integer,
     CONSTRAINT enforce_dims_the_geom CHECK ((st_ndims(the_geom) = 2)),
     CONSTRAINT enforce_dims_the_geom_webmercator CHECK ((st_ndims(the_geom_webmercator) = 2)),
     CONSTRAINT enforce_geotype_the_geom CHECK (((geometrytype(the_geom) = 'POINT'::text) OR (the_geom IS NULL))),
@@ -313,8 +317,10 @@ CREATE TABLE _vovw_2_test_table_overviews (
     cartodb_id integer NOT NULL,
     name character varying,
     address character varying,
+    value float8,
     the_geom geometry,
     the_geom_webmercator geometry,
+    _feature_count integer,
     CONSTRAINT enforce_dims_the_geom CHECK ((st_ndims(the_geom) = 2)),
     CONSTRAINT enforce_dims_the_geom_webmercator CHECK ((st_ndims(the_geom_webmercator) = 2)),
     CONSTRAINT enforce_geotype_the_geom CHECK (((geometrytype(the_geom) = 'POINT'::text) OR (the_geom IS NULL))),
@@ -327,11 +333,11 @@ GRANT ALL ON TABLE _vovw_2_test_table_overviews TO :TESTUSER;
 GRANT SELECT ON TABLE _vovw_2_test_table_overviews TO :PUBLICUSER;
 
 INSERT INTO _vovw_2_test_table_overviews VALUES
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.314252', 1, 'Hawai', 'Calle de Pérez Galdós 9, Madrid, Spain', '0101000020E610000000000000000020C00000000000004440', '0101000020110F000076491621312319C122D4663F1DCC5241'),
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.319101', 2, 'El Estocolmo', 'Calle de la Palma 72, Madrid, Spain', '0101000020E610000000000000009431C026043C75E7224340', '0101000020110F0000C4356B29423319C15DD1092DADCC5241');
+('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.314252', 1, 'Hawai', 'Calle de Pérez Galdós 9, Madrid, Spain', 8.0/3.0, '0101000020E610000000000000000020C00000000000004440', '0101000020110F000076491621312319C122D4663F1DCC5241', 3),
+('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.319101', 2, 'El Estocolmo', 'Calle de la Palma 72, Madrid, Spain', 7.0/2.0, '0101000020E610000000000000009431C026043C75E7224340', '0101000020110F0000C4356B29423319C15DD1092DADCC5241', 2);
 
 INSERT INTO _vovw_1_test_table_overviews VALUES
-('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.314252', 1, 'Hawai', 'Calle de Pérez Galdós 9, Madrid, Spain', '0101000020E610000000000000000020C00000000000004440', '0101000020110F000076491621312319C122D4663F1DCC5241');
+('2011-09-21 14:02:21.358706', '2011-09-21 14:02:21.314252', 1, 'Hawai', 'Calle de Pérez Galdós 9, Madrid, Spain', 3.0, '0101000020E610000000000000000020C00000000000004440', '0101000020110F000076491621312319C122D4663F1DCC5241', 5);
 
 
 -- analysis tables -----------------------------------------------

test/support/test-client.js

@@ -6,7 +6,7 @@ var urlParser = require('url');
 
 var mapnik = require('windshaft').mapnik;
 
-var LayergroupToken = require('../../lib/cartodb/models/layergroup_token');
+var LayergroupToken = require('./layergroup-token');
 
 var assert = require('./assert');
 var helper = require('./test_helper');
@@ -24,6 +24,15 @@ function TestClient(mapConfig, apiKey) {
 
 module.exports = TestClient;
 
+module.exports.RESPONSE = {
+    ERROR: {
+        status: 400,
+        headers: {
+            'Content-Type': 'application/json; charset=utf-8'
+        }
+    }
+};
+
 TestClient.prototype.getWidget = function(widgetName, params, callback) {
     var self = this;
 
@@ -62,6 +71,7 @@ TestClient.prototype.getWidget = function(widgetName, params, callback) {
                         return next(err);
                     }
                     var parsedBody = JSON.parse(res.body);
+
                     var expectedWidgetURLS = {
                         http: "/api/v1/map/" + parsedBody.layergroupid + "/0/widget/" + widgetName
                     };
@@ -69,6 +79,15 @@ TestClient.prototype.getWidget = function(widgetName, params, callback) {
                     assert.ok(
                         parsedBody.metadata.layers[0].widgets[widgetName].url.http.match(expectedWidgetURLS.http)
                     );
+
+                    var expectedDataviewsURLS = {
+                        http: "/api/v1/map/" + parsedBody.layergroupid + "/dataview/" + widgetName
+                    };
+                    assert.ok(parsedBody.metadata.dataviews[widgetName]);
+                    assert.ok(
+                        parsedBody.metadata.dataviews[widgetName].url.http.match(expectedDataviewsURLS.http)
+                    );
+
                     return next(null, parsedBody.layergroupid);
                 }
             );
@@ -82,9 +101,12 @@ TestClient.prototype.getWidget = function(widgetName, params, callback) {
             var urlParams = {
                 own_filter: params.hasOwnProperty('own_filter') ? params.own_filter : 1
             };
-            if (params && params.bbox) {
-                urlParams.bbox = params.bbox;
-            }
+            ['bbox', 'bins', 'start', 'end'].forEach(function(extraParam) {
+                if (params.hasOwnProperty(extraParam)) {
+                    urlParams[extraParam] = params[extraParam];
+                }
+            });
+
             url = '/api/v1/map/' + layergroupId + '/0/widget/' + widgetName + '?' + qs.stringify(urlParams);
 
             assert.response(server,
@@ -113,7 +135,120 @@ TestClient.prototype.getWidget = function(widgetName, params, callback) {
         function finish(err, res) {
             self.keysToDelete['map_cfg|' + LayergroupToken.parse(layergroupId).token] = 0;
             self.keysToDelete['user:localhost:mapviews:global'] = 5;
-            return callback(err, res);
+            var widget;
+            if (!err && res.body) {
+                widget = JSON.parse(res.body);
+            }
+            return callback(err, res, widget);
+        }
+    );
+};
+
+TestClient.prototype.widgetSearch = function(widgetName, userQuery, params, callback) {
+    var self = this;
+
+    if (!callback) {
+        callback = params;
+        params = {};
+    }
+
+    var url = '/api/v1/map';
+    if (params && params.filters) {
+        url += '?' + qs.stringify({ filters: JSON.stringify(params.filters) });
+    }
+
+    var layergroupId;
+    step(
+        function createLayergroup() {
+            var next = this;
+            assert.response(server,
+                {
+                    url: url,
+                    method: 'POST',
+                    headers: {
+                        host: 'localhost',
+                        'Content-Type': 'application/json'
+                    },
+                    data: JSON.stringify(self.mapConfig)
+                },
+                {
+                    status: 200,
+                    headers: {
+                        'Content-Type': 'application/json; charset=utf-8'
+                    }
+                },
+                function(res, err) {
+                    if (err) {
+                        return next(err);
+                    }
+                    var parsedBody = JSON.parse(res.body);
+
+                    var expectedWidgetURLS = {
+                        http: "/api/v1/map/" + parsedBody.layergroupid + "/0/widget/" + widgetName
+                    };
+                    assert.ok(parsedBody.metadata.layers[0].widgets[widgetName]);
+                    assert.ok(
+                        parsedBody.metadata.layers[0].widgets[widgetName].url.http.match(expectedWidgetURLS.http)
+                    );
+
+                    var expectedDataviewsURLS = {
+                        http: "/api/v1/map/" + parsedBody.layergroupid + "/dataview/" + widgetName
+                    };
+                    assert.ok(parsedBody.metadata.dataviews[widgetName]);
+                    assert.ok(
+                        parsedBody.metadata.dataviews[widgetName].url.http.match(expectedDataviewsURLS.http)
+                    );
+
+                    return next(null, parsedBody.layergroupid);
+                }
+            );
+        },
+        function getWidgetSearchResult(err, _layergroupId) {
+            assert.ifError(err);
+
+            var next = this;
+            layergroupId = _layergroupId;
+
+            var urlParams = {
+                q: userQuery,
+                own_filter: params.hasOwnProperty('own_filter') ? params.own_filter : 1
+            };
+            if (params && params.bbox) {
+                urlParams.bbox = params.bbox;
+            }
+            url = '/api/v1/map/' + layergroupId + '/0/widget/' + widgetName + '/search?' + qs.stringify(urlParams);
+
+            assert.response(server,
+                {
+                    url: url,
+                    method: 'GET',
+                    headers: {
+                        host: 'localhost'
+                    }
+                },
+                {
+                    status: 200,
+                    headers: {
+                        'Content-Type': 'application/json; charset=utf-8'
+                    }
+                },
+                function(res, err) {
+                    if (err) {
+                        return next(err);
+                    }
+
+                    next(null, res);
+                }
+            );
+        },
+        function finish(err, res) {
+            self.keysToDelete['map_cfg|' + LayergroupToken.parse(layergroupId).token] = 0;
+            self.keysToDelete['user:localhost:mapviews:global'] = 5;
+            var searchResult;
+            if (!err && res.body) {
+                searchResult = JSON.parse(res.body);
+            }
+            return callback(err, res, searchResult);
         }
     );
 };
@@ -184,9 +319,13 @@ TestClient.prototype.getDataview = function(dataviewName, params, callback) {
             var urlParams = {
                 own_filter: params.hasOwnProperty('own_filter') ? params.own_filter : 1
             };
-            if (params && params.bbox) {
-                urlParams.bbox = params.bbox;
-            }
+
+            ['bbox', 'bins', 'start', 'end'].forEach(function(extraParam) {
+                if (params.hasOwnProperty(extraParam)) {
+                    urlParams[extraParam] = params[extraParam];
+                }
+            });
+
             if (self.apiKey) {
                 urlParams.api_key = self.apiKey;
             }
@@ -215,10 +354,10 @@ TestClient.prototype.getDataview = function(dataviewName, params, callback) {
                 }
             );
         },
-        function finish(err, res) {
+        function finish(err, dataview) {
             self.keysToDelete['map_cfg|' + LayergroupToken.parse(layergroupId).token] = 0;
             self.keysToDelete['user:localhost:mapviews:global'] = 5;
-            return callback(err, res);
+            return callback(err, dataview);
         }
     );
 };