Release 2.84.2

Merge pull request #596 from CartoDB/upgrade-camshaft-to-0.48.3
Upgrade Camshaft version to 0.48.3
2016-11-23 15:09:24 +01:00 · 2016-11-23 15:05:43 +01:00 · 2016-11-23 13:17:16 +01:00 · 2016-11-23 11:57:05 +01:00 · 2016-11-23 11:53:37 +01:00 · 2016-11-23 11:50:45 +01:00
108 changed files with 7779 additions and 2049 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,16 +1,17 @@
-sudo: false
-
+dist: trusty # only environment that supports Postgres 9.5 at this time
+sudo: required
 addons:
-  postgresql: "9.3"
+  postgresql: "9.5"
  apt:
    packages:
+      - postgresql-plpython-9.5
      - pkg-config
      - libcairo2-dev
      - libjpeg8-dev
      - libgif-dev
+      - libpango1.0-dev

 before_install:
-  - npm install -g npm@2
  - createdb template_postgis
  - createuser publicuser
  - psql -c "CREATE EXTENSION postgis" template_postgis
--- a/2
+++ b/2
@@ -1,5 +1,5 @@
 1. Test (make clean all check), fix if broken before proceeding
-2. Ensure proper version in package.json 
+2. Ensure proper version in package.json
 3. Ensure NEWS section exists for the new version, review it, add release date
 4. Recreate npm-shrinkwrap.json with: `npm install --no-shrinkwrap && npm shrinkwrap`
 5. Commit package.json, npm-shrinwrap.json, NEWS
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,5 +1,586 @@
 # Changelog

+## 2.84.2
+Released 2016-11-23
+Announcements:
+ - Upgrades camshaft to [0.48.3](https://github.com/CartoDB/camshaft/releases/tag/0.48.3).
+
+
+## 2.84.1
+Released 2016-11-23
+
+Announcements:
+ - Upgrades camshaft to [0.48.2](https://github.com/CartoDB/camshaft/releases/tag/0.48.2).
+
+
+## 2.84.0
+Released 2016-11-11
+
+New features:
+ - Analyses limit configuration allows to set other limits than timeout.
+
+
+## 2.83.1
+Released 2016-11-10
+
+Announcements:
+ - Upgrades camshaft to [0.48.1](https://github.com/CartoDB/camshaft/releases/tag/0.48.1).
+
+
+## 2.83.0
+Released 2016-11-10
+
+Announcements:
+ - Upgrades camshaft to [0.48.0](https://github.com/CartoDB/camshaft/releases/tag/0.48.0).
+
+
+## 2.82.0
+Released 2016-11-08
+
+Announcements:
+ - Upgrades camshaft to [0.47.0](https://github.com/CartoDB/camshaft/releases/tag/0.47.0).
+
+
+## 2.81.1
+Released 2016-11-05
+
+Announcements:
+ - Upgrades windshaft to [2.6.2](https://github.com/CartoDB/windshaft/releases/tag/2.6.2).
+ - Upgrades camshaft to [0.46.3](https://github.com/CartoDB/camshaft/releases/tag/0.46.3).
+
+
+## 2.81.0
+Released 2016-11-02
+
+Enhancements:
+ - Returns errors with context when query layer does not retrieve geometry column
+
+Announcements:
+ - Upgrades windshaft to [2.6.1](https://github.com/CartoDB/windshaft/releases/tag/2.6.1).
+ - Upgrades camshaft to [0.46.2](https://github.com/CartoDB/camshaft/releases/tag/0.46.2).
+
+
+## 2.80.2
+Released 2016-10-26
+
+Bug fixes:
+ - Fix order in categories query to get ramps
+
+
+## 2.80.1
+Released 2016-10-25
+
+Announcements:
+ - Upgrades camshaft to [0.46.1](https://github.com/CartoDB/camshaft/releases/tag/0.46.1).
+
+
+## 2.80.0
+Released 2016-10-20
+
+Announcements:
+ - Upgrades camshaft to [0.46.0](https://github.com/CartoDB/camshaft/releases/tag/0.46.0).
+
+New features:
+ - Default analyses limits can be defined in configuration.
+
+
+## 2.79.0
+Released 2016-10-11
+
+New features:
+ - Retrieve analysis limits and pass them into camshaft.
+
+Announcements:
+ - Upgrades turbo-carto to [0.18.0](https://github.com/CartoDB/turbo-carto/releases/tag/0.18.0).
+ - Upgrades camshaft to [0.45.0](https://github.com/CartoDB/camshaft/releases/tag/0.45.0).
+
+
+## 2.78.1
+Released 2016-09-30
+
+Announcements:
+ - Upgrades camshaft to [0.44.2](https://github.com/CartoDB/camshaft/releases/tag/0.44.2).
+
+
+## 2.78.0
+Released 2016-09-29
+
+New features:
+ - Add metadata about processed turbo-carto rules.
+
+Announcements:
+ - Upgrades turbo-carto to [0.17.1](https://github.com/CartoDB/turbo-carto/releases/tag/0.17.1).
+
+
+## 2.77.1
+
+Released 2016-09-28
+
+Announcements:
+ - Upgrades camshaft to [0.44.1](https://github.com/CartoDB/camshaft/releases/tag/0.44.1).
+
+
+## 2.77.0
+
+Released 2016-09-26
+
+Announcements:
+ - Upgrades camshaft to [0.44.0](https://github.com/CartoDB/camshaft/releases/tag/0.44.0).
+ - Adds a new configuration for camshaft: logger stream.
+
+
+## 2.76.0
+
+Released 2016-09-15
+
+New features:
+ - Allow to use `--config /path/to/config.js` to specify configuration file.
+   - Environment will be loaded from config file if `environment` key is present, otherwise it keeps current behaviour.
+
+Bug fixes:
+ - Allow to use absolute paths for log files #570.
+
+
+## 2.75.0
+
+Released 2016-09-14
+
+Announcements:
+ - Upgrades camshaft to [0.43.0](https://github.com/CartoDB/camshaft/releases/tag/0.43.0).
+
+
+## 2.74.1
+
+Released 2016-09-07
+
+Announcements:
+ - Upgrades camshaft to [0.42.1](https://github.com/CartoDB/camshaft/releases/tag/0.42.1).
+
+
+## 2.74.0
+
+Released 2016-09-06
+
+Enhancements:
+ - Layers in previews can be shown or hidden using `preview_layers` property in template map
+
+
+## 2.73.1
+
+Released 2016-09-06
+
+Bug fixes:
+ - Fixes missing column in fixture table `cdb_analysis_catalog`.
+
+
+## 2.73.0
+
+Released 2016-09-06
+
+Announcements:
+ - Upgrades camshaft to [0.42.0](https://github.com/CartoDB/camshaft/releases/tag/0.42.0).
+
+
+## 2.72.0
+
+Released 2016-08-23
+
+Announcements:
+ - Upgrades camshaft to [0.41.0](https://github.com/CartoDB/camshaft/releases/tag/0.41.0).
+
+
+## 2.71.0
+
+Released 2016-08-17
+
+Announcements:
+ - Upgrades windshaft to [2.5.0](https://github.com/CartoDB/windshaft/releases/tag/2.5.0).
+
+
+## 2.70.0
+
+Released 2016-08-16
+
+Announcements:
+ - Upgrades camshaft to [0.40.0](https://github.com/CartoDB/camshaft/releases/tag/0.40.0).
+
+
+## 2.69.1
+
+Released 2016-08-12
+
+Announcements:
+ - Upgrades windshaft to [2.4.2](https://github.com/CartoDB/windshaft/releases/tag/2.4.2).
+
+
+## 2.69.0
+
+Released 2016-08-11
+
+Announcements:
+ - Upgrades camshaft to [0.39.0](https://github.com/CartoDB/camshaft/releases/tag/0.39.0).
+
+
+## 2.68.0
+
+Released 2016-07-21
+
+Announcements:
+ - Upgrades turbo-carto to [0.16.0](https://github.com/CartoDB/turbo-carto/releases/tag/0.16.0).
+
+
+## 2.67.1
+
+Released 2016-07-21
+
+Announcements:
+ - Upgrades camshaft to [0.38.1](https://github.com/CartoDB/camshaft/releases/tag/0.38.1).
+
+
+## 2.67.0
+
+Released 2016-07-21
+
+Announcements:
+ - Upgrades camshaft to [0.38.0](https://github.com/CartoDB/camshaft/releases/tag/0.38.0).
+
+
+## 2.66.2
+
+Released 2016-07-20
+
+Announcements:
+ - Upgrades turbo-carto to [0.15.1](https://github.com/CartoDB/turbo-carto/releases/tag/0.15.1).
+
+
+## 2.66.1
+
+Released 2016-07-20
+
+Announcements:
+ - Upgrades turbo-carto to [0.15.0](https://github.com/CartoDB/turbo-carto/releases/tag/0.15.0).
+
+
+## 2.66.0
+
+Released 2016-07-18
+
+Announcements:
+ - Available new endpoint to check user analyses.
+ - Upgrades camshaft to [0.37.1](https://github.com/CartoDB/camshaft/releases/tag/0.37.1).
+
+
+## 2.65.0
+
+Released 2016-07-15
+
+Announcements:
+ - Upgrades cartodb-redis to 0.13.1.
+ - Upgrades camshaft to [0.37.0](https://github.com/CartoDB/camshaft/releases/tag/0.37.0).
+
+
+## 2.64.0
+
+Released 2016-07-12
+
+Announcements:
+ - Upgrades camshaft to [0.36.0](https://github.com/CartoDB/camshaft/releases/tag/0.36.0).
+
+
+## 2.63.0
+
+Released 2016-07-11
+
+Enhancements:
+ - Return last error message for failed nodes on map creation.
+
+Announcements:
+ - Upgrades camshaft to [0.35.0](https://github.com/CartoDB/camshaft/releases/tag/0.35.0).
+ - Upgrades lzma to 2.3.2.
+
+
+## 2.62.0
+
+Released 2016-07-07
+
+Announcements:
+ - Upgrades camshaft to [0.34.0](https://github.com/CartoDB/camshaft/releases/tag/0.34.0).
+
+
+## 2.61.2
+
+Released 2016-07-07
+
+Announcements:
+ - Limit analysis creation concurrency.
+ - Upgrades camshaft to [0.33.3](https://github.com/CartoDB/camshaft/releases/tag/0.33.3).
+
+
+## 2.61.1
+
+Released 2016-07-06
+
+Enhancements:
+ - Dataviews use mapconfig to store/retrieve their queries instead of instantiating analyses again.
+
+
+## 2.61.0
+
+Released 2016-07-06
+
+Enhancements:
+ - More clear turbo-carto error messages: no context in message.
+ - Return multiple turbo-carto errors #541.
+
+Announcements:
+ - Upgrades turbo-carto to [0.14.0](https://github.com/CartoDB/turbo-carto/releases/tag/0.14.0).
+ - Upgrades camshaft to [0.33.2](https://github.com/CartoDB/camshaft/releases/tag/0.33.2).
+
+
+## 2.60.0
+
+Released 2016-07-05
+
+Announcements:
+ - Upgrades camshaft to [0.32.0](https://github.com/CartoDB/camshaft/releases/tag/0.32.0).
+
+
+## 2.59.1
+
+Released 2016-07-05
+
+Announcements:
+ - Upgrades camshaft to [0.31.0](https://github.com/CartoDB/camshaft/releases/tag/0.31.0).
+
+
+## 2.59.0
+
+Released 2016-07-05
+
+Announcements:
+ - Upgrades camshaft to [0.30.0](https://github.com/CartoDB/camshaft/releases/tag/0.30.0).
+
+
+## 2.58.0
+
+Released 2016-07-05
+
+Announcements:
+ - Upgrades camshaft to [0.29.2](https://github.com/CartoDB/camshaft/releases/tag/0.29.2).
+
+Bug fixes:
+ - Return full list of nodes in response metadata.
+
+
+## 2.57.0
+
+Released 2016-07-04
+
+Announcements:
+ - Upgrades camshaft to [0.28.1](https://github.com/CartoDB/camshaft/releases/tag/0.28.1).
+
+
+## 2.56.0
+
+Released 2016-07-04
+
+Announcements:
+ - Upgrades camshaft to [0.27.0](https://github.com/CartoDB/camshaft/releases/tag/0.27.0).
+
+
+## 2.55.0
+
+Released 2016-07-04
+
+Enhancements:
+ - Skip null values for quantification methods generating null values.
+
+Announcements:
+ - Uses new configuration for camshaft: analysis node has an associated user/owner.
+ - Upgrades camshaft to [0.26.0](https://github.com/CartoDB/camshaft/releases/tag/0.26.0).
+
+
+## 2.54.0
+
+Released 2016-06-30
+
+Improvements:
+ - Errors with context: replaced `turbo-carto` error type by `layer` type.
+
+Announcements:
+ - Upgrades camshaft to [0.23.0](https://github.com/CartoDB/camshaft/releases/tag/0.23.0)
+
+
+## 2.53.5
+
+Released 2016-06-29
+
+Bug fixes:
+ - Uses node list so identical nodes are not de-duplicated and can be used with different ids #528.
+
+
+## 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
+ - Responses with error now return the layer-id to give more info to the user.
+
+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
--- a/app.js
+++ b/app.js
@@ -5,20 +5,35 @@ var fs = require('fs');

 var _ = require('underscore');

-var ENVIRONMENT;
-if ( process.argv[2] ) {
-    ENVIRONMENT = process.argv[2];
-} else if ( process.env.NODE_ENV ) {
-    ENVIRONMENT = process.env.NODE_ENV;
-} else {
-    ENVIRONMENT = 'development';
-}
-
 // jshint undef:false
 var log = console.log.bind(console);
 var logError = console.error.bind(console);
 // jshint undef:true

+var argv = require('yargs')
+    .usage('Usage: $0 <environment> [options]')
+    .help('h')
+    .example(
+    '$0 production -c /etc/sql-api/config.js',
+    'start server in production environment with /etc/sql-api/config.js as config file'
+)
+    .alias('h', 'help')
+    .alias('c', 'config')
+    .nargs('c', 1)
+    .describe('c', 'Load configuration from path')
+    .argv;
+
+var environmentArg = argv._[0] || process.env.NODE_ENV || 'development';
+var configurationFile = path.resolve(argv.config || './config/environments/' + environmentArg + '.js');
+if (!fs.existsSync(configurationFile)) {
+    logError('Configuration file "%s" does not exist', configurationFile);
+    process.exit(1);
+}
+
+global.environment = require(configurationFile);
+var ENVIRONMENT = argv._[0] || process.env.NODE_ENV || global.environment.environment;
+process.env.NODE_ENV = ENVIRONMENT;
+
 var availableEnvironments = {
    production: true,
    staging: true,
@@ -33,16 +48,6 @@ if (!availableEnvironments[ENVIRONMENT]){
 }

 process.env.NODE_ENV = ENVIRONMENT;
-
-// set environment specific variables
-global.environment = require('./config/environments/' + ENVIRONMENT);
-
-global.log4js = require('log4js');
-var log4js_config = {
-  appenders: [],
-  replaceConsole: true
-};
-
 if (global.environment.uv_threadpool_size) {
    process.env.UV_THREADPOOL_SIZE = global.environment.uv_threadpool_size;
 }
@@ -58,25 +63,31 @@ var agentOptions = _.defaults(global.environment.httpAgent || {}, {
 http.globalAgent = new http.Agent(agentOptions);
 https.globalAgent = new https.Agent(agentOptions);

+
+global.log4js = require('log4js');
+var log4jsConfig = {
+    appenders: [],
+    replaceConsole: true
+};
+
 if ( global.environment.log_filename ) {
-  var logdir = path.dirname(global.environment.log_filename);
-  // See cwd inlog4js.configure call below
-  logdir = path.resolve(__dirname, logdir);
-  if ( ! fs.existsSync(logdir) ) {
-    logError("Log filename directory does not exist: " + logdir);
-    process.exit(1);
-  }
-  log("Logs will be written to " + global.environment.log_filename);
-  log4js_config.appenders.push(
-    { type: "file", filename: global.environment.log_filename }
-  );
+    var logFilename = path.resolve(global.environment.log_filename);
+    var logDirectory = path.dirname(logFilename);
+    if (!fs.existsSync(logDirectory)) {
+        logError("Log filename directory does not exist: " + logDirectory);
+        process.exit(1);
+    }
+    log("Logs will be written to " + logFilename);
+    log4jsConfig.appenders.push(
+        { type: "file", absolute: true, filename: logFilename }
+    );
 } else {
-  log4js_config.appenders.push(
-    { type: "console", layout: { type:'basic' } }
-  );
+    log4jsConfig.appenders.push(
+        { type: "console", layout: { type:'basic' } }
+    );
 }

-global.log4js.configure(log4js_config, { cwd: __dirname });
+global.log4js.configure(log4jsConfig);
 global.logger = global.log4js.getLogger();

 global.environment.api_hostname = require('os').hostname().split('.')[0];
@@ -99,6 +110,7 @@ var listener = server.listen(serverOptions.bind.port, serverOptions.bind.host, b
 var version = require("./package").version;

 listener.on('listening', function() {
+    log('Using configuration file "%s"', configurationFile);
    log(
        "Windshaft tileserver %s started on %s:%s PID=%d (%s)",
        version, serverOptions.bind.host, serverOptions.bind.port, process.pid, ENVIRONMENT
@@ -114,7 +126,7 @@ setInterval(function() {

 process.on('SIGHUP', function() {
    global.log4js.clearAndShutdownAppenders(function() {
-        global.log4js.configure(log4js_config);
+        global.log4js.configure(log4jsConfig);
        global.logger = global.log4js.getLogger();
        log('Log files reloaded');
    });
--- a/config/environments/development.js.example
+++ b/config/environments/development.js.example
@@ -62,6 +62,7 @@ var config = {
        extent: "-180,-90,180,90",
        srid: 4326,
        */
+        // max number of rows to return when querying data, 0 means no limit
        row_limit: 65535,
        simplify_geometries: true,
        use_overviews: true, // use overviews to retrieve raster
@@ -209,6 +210,18 @@ var config = {
            endpoint: 'http://127.0.0.1:8080/api/v2/sql/job',
            // the template to use for adding the host header in the batch api requests
            hostHeaderTemplate: '{{=it.username}}.localhost.lan'
+        },
+        logger: {
+            // If filename is given logs comming from analysis client  will be written
+            // there, in append mode. Otherwise 'log_filename' is used. Otherwise stdout is used (default).
+            // Log file will be re-opened on receiving the HUP signal
+            filename: '/tmp/analysis.log'
+        },
+        // Define max execution time in ms for analyses or tags
+        // If analysis or tag are not found in redis this values will be used as default.
+        limits: {
+            moran: { timeout: 120000, maxNumberOfRows: 1e5 },
+            cpu2x: { timeout: 60000 }
        }
    }
    ,millstone: {
--- a/config/environments/production.js.example
+++ b/config/environments/production.js.example
@@ -56,6 +56,7 @@ var config = {
        host: '127.0.0.1',
        port: 6432,
        extent: "-20037508.3,-20037508.3,20037508.3,20037508.3",
+        // max number of rows to return when querying data, 0 means no limit
        row_limit: 65535,
        /*
         * Set persist_connection to false if you want
@@ -203,6 +204,18 @@ var config = {
            endpoint: 'http://127.0.0.1:8080/api/v2/sql/job',
            // the template to use for adding the host header in the batch api requests
            hostHeaderTemplate: '{{=it.username}}.localhost.lan'
+        },
+        logger: {
+            // If filename is given logs comming from analysis client  will be written
+            // there, in append mode. Otherwise 'log_filename' is used. Otherwise stdout is used (default).
+            // Log file will be re-opened on receiving the HUP signal
+            filename: 'logs/analysis.log'
+        },
+        // Define max execution time in ms for analyses or tags
+        // If analysis or tag are not found in redis this values will be used as default.
+        limits: {
+            moran: { timeout: 120000, maxNumberOfRows: 1e5 },
+            cpu2x: { timeout: 60000 }
        }
    }
    ,millstone: {
--- a/config/environments/staging.js.example
+++ b/config/environments/staging.js.example
@@ -56,6 +56,7 @@ var config = {
        host: '127.0.0.1',
        port: 6432,
        extent: "-20037508.3,-20037508.3,20037508.3,20037508.3",
+        // max number of rows to return when querying data, 0 means no limit
        row_limit: 65535,
        simplify_geometries: true,
        use_overviews: true, // use overviews to retrieve raster
@@ -203,6 +204,18 @@ var config = {
            endpoint: 'http://127.0.0.1:8080/api/v2/sql/job',
            // the template to use for adding the host header in the batch api requests
            hostHeaderTemplate: '{{=it.username}}.localhost.lan'
+        },
+        logger: {
+            // If filename is given logs comming from analysis client  will be written
+            // there, in append mode. Otherwise 'log_filename' is used. Otherwise stdout is used (default).
+            // Log file will be re-opened on receiving the HUP signal
+            filename: 'logs/analysis.log'
+        },
+        // Define max execution time in ms for analyses or tags
+        // If analysis or tag are not found in redis this values will be used as default.
+        limits: {
+            moran: { timeout: 120000, maxNumberOfRows: 1e5 },
+            cpu2x: { timeout: 60000 }
        }
    }
    ,millstone: {
--- a/config/environments/test.js.example
+++ b/config/environments/test.js.example
@@ -56,6 +56,7 @@ var config = {
        host: '127.0.0.1',
        port: 5432,
        extent: "-20037508.3,-20037508.3,20037508.3,20037508.3",
+        // max number of rows to return when querying data, 0 means no limit
        row_limit: 65535,
        simplify_geometries: true,
        use_overviews: true, // use overviews to retrieve raster
@@ -204,6 +205,18 @@ var config = {
            endpoint: 'http://127.0.0.1:8080/api/v2/sql/job',
            // the template to use for adding the host header in the batch api requests
            hostHeaderTemplate: '{{=it.username}}.localhost.lan'
+        },
+        logger: {
+            // If filename is given logs comming from analysis client  will be written
+            // there, in append mode. Otherwise 'log_filename' is used. Otherwise stdout is used (default).
+            // Log file will be re-opened on receiving the HUP signal
+            filename: 'node-windshaft.log'
+        },
+        // Define max execution time in ms for analyses or tags
+        // If analysis or tag are not found in redis this values will be used as default.
+        limits: {
+            moran: { timeout: 120000, maxNumberOfRows: 1e5 },
+            cpu2x: { timeout: 60000 }
        }
    }
    ,millstone: {
--- a/docs/Map-API.md
+++ b/docs/Map-API.md
@@ -1,11 +1,11 @@
 # Maps API

-The CartoDB Maps API allows you to generate maps based on data hosted in your CartoDB account and apply custom SQL and CartoCSS to the data. The API generates a XYZ-based URL to fetch Web Mercator projected tiles, using web clients such as [Leaflet](http://leafletjs.com), [Google Maps](https://developers.google.com/maps/), or [OpenLayers](http://openlayers.org/).
+The CARTO Maps API allows you to generate maps based on data hosted in your CARTO account and apply custom SQL and CartoCSS to the data. The API generates a XYZ-based URL to fetch Web Mercator projected tiles, using web clients such as [Leaflet](http://leafletjs.com), [Google Maps](https://developers.google.com/maps/), or [OpenLayers](http://openlayers.org/).

 You can create two types of maps with the Maps API:

 - **Anonymous Maps**  
-  You can create maps using your CartoDB public data. Any client can change the read-only SQL and CartoCSS parameters that generate the map tiles. These maps can be created from a JavaScript application alone and no authenticated calls are needed. See [this CartoDB.js example](/cartodb-platform/cartodb-js/getting-started/).
+  You can create maps using your CARTO public data. Any client can change the read-only SQL and CartoCSS parameters that generate the map tiles. These maps can be created from a JavaScript application alone and no authenticated calls are needed. See [this CARTO.js example](/carto-engine/carto-js/getting-started/).

 - **Named Maps**  
  There are also maps that have access to your private data. These maps require an owner to setup and modify any SQL and CartoCSS parameters and are not modifiable without new setup calls.
--- a/docs/anonymous_maps.md
+++ b/docs/anonymous_maps.md
@@ -28,7 +28,7 @@ POST /api/v1/map
 }
 ```

-See [MapConfig File Formats](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/) for details.
+See [MapConfig File Formats](http://docs.carto.com/carto-engine/maps-api/mapconfig/) for details.

 #### Response

@@ -36,7 +36,7 @@ The response includes:

 Attributes | Description
 --- | ---
-layergroupid | The ID for that map, used to compose the URL for the tiles. The final URL is: `https://{username}.cartodb.com/api/v1/map/{layergroupid}/{z}/{x}/{y}.png`
+layergroupid | The ID for that map, used to compose the URL for the tiles. The final URL is: `https://{username}.carto.com/api/v1/map/{layergroupid}/{z}/{x}/{y}.png`
 updated_at | The ISO date of the last time the data involved in the query was updated.
 metadata | Includes information about the layers.
 cdn_url | URLs to fetch the data using the best CDN for your zone.
@@ -46,7 +46,7 @@ cdn_url | URLs to fetch the data using the best CDN for your zone.
 #### Call

 ```bash
-curl 'https://{username}.cartodb.com/api/v1/map' -H 'Content-Type: application/json' -d @mapconfig.json
+curl 'https://{username}.carto.com/api/v1/map' -H 'Content-Type: application/json' -d @mapconfig.json
 ```

 #### Response
@@ -79,7 +79,7 @@ When you have a layergroup, there are several resources for retrieving layergoup
 These tiles will get just the Mapnik layers. To get individual layers, see the following section.

 ```bash
-https://{username}.cartodb.com/api/v1/map/{layergroupid}/{z}/{x}/{y}.png
+https://{username}.carto.com/api/v1/map/{layergroupid}/{z}/{x}/{y}.png
 ```

 #### Individual layers
@@ -89,7 +89,7 @@ The MapConfig specification holds the layers definition in a 0-based index. Laye
 Individual layers can be accessed using that 0-based index. For UTF grid tiles:

 ```bash
-https://{username}.cartodb.com/api/v1/map/{layergroupid}/{layer}/{z}/{x}/{y}.grid.json
+https://{username}.carto.com/api/v1/map/{layergroupid}/{layer}/{z}/{x}/{y}.grid.json
 ```

 In this case, `layer` as 0 returns the UTF grid tiles/attributes for layer 0, the only layer in the example MapConfig.
@@ -97,13 +97,13 @@ In this case, `layer` as 0 returns the UTF grid tiles/attributes for layer 0, th
 If the MapConfig had a Torque layer at index 1 it could be possible to request it with:

 ```bash
-https://{username}.cartodb.com/api/v1/map/{layergroupid}/1/{z}/{x}/{y}.torque.json
+https://{username}.carto.com/api/v1/map/{layergroupid}/1/{z}/{x}/{y}.torque.json
 ```

 #### Attributes defined in `attributes` section

 ```bash
-https://{username}.cartodb.com/api/v1/map/{layergroupid}/{layer}/attributes/{feature_id}
+https://{username}.carto.com/api/v1/map/{layergroupid}/{layer}/attributes/{feature_id}
 ```

 Which returns JSON with the attributes defined, like:
@@ -115,7 +115,7 @@ Which returns JSON with the attributes defined, like:
 #### Blending and layer selection

 ```bash
-https://{username}.cartodb.com/api/v1/map/{layergroupid}/{layer_filter}/{z}/{x}/{y}.png
+https://{username}.carto.com/api/v1/map/{layergroupid}/{layer_filter}/{z}/{x}/{y}.png
 ```

 Note: currently format is limited to `png`.
@@ -127,7 +127,7 @@ Note: currently format is limited to `png`.
 Using `all` as `layer_filter` will blend all layers in the layergroup

 ```bash
-https://{username}.cartodb.com/api/v1/map/{layergroupid}/all/{z}/{x}/{y}.png
+https://{username}.carto.com/api/v1/map/{layergroupid}/all/{z}/{x}/{y}.png
 ```

 - Filter by layer index
@@ -135,15 +135,12 @@ https://{username}.cartodb.com/api/v1/map/{layergroupid}/all/{z}/{x}/{y}.png
 A list of comma separated layer indexes can be used to just render a subset of layers. For example `0,3,4` will filter and blend layers with indexes 0, 3, and 4.

 ```bash
-https://{username}.cartodb.com/api/v1/map/{layergroupid}/0,3,4/{z}/{x}/{y}.png
+https://{username}.carto.com/api/v1/map/{layergroupid}/0,3,4/{z}/{x}/{y}.png
 ```

 Some notes about filtering:

  - Invalid index values or out of bounds indexes will end in `Invalid layer filtering` errors.
-  - Once a Mapnik layer is selected, all Mapnik layers will get blended. As this may change in the future **it is
-  recommended** to always select all Mapnik layers if you want to select at least one so you will get a consistent
-  behavior in the future.
  - Ordering is not considered. So right now filtering layers 0,3,4 is the very same thing as filtering 3,4,0. As this
  may change in the future **it is recommended** to always select the layers in ascending order so you will get a
  consistent behavior in the future.
@@ -172,7 +169,7 @@ callback | JSON callback name.
 #### Call

 ```bash
-curl "https://{username}.cartodb.com/api/v1/map?callback=callback&config=%7B%22version%22%3A%221.0.1%22%2C%22layers%22%3A%5B%7B%22type%22%3A%22cartodb%22%2C%22options%22%3A%7B%22sql%22%3A%22select+%2A+from+european_countries_e%22%2C%22cartocss%22%3A%22%23european_countries_e%7B+polygon-fill%3A+%23FF6600%3B+%7D%22%2C%22cartocss_version%22%3A%222.3.0%22%2C%22interactivity%22%3A%5B%22cartodb_id%22%5D%7D%7D%5D%7D"
+curl "https://{username}.carto.com/api/v1/map?callback=callback&config=%7B%22version%22%3A%221.0.1%22%2C%22layers%22%3A%5B%7B%22type%22%3A%22cartodb%22%2C%22options%22%3A%7B%22sql%22%3A%22select+%2A+from+european_countries_e%22%2C%22cartocss%22%3A%22%23european_countries_e%7B+polygon-fill%3A+%23FF6600%3B+%7D%22%2C%22cartocss_version%22%3A%222.3.0%22%2C%22interactivity%22%3A%5B%22cartodb_id%22%5D%7D%7D%5D%7D"
 ```

 #### Response
--- a/docs/general_concepts.md
+++ b/docs/general_concepts.md
@@ -4,7 +4,7 @@ The following concepts are the same for every endpoint in the API except when it

 ## Auth

-By default, users do not have access to private tables in CartoDB. In order to instantiate a map from private table data an API Key is required. Additionally, to include some endpoints, an API Key must be included (e.g. creating a Named Map).
+By default, users do not have access to private tables in CARTO. In order to instantiate a map from private table data an API Key is required. Additionally, to include some endpoints, an API Key must be included (e.g. creating a Named Map).

 To execute an authorized request, `api_key=YOURAPIKEY` should be added to the request URL. The param can be also passed as POST param. Using HTTPS is mandatory when you are performing requests that include your `api_key`.

--- a/docs/named_maps.md
+++ b/docs/named_maps.md
@@ -1,12 +1,12 @@
 # Named Maps

-Named Maps are essentially the same as Anonymous Maps except the MapConfig is stored on the server, and the map is given a unique name. You can create Named Maps from private data, and users without an API Key can view your Named Map (while keeping your data private). 
+Named Maps are essentially the same as Anonymous Maps except the MapConfig is stored on the server, and the map is given a unique name. You can create Named Maps from private data, and users without an API Key can view your Named Map (while keeping your data private).

-The Named Map workflow consists of uploading a MapConfig file to CartoDB servers, to select data from your CartoDB user database by using SQL, and specifying the CartoCSS for your map. 
+The Named Map workflow consists of uploading a MapConfig file to CARTO servers, to select data from your CARTO user database by using SQL, and specifying the CartoCSS for your map.

-The response back from the API provides the template_id of your Named Map as the `name` (the identifier of your Named Map), which is the name that you specified in the MapConfig. You can  which you can then use to create your Named Map details, or [fetch XYZ tiles](#fetching-xyz-tiles-for-named-maps) directly for Named Maps. 
+The response back from the API provides the template_id of your Named Map as the `name` (the identifier of your Named Map), which is the name that you specified in the MapConfig. You can  which you can then use to create your Named Map details, or [fetch XYZ tiles](#fetching-xyz-tiles-for-named-maps) directly for Named Maps.

-**Tip:** You can also use a Named Map that you created (which is defined by its `name`), to create a map using CartoDB.js. This is achieved by adding the [`namedmap` type](http://docs.cartodb.com/cartodb-platform/cartodb-js/layer-source-object/#named-maps-layer-source-object-type-namedmap) layer source object to draw the Named Map.
+**Tip:** You can also use a Named Map that you created (which is defined by its `name`), to create a map using CARTO.js. This is achieved by adding the [`namedmap` type](http://docs.carto.com/carto-engine/carto-js/layer-source-object/#named-maps-layer-source-object-type-namedmap) layer source object to draw the Named Map.

 The main differences, compared to Anonymous Maps, is that Named Maps include:

@@ -14,11 +14,11 @@ The main differences, compared to Anonymous Maps, is that Named Maps include:
  This allows you to control who is able to see the map based on an auth token, and create a secure Named Map with password-protection.

 - **template map**  
-  The template map is static and may contain placeholders, enabling you to modify your maps appearance by using variables. Templates maps are persistent with no preset expiration. They can only be created, or deleted, by a CartoDB user with a valid API KEY (See [auth argument](#arguments)).
+  The template map is static and may contain placeholders, enabling you to modify your maps appearance by using variables. Templates maps are persistent with no preset expiration. They can only be created, or deleted, by a CARTO user with a valid API KEY (See [auth argument](#arguments)).

-  Uploading a MapConfig creates a Named Map. MapConfigs are uploaded to the server by sending the server a "template".json file, which contain the [MapConfig specifications](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/).
+  Uploading a MapConfig creates a Named Map. MapConfigs are uploaded to the server by sending the server a "template".json file, which contain the [MapConfig specifications](http://docs.carto.com/carto-engine/maps-api/mapconfig/).

-**Note:** There is a limit of 4,096 Named Maps allowed per account. If you need to create more Named Maps, it is recommended to use a single Named Map and change the variables using [placeholders](#placeholder-format), instead of uploading multiple [Named Map MapConfigs](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/#named-map-layer-options).
+**Note:** There is a limit of 4,096 Named Maps allowed per account. If you need to create more Named Maps, it is recommended to use a single Named Map and change the variables using [placeholders](#placeholder-format), instead of uploading multiple [Named Map MapConfigs](http://docs.carto.com/carto-engine/maps-api/mapconfig/#named-map-layer-options).

 ## Create

@@ -33,7 +33,7 @@ POST /api/v1/map/named
 Params | Description
 --- | ---
 api_key | is required
-MapConfig | a [Named Map MapConfig](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/#named-map-layer-options) is required to create a Named Map
+MapConfig | a [Named Map MapConfig](http://docs.carto.com/carto-engine/maps-api/mapconfig/#named-map-layer-options) is required to create a Named Map

 #### template.json

@@ -84,6 +84,10 @@ The `name` argument defines how to name this "template_name".json. Note that the
      "south": -45,
      "east": 45,
      "north": 45
+    },
+    "preview_layers": {
+      "0": true,
+      "layer1": false
    }
  }
 }
@@ -95,22 +99,22 @@ Params | Description
 --- | ---
 name | There can only be _one_ template with the same name for any user. Valid names start with a letter or a number, and only contain letters, numbers, dashes (-), or underscores (_). _This is specific to the name of your Named Map that is specified in the `name` property of the template file_.

-auth | 
+auth |
 --- | ---
 &#124;_ method | `"token"` or `"open"` (`"open"` is the default if no method is specified. Use `"token"` to password-protect your map)
-&#124;_ valid_tokens | when `"method"` is set to `"token"`, the values listed here allow you to instantiate the Named Map. See this [example](http://docs.cartodb.com/faqs/manipulating-your-data/#how-to-create-a-password-protected-named-map) for how to create a password-protected map.
+&#124;_ valid_tokens | when `"method"` is set to `"token"`, the values listed here allow you to instantiate the Named Map. See this [example](http://docs.carto.com/faqs/manipulating-your-data/#how-to-create-a-password-protected-named-map) for how to create a password-protected map.
 placeholders | Placeholders are variables that can be placed in your template.json file's SQL or CartoCSS.
-layergroup | the layergroup configurations, as specified in the template. See [MapConfig File Format](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/) for more information.
-view (optional) | extra keys to specify the view area for the map. It can be used to have a static preview of a Named Map without having to instantiate it. It is possible to specify it with `center` + `zoom` or with a bounding box `bbox`. Center+zoom takes precedence over bounding box.
+layergroup | the layergroup configurations, as specified in the template. See [MapConfig File Format](http://docs.carto.com/carto-engine/maps-api/mapconfig/) for more information.
+view (optional) | extra keys to specify the view area for the map. It can be used to have a static preview of a Named Map without having to instantiate it. It is possible to specify it with `center` + `zoom` or with a bounding box `bbox`. Center+zoom takes precedence over bounding box. Also it is possible to choose which layers are visible or not with `preview_layers` indicating its visibility by layer index or id (visible by default).
 --- | ---
 &#124;_ zoom | The zoom level to use

-&#124;_ center | 
+&#124;_ center |
 --- | ---
 &#124;_ &#124;_ lng | The longitude to use for the center
 &#124;_ &#124;_ lat | The latitude to use for the center

-&#124;_ bounds | 
+&#124;_ bounds |
 --- | ---
 &#124;_ &#124;_ west | LowerCorner longitude for the bounding box, in decimal degrees (aka most western)
 &#124;_ &#124;_ south | LowerCorner latitude for the bounding box, in decimal degrees (aka most southern)
@@ -120,7 +124,7 @@ view (optional) | extra keys to specify the view area for the map. It can be use

 ### Placeholder Format

-Placeholders are variables that can be placed in your template.json file. Placeholders need to be defined with a `type` and a default value for MapConfigs. See details about defining a MapConfig `type` for [Layergoup configurations](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/#layergroup-configurations).
+Placeholders are variables that can be placed in your template.json file. Placeholders need to be defined with a `type` and a default value for MapConfigs. See details about defining a MapConfig `type` for [Layergoup configurations](http://docs.carto.com/carto-engine/maps-api/mapconfig/#layergroup-configurations).

 Valid placeholder names start with a letter and can only contain letters, numbers, or underscores. They have to be written between the `<%=` and `%>` strings in order to be replaced inside the Named Maps API.

@@ -155,12 +159,12 @@ This is the call for creating the Named Map. It is sending the template.json fil
 curl -X POST \
   -H 'Content-Type: application/json' \
   -d @template.json \
-   'https://{username}.cartodb.com/api/v1/map/named?api_key={api_key}'
+   'https://{username}.carto.com/api/v1/map/named?api_key={api_key}'
 ```

 #### Response

-The response back from the API provides the name of your MapConfig as a template, enabling you to edit the Named Map details by inserting your variables into the template where placeholders are defined, and create custom queries using SQL. 
+The response back from the API provides the name of your MapConfig as a template, enabling you to edit the Named Map details by inserting your variables into the template where placeholders are defined, and create custom queries using SQL.

 ```javascript
 {
@@ -170,7 +174,7 @@ The response back from the API provides the name of your MapConfig as a template

 ## Instantiate

-Instantiating a Named Map allows you to fetch the map tiles. You can use the Maps API to instantiate, or use the CartoDB.js `createLayer()` function. The result is an Anonymous Map.
+Instantiating a Named Map allows you to fetch the map tiles. You can use the Maps API to instantiate, or use the CARTO.js `createLayer()` function. The result is an Anonymous Map.

 #### Definition

@@ -209,7 +213,7 @@ Valid auth token will be needed, if required by the template.
 curl -X POST \
  -H 'Content-Type: application/json' \
  -d @params.json \
-  'https://{username}.cartodb.com/api/v1/map/named/{template_name}?auth_token={auth_token}'
+  'https://{username}.carto.com/api/v1/map/named/{template_name}?auth_token={auth_token}'
 ```

 #### Response
@@ -229,7 +233,7 @@ curl -X POST \
 }
 ```

-You can then use the `layergroupid` for fetching tiles and grids as you would normally (see [Anonymous Maps](http://docs.cartodb.com/cartodb-platform/maps-api/anonymous-maps/)).
+You can then use the `layergroupid` for fetching tiles and grids as you would normally (see [Anonymous Maps](http://docs.carto.com/carto-engine/maps-api/anonymous-maps/)).

 ## Update

@@ -261,7 +265,7 @@ Updating a Named Map removes all the Named Map instances, so they need to be ini
 curl -X PUT \
  -H 'Content-Type: application/json' \
  -d @template.json \
-  'https://{username}.cartodb.com/api/v1/map/named/{template_name}?api_key={api_key}'
+  'https://{username}.carto.com/api/v1/map/named/{template_name}?api_key={api_key}'
 ```

 #### Response
@@ -303,7 +307,7 @@ api_key | is required
 #### Call

 ```bash
-curl -X DELETE 'https://{username}.cartodb.com/api/v1/map/named/{template_name}?api_key={api_key}'
+curl -X DELETE 'https://{username}.carto.com/api/v1/map/named/{template_name}?api_key={api_key}'
 ```

 #### Response
@@ -337,7 +341,7 @@ api_key | is required
 #### Call

 ```bash
-curl -X GET 'https://{username}.cartodb.com/api/v1/map/named?api_key={api_key}'
+curl -X GET 'https://{username}.carto.com/api/v1/map/named?api_key={api_key}'
 ```

 #### Response
@@ -377,7 +381,7 @@ api_key | is required
 #### Call

 ```bash
-curl -X GET 'https://{username}.cartodb.com/api/v1/map/named/{template_name}?api_key={api_key}'
+curl -X GET 'https://{username}.carto.com/api/v1/map/named/{template_name}?api_key={api_key}'
 ```

 #### Response
@@ -418,7 +422,7 @@ callback | JSON callback name
 #### Call

 ```bash
-curl 'https://{username}.cartodb.com/api/v1/map/named/{template_name}/jsonp?auth_token={auth_token}&callback=callback&config=template_params_json'
+curl 'https://{username}.carto.com/api/v1/map/named/{template_name}/jsonp?auth_token={auth_token}&callback=callback&config=template_params_json'
 ```

 #### Response
@@ -450,9 +454,9 @@ callback({
 })
 ```

-## CartoDB.js for Named Maps
+## CARTO.js for Named Maps

-You can use a Named Map that you created (which is defined by its `name`), to create a map using CartoDB.js. This is achieved by adding the [`namedmap` type](http://docs.cartodb.com/cartodb-platform/cartodb-js/layer-source-object/#named-maps-layer-source-object-type-namedmap) layer source object to draw the Named Map.
+You can use a Named Map that you created (which is defined by its `name`), to create a map using CARTO.js. This is achieved by adding the [`namedmap` type](http://docs.carto.com/carto-engine/carto-js/layer-source-object/#named-maps-layer-source-object-type-namedmap) layer source object to draw the Named Map.

 ```javascript
 {
@@ -482,17 +486,17 @@ You can use a Named Map that you created (which is defined by its `name`), to cr

 **Note:** Instantiating a Named Map over a `createLayer` does not require an API Key and by default, does not include auth tokens. _If_ you defined auth tokens for the Named Map configuration, then you will have to include them.

-[CartoDB.js](http://docs.cartodb.com/cartodb-platform/cartodb-js/) has methods for accessing your Named Maps.
+[CARTO.js](http://docs.carto.com/carto-engine/carto-js/) has methods for accessing your Named Maps.

-1. [layer.setParams()](http://docs.cartodb.com/cartodb-platform/cartodb-js/api-methods/#layersetparamskey-value) allows you to change the template variables (in the placeholders object) via JavaScript
+1. [layer.setParams()](http://docs.carto.com/carto-engine/carto-js/api-methods/#layersetparamskey-value) allows you to change the template variables (in the placeholders object) via JavaScript

-    **Note:** The CartoDB.js `layer.setParams()` function is not supported when using Named Maps for Torque. Alternatively, you can create a [Torque layer in a Named Map](http://bl.ocks.org/iriberri/de37be6406f9cc7cfe5a)
+    **Note:** The CARTO.js `layer.setParams()` function is not supported when using Named Maps for Torque. Alternatively, you can create a [Torque layer in a Named Map](http://bl.ocks.org/iriberri/de37be6406f9cc7cfe5a)

-2. [layer.setAuthToken()](http://docs.cartodb.com/cartodb-platform/cartodb-js/api-methods/#layersetauthtokenauthtoken) allows you to set the auth tokens to create the layer
+2. [layer.setAuthToken()](http://docs.carto.com/carto-engine/carto-js/api-methods/#layersetauthtokenauthtoken) allows you to set the auth tokens to create the layer

 ### Torque Layer in a Named Map

-If you are creating a Torque layer in a Named Map without using the Torque.js library, you can apply the Torque layer by applying the following code with CartoDBjs:
+If you are creating a Torque layer in a Named Map without using the Torque.js library, you can apply the Torque layer by applying the following code with CARTO.js:

 ```javascript
 // add cartodb layer with one sublayer
@@ -516,12 +520,12 @@ If you are creating a Torque layer in a Named Map without using the Torque.js li
    })
    .addTo(map)
    .done(function(layer) {
-  
+
    });
 }
 ```

-#### Examples of Named Maps created with CartoDB.js
+#### Examples of Named Maps created with CARTO.js

 - [Named Map selectors with interaction](http://bl.ocks.org/ohasselblad/515a8af1f99d5e690484)

@@ -535,7 +539,7 @@ Optionally, authenticated users can fetch projected tiles (XYZ tiles or Mapnik R

 ### Fetch XYZ Tiles Directly with a URL

-Authenticated users, with an auth token, can use XYZ-based URLs to fetch tiles directly, and instantiate the Named Map as part of the request to your application. You do not have to do any other steps to initialize your map. 
+Authenticated users, with an auth token, can use XYZ-based URLs to fetch tiles directly, and instantiate the Named Map as part of the request to your application. You do not have to do any other steps to initialize your map.

 To call a template_id in a URL:

@@ -543,21 +547,21 @@ To call a template_id in a URL:

 For example, a complete URL might appear as:

-"https://{username}.cartodb.com/api/v1/map/named/{template_id}/{layer}/{z}/{x}/{y}.png"
+"https://{username}.carto.com/api/v1/map/named/{template_id}/{layer}/{z}/{x}/{y}.png"

 The placeholders indicate the following:

- [`template_id`](http://docs.cartodb.com/cartodb-platform/maps-api/named-maps/#response) is the response of your Named Map.
+- [`template_id`](http://docs.carto.com/carto-engine/maps-api/named-maps/#response) is the response of your Named Map.
 - layers can be a number (referring to the # layer of your map), all layers of your map, or a list of layers.
-  - To show just the basemap layer, enter the number value `0` in the layer placeholder "https://{username}.cartodb.com/api/v1/map/named/{template_id}/0/{z}/{x}/{y}.png"
-  - To show the first layer, enter the number value `1` in the layer placeholder "https://{username}.cartodb.com/api/v1/map/named/{template_id}/1/{z}/{x}/{y}.png"
-  - To show all layers, enter the value `all` for the layer placeholder "https://{username}.cartodb.com/api/v1/map/named/{template_id}/all/{z}/{x}/{y}.png"
-  - To show a [list of layers](http://docs.cartodb.com/cartodb-platform/maps-api/anonymous-maps/#blending-and-layer-selection), enter the comma separated layer value as 0,1,2 in the layer placeholder. For example, to show the basemap and the first layer, "https://{username}.cartodb.com/api/v1/map/named/{template_id}/0,1/{z}/{x}/{y}.png"
+  - To show just the basemap layer, enter the number value `0` in the layer placeholder "https://{username}.carto.com/api/v1/map/named/{template_id}/0/{z}/{x}/{y}.png"
+  - To show the first layer, enter the number value `1` in the layer placeholder "https://{username}.carto.com/api/v1/map/named/{template_id}/1/{z}/{x}/{y}.png"
+  - To show all layers, enter the value `all` for the layer placeholder "https://{username}.carto.com/api/v1/map/named/{template_id}/all/{z}/{x}/{y}.png"
+  - To show a [list of layers](http://docs.carto.com/carto-engine/maps-api/anonymous-maps/#blending-and-layer-selection), enter the comma separated layer value as 0,1,2 in the layer placeholder. For example, to show the basemap and the first layer, "https://{username}.carto.com/api/v1/map/named/{template_id}/0,1/{z}/{x}/{y}.png"


 ### Get Mapnik Retina Tiles

-Mapnik Retina tiles are not directly supported for Named Maps, so you cannot use the Named Map template_id. To fetch Mapnik Retina tiles, get the [layergroupid](http://docs.cartodb.com/cartodb-platform/maps-api/named-maps/#response-1) to initialize the map.
+Mapnik Retina tiles are not directly supported for Named Maps, so you cannot use the Named Map template_id. To fetch Mapnik Retina tiles, get the [layergroupid](http://docs.carto.com/carto-engine/maps-api/named-maps/#response-1) to initialize the map.

 Instantiate the map by using your `layergroupid` in the token placeholder:

--- a/docs/quickstart.md
+++ b/docs/quickstart.md
@@ -22,10 +22,10 @@ $.ajax({
  type: 'POST',
  dataType: 'json',
  contentType: 'application/json',
-  url: 'https://{username}.cartodb.com/api/v1/map',
+  url: 'https://{username}.carto.com/api/v1/map',
  data: JSON.stringify(mapconfig),
  success: function(data) {
-    var templateUrl = 'https://{username}.cartodb.com/api/v1/map/' + data.layergroupid + '/{z}/{x}/{y}.png'
+    var templateUrl = 'https://{username}.carto.com/api/v1/map/' + data.layergroupid + '/{z}/{x}/{y}.png'
    console.log(templateUrl);
  }
 })
@@ -33,7 +33,7 @@ $.ajax({

 ## Named Maps

-Let's create a Named Map using some private tables in a CartoDB account.
+Let's create a Named Map using some private tables in a CARTO account.
 The following map config sets up a map of European countries that have a white fill color:

 ```javascript
@@ -56,12 +56,12 @@ The following map config sets up a map of European countries that have a white f
 }
 ```

-The MapConfig needs to be sent to CartoDB's Map API using an authenticated call. Here we will use a command line tool called `curl`. For more info about this tool, see [this blog post](http://quickleft.com/blog/command-line-tutorials-curl), or type `man curl` in bash. Using `curl`, and storing the config from above in a file `MapConfig.json`, the call would look like:
+The MapConfig needs to be sent to CARTO's Map API using an authenticated call. Here we will use a command line tool called `curl`. For more info about this tool, see [this blog post](http://quickleft.com/blog/command-line-tutorials-curl), or type `man curl` in bash. Using `curl`, and storing the config from above in a file `MapConfig.json`, the call would look like:

 #### Call

 ```bash
-curl 'https://{username}.cartodb.com/api/v1/map/named?api_key={api_key}' -H 'Content-Type: application/json' -d @mapconfig.json
+curl 'https://{username}.carto.com/api/v1/map/named?api_key={api_key}' -H 'Content-Type: application/json' -d @mapconfig.json
 ```

 To get the `URL` to fetch the tiles you need to instantiate the map, where `template_id` is the template name from the previous response.
@@ -69,7 +69,7 @@ To get the `URL` to fetch the tiles you need to instantiate the map, where `temp
 #### Call

 ```bash
-curl -X POST 'https://{username}.cartodb.com/api/v1/map/named/{template_id}' -H 'Content-Type: application/json'
+curl -X POST 'https://{username}.carto.com/api/v1/map/named/{template_id}' -H 'Content-Type: application/json'
 ```

 The response will return JSON with properties for the `layergroupid`, the timestamp (`last_updated`) of the last data modification and some key/value pairs with `metadata` for the `layers`.
@@ -96,5 +96,5 @@ Note: all `layers` in `metadata` will always have a `type` string and a `meta` d
 You can use the `layergroupid` to instantiate a URL template for accessing tiles on the client. Here we use the `layergroupid` from the example response above in this URL template:

 ```bash
-https://{username}.cartodb.com/api/v1/map/{layergroupid}/{z}/{x}/{y}.png
+https://{username}.carto.com/api/v1/map/{layergroupid}/{z}/{x}/{y}.png
 ```
--- a/docs/static_maps_api.md
+++ b/docs/static_maps_api.md
@@ -78,7 +78,7 @@ format | the format for the image, supported types: `png`, `jpg`
 --- | ---
 &#124;_ jpg | will have a default quality of 85.

-A Named Maps static image will get its constraints from the [`view` argument of the Create Named Map function](http://docs.cartodb.com/cartodb-platform/maps-api/named-maps/#arguments). If `view` is not defined, it will estimate the extent based on the involved tables, otherwise it fallbacks to `"zoom": 1`, `"lng": 0` and `"lat": 0`.
+A Named Maps static image will get its constraints from the [`view` argument of the Create Named Map function](http://docs.carto.com/carto-engine/maps-api/named-maps/#arguments). If `view` is not defined, it will estimate the extent based on the involved tables, otherwise it fallbacks to `"zoom": 1`, `"lng": 0` and `"lat": 0`.

 #### Layers

@@ -122,9 +122,9 @@ By manipulating the `"urlTemplate"` custom basemaps can be used in generating st
 },
 ```

-**CartoDB**
+**CARTO**

-As described in the [MapConfig File Format](http://docs.cartodb.com/cartodb-platform/maps-api/mapconfig/), a "cartodb" type layer is now just an alias to a "mapnik" type layer as above, intended for backwards compatibility.
+As described in the [MapConfig File Format](http://docs.carto.com/carto-engine/maps-api/mapconfig/), a "cartodb" type layer is now just an alias to a "mapnik" type layer as above, intended for backwards compatibility.

 ```javascript
 {
@@ -142,18 +142,18 @@ Additionally, static images from Torque maps and other map layers can be used to

 ### Caching

-It is important to note that generated images are cached from the live data referenced with the `layergroupid token` on the specified CartoDB account. This means that if the data changes, the cached image will also change. When linking dynamically, it is important to take into consideration the state of the data and longevity of the static image to avoid broken images or changes in how the image is displayed. To obtain a static snapshot of the map as it is today and preserve the image long-term regardless of changes in data, the image must be saved and stored locally.
+It is important to note that generated images are cached from the live data referenced with the `layergroupid token` on the specified CARTO account. This means that if the data changes, the cached image will also change. When linking dynamically, it is important to take into consideration the state of the data and longevity of the static image to avoid broken images or changes in how the image is displayed. To obtain a static snapshot of the map as it is today and preserve the image long-term regardless of changes in data, the image must be saved and stored locally.

 ### Limits

 * While images can encompass an entirety of a map, the default limit for pixel range is 8192 x 8192.
 * Image resolution by default is set to 72 DPI
 * JPEG quality by default is 85%
-* Timeout limits for generating static maps are the same across the CartoDB Editor and Platform. It is important to ensure timely processing of queries.
+* Timeout limits for generating static maps are the same across CARTO Builder and CARTO Engine. It is important to ensure timely processing of queries.

 ## Examples

-After instantiating a map from a CartoDB account:
+After instantiating a map from a CARTO account:

 #### Call

--- a/lib/cartodb/api/filter_stats_api.js
+++ b/lib/cartodb/api/filter_stats_api.js
@@ -1,6 +1,6 @@
 var _ = require('underscore');
 var step = require('step');
-var CamshaftFilter = require('../models/filter/camshaft');
+var AnalysisFilter = require('../models/filter/analysis');

 function FilterStatsApi(pgQueryRunner) {
    this.pgQueryRunner = pgQueryRunner;
@@ -40,8 +40,8 @@ FilterStatsApi.prototype.getFilterStats = function (username, unfiltered_query,
      },
      function getFilteredRows() {
          if ( filters && !_.isEmpty(filters)) {
-              var camshaftFilter = new CamshaftFilter(filters);
-              var query = camshaftFilter.sql(unfiltered_query);
+              var analysisFilter = new AnalysisFilter(filters);
+              var query = analysisFilter.sql(unfiltered_query);
              getEstimatedRows(self.pgQueryRunner, username, query, this);
          } else {
              this(null, null);
--- a/lib/cartodb/backends/analysis-status.js
+++ b/lib/cartodb/backends/analysis-status.js
@@ -9,7 +9,10 @@ module.exports = AnalysisStatusBackend;
 AnalysisStatusBackend.prototype.getNodeStatus = function (params, callback) {
    var nodeId = params.nodeId;

-    var statusQuery = 'SELECT node_id, status, updated_at FROM cdb_analysis_catalog where node_id = \'' + nodeId + '\'';
+    var statusQuery = [
+        'SELECT node_id, status, updated_at, last_error_message as error_message',
+        'FROM cdb_analysis_catalog where node_id = \'' + nodeId + '\''
+    ].join(' ');

    var pg = new PSQL(dbParamsFromReqParams(params));
    pg.query(statusQuery, function(err, result) {
@@ -21,10 +24,16 @@ AnalysisStatusBackend.prototype.getNodeStatus = function (params, callback) {

        var rows = result.rows || [];

-        return callback(null, rows[0] || {
+        var statusResponse = rows[0] || {
            node_id: nodeId,
            status: 'unknown'
-        });
+        };
+
+        if (statusResponse.status !== 'failed') {
+            delete statusResponse.error_message;
+        }
+
+        return callback(null, statusResponse);
    }, true); // use read-only transaction
 };

--- a/lib/cartodb/backends/analysis.js
+++ b/lib/cartodb/backends/analysis.js
@@ -1,19 +1,93 @@
-var camshaft = require('camshaft');
+'use strict';

-function AnalysisBackend(options) {
-    var batchConfig = options.batch || {};
+var _ = require('underscore');
+var camshaft = require('camshaft');
+var fs = require('fs');
+
+var REDIS_LIMITS = {
+    DB: 5,
+    PREFIX: 'limits:analyses:' // + username
+};
+
+function AnalysisBackend (metadataBackend, options) {
+    this.metadataBackend = metadataBackend;
+    this.options = options || {};
+    this.options.limits = this.options.limits || {};
+    this.setBatchConfig(this.options.batch);
+    this.setLoggerConfig(this.options.logger);
+}
+
+module.exports = AnalysisBackend;
+
+AnalysisBackend.prototype.setBatchConfig = function (options) {
+    var batchConfig = options || {};
    batchConfig.endpoint = batchConfig.endpoint || 'http://127.0.0.1:8080/api/v1/sql/job';
    batchConfig.inlineExecution = batchConfig.inlineExecution || false;
    batchConfig.hostHeaderTemplate = batchConfig.hostHeaderTemplate || '{{=it.username}}.localhost.lan';
    this.batchConfig = batchConfig;
-}
+};

-module.exports = AnalysisBackend;
+AnalysisBackend.prototype.setLoggerConfig = function (options) {
+    this.loggerConfig = options || {};
+
+    if (this.loggerConfig.filename) {
+        this.stream = fs.createWriteStream(this.loggerConfig.filename, { flags: 'a', encoding: 'utf8' });
+
+        process.on('SIGHUP', function () {
+            if (this.stream) {
+                this.stream.destroy();
+            }
+
+            this.stream = fs.createWriteStream(this.loggerConfig.filename, { flags: 'a', encoding: 'utf8' });
+        }.bind(this));
+    }
+};

 AnalysisBackend.prototype.create = function(analysisConfiguration, analysisDefinition, callback) {
    analysisConfiguration.batch.endpoint = this.batchConfig.endpoint;
    analysisConfiguration.batch.inlineExecution = this.batchConfig.inlineExecution;
    analysisConfiguration.batch.hostHeaderTemplate = this.batchConfig.hostHeaderTemplate;

-    camshaft.create(analysisConfiguration, analysisDefinition, callback);
+    analysisConfiguration.logger = {
+        stream: this.stream ? this.stream : process.stdout
+    };
+
+    this.getAnalysesLimits(analysisConfiguration.user, function(err, limits) {
+        analysisConfiguration.limits = limits || {};
+        camshaft.create(analysisConfiguration, analysisDefinition, callback);
+    });
+};
+
+AnalysisBackend.prototype.getAnalysesLimits = function(username, callback) {
+    var self = this;
+
+    var analysesLimits = {
+        analyses: {
+            // buffer: {
+            //     timeout: 1000,
+            //     maxNumberOfRows: 1e6
+            // }
+        }
+    };
+
+    Object.keys(self.options.limits).forEach(function(analysisTypeOrTag) {
+        analysesLimits.analyses[analysisTypeOrTag] = _.extend({}, self.options.limits[analysisTypeOrTag]);
+    });
+
+    var analysesLimitsKey = REDIS_LIMITS.PREFIX + username;
+    this.metadataBackend.redisCmd(REDIS_LIMITS.DB, 'HGETALL', [analysesLimitsKey], function(err, analysesTimeouts) {
+        // analysesTimeouts wil be something like: { moran: 3000, intersection: 5000 }
+        analysesTimeouts = analysesTimeouts || {};
+
+        Object.keys(analysesTimeouts).forEach(function(analysisType) {
+            analysesLimits.analyses[analysisType] = _.defaults(
+                {
+                    timeout: Number.isFinite(+analysesTimeouts[analysisType]) ? +analysesTimeouts[analysisType] : 0
+                },
+                analysesLimits.analyses[analysisType]
+            );
+        });
+
+        return callback(null, analysesLimits);
+    });
 };
--- a/lib/cartodb/backends/dataview.js
+++ b/lib/cartodb/backends/dataview.js
@@ -2,11 +2,8 @@ var assert = require('assert');

 var _ = require('underscore');
 var PSQL = require('cartodb-psql');
-var camshaft = require('camshaft');
 var step = require('step');

-var Timer = require('../stats/timer');
-
 var BBoxFilter = require('../models/filter/bbox');

 var DataviewFactory = require('../models/dataview/factory');
@@ -16,6 +13,9 @@ var overviewsQueryRewriter = new OverviewsQueryRewriter({
    zoom_level: 'CDB_ZoomFromScale(!scale_denominator!)'
 });

+var dot = require('dot');
+dot.templateSettings.strip = false;
+
 function DataviewBackend(analysisBackend) {
    this.analysisBackend = analysisBackend;
 }
@@ -23,128 +23,47 @@ function DataviewBackend(analysisBackend) {
 module.exports = DataviewBackend;

 DataviewBackend.prototype.getDataview = function (mapConfigProvider, user, params, callback) {
-    var self = this;
-
-    var timer = new Timer();

    var dataviewName = params.dataviewName;
-
-    var mapConfig;
-    var dataviewDefinition;
    step(
        function getMapConfig() {
            mapConfigProvider.getMapConfig(this);
        },
-        function _getDataviewDefinition(err, _mapConfig) {
+        function runDataviewQuery(err, mapConfig) {
            assert.ifError(err);

-            mapConfig = _mapConfig;
-
-            var _dataviewDefinition = getDataviewDefinition(mapConfig.obj(), dataviewName);
-            if (!_dataviewDefinition) {
+            var dataviewDefinition = getDataviewDefinition(mapConfig.obj(), dataviewName);
+            if (!dataviewDefinition) {
                throw new Error("Dataview '" + dataviewName + "' does not exists");
            }

-            dataviewDefinition = _dataviewDefinition;
-
-            return dataviewDefinition;
-        },
-        function loadAnalysis(err) {
-            assert.ifError(err);
-
-            var analysisConfiguration = {
-                db: {
-                    host: params.dbhost,
-                    port: params.dbport,
-                    dbname: params.dbname,
-                    user: params.dbuser,
-                    pass: params.dbpassword
-                },
-                batch: {
-                    username: user,
-                    apiKey: params.api_key
-                }
-            };
-
-            var sourceId = dataviewDefinition.source.id;
-            var analysisDefinition = getAnalysisDefinition(mapConfig.obj().analyses, sourceId);
-
-            var next = this;
-
-            self.analysisBackend.create(analysisConfiguration, analysisDefinition, function(err, analysis) {
-                if (err) {
-                    return next(err);
-                }
-
-                var sourceId2Node = {};
-                var rootNode = analysis.getRoot();
-                if (rootNode.params && rootNode.params.id) {
-                    sourceId2Node[rootNode.params.id] = rootNode;
-                }
-
-                analysis.getSortedNodes().forEach(function(node) {
-                    if (node.params && node.params.id) {
-                        sourceId2Node[node.params.id] = node;
-                    }
-                });
-
-                var node = sourceId2Node[sourceId];
-
-                if (!node) {
-                    return next(new Error('Analysis node not found for dataview'));
-                }
-
-                return next(null, node);
-            });
-        },
-        function runDataviewQuery(err, node) {
-            assert.ifError(err);
-
            var pg = new PSQL(dbParamsFromReqParams(params));

            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 = (ownFilter) ? dataviewDefinition.sql.own_filter_on : dataviewDefinition.sql.own_filter_off;
            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 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 (queryRewriteData && dataviewDefinition.node.type === 'source') {
+                queryRewriteData = _.extend({}, queryRewriteData, {
+                    filters: dataviewDefinition.node.filters,
+                    unfiltered_query: dataviewDefinition.sql.own_filter_on
+                });
            }

            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',
-                            srid: 4326,
+                            column: 'the_geom_webmercator',
+                            srid: 3857
                        },
                        params: {
                            bbox: params.bbox
@@ -170,104 +89,32 @@ DataviewBackend.prototype.getDataview = function (mapConfigProvider, user, param
            dataview.getResult(pg, overrideParams, this);
        },
        function returnCallback(err, result) {
-            return callback(err, result, timer.getTimes());
+            return callback(err, result);
        }
    );
 };

 DataviewBackend.prototype.search = function (mapConfigProvider, user, params, callback) {
-    var self = this;
-
-    var timer = new Timer();
-
    var dataviewName = params.dataviewName;

-    var mapConfig;
-    var dataviewDefinition;
    step(
        function getMapConfig() {
            mapConfigProvider.getMapConfig(this);
        },
-        function _getDataviewDefinition(err, _mapConfig) {
+        function runDataviewSearchQuery(err, mapConfig) {
            assert.ifError(err);

-            mapConfig = _mapConfig;
-
-            var _dataviewDefinition = getDataviewDefinition(mapConfig.obj(), dataviewName);
-            if (!_dataviewDefinition) {
+            var dataviewDefinition = getDataviewDefinition(mapConfig.obj(), dataviewName);
+            if (!dataviewDefinition) {
                throw new Error("Dataview '" + dataviewName + "' does not exists");
            }

-            dataviewDefinition = _dataviewDefinition;
-
-            return dataviewDefinition;
-        },
-        function loadAnalysis(err) {
-            assert.ifError(err);
-
-            var analysisConfiguration = {
-                db: {
-                    host: params.dbhost,
-                    port: params.dbport,
-                    dbname: params.dbname,
-                    user: params.dbuser,
-                    pass: params.dbpassword
-                },
-                batch: {
-                    // TODO load this from configuration
-                    endpoint: 'http://127.0.0.1:8080/api/v1/sql/job',
-                    username: user,
-                    apiKey: params.api_key
-                }
-            };
-
-            var sourceId = dataviewDefinition.source.id;
-            var analysisDefinition = getAnalysisDefinition(mapConfig.obj().analyses, sourceId);
-
-            var next = this;
-
-            self.analysisBackend.create(analysisConfiguration, analysisDefinition, function(err, analysis) {
-                if (err) {
-                    return next(err);
-                }
-
-                var sourceId2Node = {};
-                var rootNode = analysis.getRoot();
-                if (rootNode.params && rootNode.params.id) {
-                    sourceId2Node[rootNode.params.id] = rootNode;
-                }
-
-                analysis.getSortedNodes().forEach(function(node) {
-                    if (node.params && node.params.id) {
-                        sourceId2Node[node.params.id] = node;
-                    }
-                });
-
-                var node = sourceId2Node[sourceId];
-
-                if (!node) {
-                    return next(new Error('Analysis node not found for dataview'));
-                }
-
-                return next(null, node);
-            });
-        },
-        function runDataviewQuery(err, node) {
-            assert.ifError(err);
-
            var pg = new PSQL(dbParamsFromReqParams(params));

            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 = (ownFilter) ? dataviewDefinition.sql.own_filter_on : dataviewDefinition.sql.own_filter_off;

            if (params.bbox) {
                var bboxFilter = new BBoxFilter({column: 'the_geom', srid: 4326}, {bbox: params.bbox});
@@ -280,23 +127,11 @@ DataviewBackend.prototype.search = function (mapConfigProvider, user, params, ca
            dataview.search(pg, userQuery, this);
        },
        function returnCallback(err, result) {
-            return callback(err, result, timer.getTimes());
+            return callback(err, result);
        }
    );
 };

-function getAnalysisDefinition(mapConfigAnalyses, sourceId) {
-    mapConfigAnalyses = mapConfigAnalyses || [];
-    for (var i = 0; i < mapConfigAnalyses.length; i++) {
-        var analysisGraph = new camshaft.reference.AnalysisGraph(mapConfigAnalyses[i]);
-        var nodes = analysisGraph.getNodesWithId();
-        if (nodes.hasOwnProperty(sourceId)) {
-            return mapConfigAnalyses[i];
-        }
-    }
-    throw new Error('There is no associated analysis for the dataview source id');
-}
-
 function getDataviewDefinition(mapConfig, dataviewName) {
    var dataviews = mapConfig.dataviews || {};
    return dataviews[dataviewName];
--- a/lib/cartodb/backends/template_maps.js
+++ b/lib/cartodb/backends/template_maps.js
@@ -55,11 +55,9 @@ util.inherits(TemplateMaps, EventEmitter);
 module.exports = TemplateMaps;


-var o = TemplateMaps.prototype;
-
 //--------------- PRIVATE METHODS --------------------------------

-o._userTemplateLimit = function() {
+TemplateMaps.prototype._userTemplateLimit = function() {
  return this.opts.max_user_templates || 0;
 };

@@ -70,7 +68,7 @@ o._userTemplateLimit = function() {
 * @param redisArgs - the arguments for the redis function in an array
 * @param callback - function to pass results too.
 */
-o._redisCmd = function(redisFunc, redisArgs, callback) {
+TemplateMaps.prototype._redisCmd = function(redisFunc, redisArgs, callback) {
  var redisClient;
  var that = this;
  var db = that.db_signatures;
@@ -97,7 +95,7 @@ o._redisCmd = function(redisFunc, redisArgs, callback) {
 var _reValidNameIdentifier = /^[a-z0-9][0-9a-z_\-]*$/i;
 var _reValidPlaceholderIdentifier = /^[a-z][0-9a-z_]*$/i;
 // jshint maxcomplexity:15
-o._checkInvalidTemplate = function(template) {
+TemplateMaps.prototype._checkInvalidTemplate = function(template) {
  if ( template.version !== '0.0.1' ) {
    return new Error("Unsupported template version " + template.version);
  }
@@ -200,7 +198,7 @@ function templateDefaults(template) {
 // @param callback function(err, tpl_id)
 //        Return template identifier (only valid for given user)
 //
-o.addTemplate = function(owner, template, callback) {
+TemplateMaps.prototype.addTemplate = function(owner, template, callback) {
    var self = this;

    template = templateDefaults(template);
@@ -258,7 +256,7 @@ o.addTemplate = function(owner, template, callback) {
 //
 // @param callback function(err)
 //
-o.delTemplate = function(owner, tpl_id, callback) {
+TemplateMaps.prototype.delTemplate = function(owner, tpl_id, callback) {
    var self = this;
    step(
        function deleteTemplate() {
@@ -297,7 +295,8 @@ o.delTemplate = function(owner, tpl_id, callback) {
 //
 // @param callback function(err)
 //
-o.updTemplate = function(owner, tpl_id, template, callback) {
+TemplateMaps.prototype.updTemplate = function(owner, tpl_id, template, callback) {
+    
    var self = this;

    template = templateDefaults(template);
@@ -356,7 +355,7 @@ o.updTemplate = function(owner, tpl_id, template, callback) {
 // @param callback function(err, tpl_id_list)
 //        Returns a list of template identifiers
 //
-o.listTemplates = function(owner, callback) {
+TemplateMaps.prototype.listTemplates = function(owner, callback) {
    this._redisCmd('HKEYS', [ this.key_usr_tpl({owner:owner}) ], callback);
 };

@@ -370,7 +369,7 @@ o.listTemplates = function(owner, callback) {
 // @param callback function(err, template)
 //        Return full template definition
 //
-o.getTemplate = function(owner, tpl_id, callback) {
+TemplateMaps.prototype.getTemplate = function(owner, tpl_id, callback) {
    var self = this;
    step(
        function getTemplate() {
@@ -386,7 +385,7 @@ o.getTemplate = function(owner, tpl_id, callback) {
    );
 };

-o.isAuthorized = function(template, authTokens) {
+TemplateMaps.prototype.isAuthorized = function(template, authTokens) {
    if (!template) {
        return false;
    }
@@ -438,7 +437,7 @@ function _replaceVars (str, params) {
    });
    return str;
 }
-o.instance = function(template, params) {
+TemplateMaps.prototype.instance = function(template, params) {
  var all_params = {};
  var phold = template.placeholders || {};
  Object.keys(phold).forEach(function(k) {
@@ -500,7 +499,7 @@ o.instance = function(template, params) {
 };

 // Return a fingerPrint of the object
-o.fingerPrint = function(template) {
+TemplateMaps.prototype.fingerPrint = function(template) {
  return crypto.createHash('md5')
    .update(JSON.stringify(template))
    .digest('hex')
--- a/lib/cartodb/backends/turbo-carto-postgres-datasource.js
+++ b/lib/cartodb/backends/turbo-carto-postgres-datasource.js
@@ -6,6 +6,9 @@ dot.templateSettings.strip = false;
 function createTemplate(method) {
    return dot.template([
        'SELECT',
+        'min({{=it._column}}) min_val,',
+        'max({{=it._column}}) max_val,',
+        'avg({{=it._column}}) avg_val,',
        method,
        'FROM ({{=it._sql}}) _table_sql WHERE {{=it._column}} IS NOT NULL'
    ].join('\n'));
@@ -29,17 +32,12 @@ methodTemplates.category = dot.template([
    '  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',
+    '  ORDER BY 2 DESC, 1 ASC',
    '),',
    'agg_categories AS (',
-    '  SELECT \'__other\' category',
+    '  SELECT category',
    '  FROM categories',
-    '  WHERE rank >= {{=it._buckets}}',
-    '  GROUP BY 1',
-    '  UNION ALL',
-    '  SELECT CAST(category AS text)',
-    '  FROM categories',
-    '  WHERE rank < {{=it._buckets}}',
+    '  WHERE rank <= {{=it._buckets}}',
    ')',
    'SELECT array_agg(category) AS category FROM agg_categories'
 ].join('\n'));
@@ -54,9 +52,8 @@ var method2strategy = {
    category: STRATEGY.EXACT
 };

-function PostgresDatasource (pgQueryRunner, username, query) {
-    this.pgQueryRunner = pgQueryRunner;
-    this.username = username;
+function PostgresDatasource (psql, query) {
+    this.psql = psql;
    this.query = query;
 }

@@ -75,21 +72,39 @@ PostgresDatasource.prototype.getRamp = function (column, buckets, method, callba

    var query = template({ _column: column, _sql: this.query, _buckets: buckets });

-    this.pgQueryRunner.run(this.username, query, function (err, result) {
+    this.psql.query(query, function (err, resultSet) {
        if (err) {
            return callback(err);
        }

+        var result = getResult(resultSet);
        var strategy = method2strategy[methodName];
-        var ramp = result[0][methodName];
+        var ramp = result[methodName] || [];
+        var stats = {
+            min_val: result.min_val,
+            max_val: result.max_val,
+            avg_val: result.avg_val
+        };
+        // Skip null values from ramp
+        // Generated turbo-carto won't be correct, but better to keep it working than failing
+        // TODO fix cartodb-postgres extension quantification functions
+        ramp = ramp.filter(function(value) { return value !== null; });
        if (strategy !== STRATEGY.EXACT) {
            ramp = ramp.sort(function(a, b) {
                return a - b;
            });
        }

-        return callback(null, { ramp: ramp, strategy: strategy });
-    });
+        return callback(null, { ramp: ramp, strategy: strategy, stats: stats });
+    }, true); // use read-only transaction
 };

+function getResult(resultSet) {
+    resultSet = resultSet || {};
+    var result = resultSet.rows || [];
+    result = result[0] || {};
+
+    return result;
+}
+
 module.exports = PostgresDatasource;
--- a/lib/cartodb/controllers/analyses.js
+++ b/lib/cartodb/controllers/analyses.js
@@ -0,0 +1,169 @@
+var step = require('step');
+var assert = require('assert');
+var dot = require('dot');
+dot.templateSettings.strip = false;
+var PSQL = require('cartodb-psql');
+
+var util = require('util');
+var BaseController = require('./base');
+
+var cors = require('../middleware/cors');
+var userMiddleware = require('../middleware/user');
+
+function AnalysesController(authApi, pgConnection) {
+    BaseController.call(this, authApi, pgConnection);
+}
+
+util.inherits(AnalysesController, BaseController);
+
+module.exports = AnalysesController;
+
+AnalysesController.prototype.register = function(app) {
+    app.get(app.base_url_mapconfig + '/analyses/catalog', cors(), userMiddleware, this.catalog.bind(this));
+};
+
+AnalysesController.prototype.sendResponse = function(req, res, resource) {
+    res.set('Cache-Control', 'public,max-age=10,must-revalidate');
+    this.send(req, res, resource, 200);
+};
+
+AnalysesController.prototype.catalog = function(req, res) {
+    var self = this;
+    var username = req.context.user;
+
+    step(
+        function reqParams() {
+            self.req2params(req, this);
+        },
+        function catalogQuery(err) {
+            assert.ifError(err);
+            var pg = new PSQL(dbParamsFromReqParams(req.params));
+            getMetadata(username, pg, this);
+        },
+        function prepareResponse(err, results) {
+            assert.ifError(err);
+
+            var analysisIdToTable = results.tables.reduce(function(analysisIdToTable, table) {
+                var analysisId = table.relname.split('_')[2];
+                if (analysisId && analysisId.length === 40) {
+                    analysisIdToTable[analysisId] = table;
+                }
+                return analysisIdToTable;
+            }, {});
+
+            var catalogWithTables = results.catalog.map(function(analysis) {
+                if (analysisIdToTable.hasOwnProperty(analysis.node_id)) {
+                    analysis.table = analysisIdToTable[analysis.node_id];
+                }
+                return analysis;
+            });
+
+            return catalogWithTables.sort(function(analysisA, analysisB) {
+                if (!!analysisA.table && !!analysisB.table) {
+                    return analysisB.table.size - analysisA.table.size;
+                }
+
+                if (!!analysisA.table) {
+                    return -1;
+                }
+
+                if (!!analysisB.table) {
+                    return 1;
+                }
+
+                return -1;
+            });
+        },
+        function sendResponse(err, catalogWithTables) {
+            if (err) {
+                if (err.message.match(/permission\sdenied/)) {
+                    err = new Error('Unauthorized');
+                    err.http_status = 401;
+                }
+                self.sendError(req, res, err);
+            } else {
+                self.sendResponse(req, res, { catalog: catalogWithTables });
+            }
+        }
+    );
+};
+
+var catalogQueryTpl = dot.template(
+    'SELECT analysis_def->>\'type\' as type, * FROM cartodb.cdb_analysis_catalog WHERE username = \'{{=it._username}}\''
+);
+
+var tablesQueryTpl = dot.template([
+    "WITH analysis_tables AS (",
+    "    SELECT",
+    "        n.nspname AS nspname,",
+    "        c.relname AS relname,",
+    "        pg_total_relation_size(",
+    "            format('%s.%s', pg_catalog.quote_ident(n.nspname), pg_catalog.quote_ident(c.relname))",
+    "        ) AS size,",
+    "        format('%s.%s', pg_catalog.quote_ident(nspname), pg_catalog.quote_ident(relname)) AS fully_qualified_name",
+    "    FROM pg_catalog.pg_class c, pg_catalog.pg_namespace n",
+    "    WHERE c.relnamespace = n.oid",
+    "    AND pg_catalog.quote_ident(c.relname) ~ '^analysis_[a-z0-9]{10}_[a-z0-9]{40}$'",
+    "    AND n.nspname IN ('{{=it._username}}', 'public')",
+    ")",
+    "SELECT *, pg_size_pretty(size) as size_pretty",
+    "FROM analysis_tables",
+    "ORDER BY size DESC"
+].join('\n'));
+
+
+function getMetadata(username, pg, callback) {
+    var results = {
+        catalog: [],
+        tables: []
+    };
+    step(
+        function getCatalog() {
+            pg.query(catalogQueryTpl({_username: username}), this, true); // use read-only transaction
+        },
+        function handleCatalog(err, resultSet) {
+            assert.ifError(err);
+            resultSet = resultSet || {};
+            results.catalog = resultSet.rows || [];
+            this();
+        },
+        function getTables(err) {
+            assert.ifError(err);
+            pg.query(tablesQueryTpl({_username: username}), this, true); // use read-only transaction
+        },
+        function handleTables(err, resultSet) {
+            assert.ifError(err);
+            resultSet = resultSet || {};
+            results.tables = resultSet.rows || [];
+            this();
+        },
+        function finish(err) {
+            if (err) {
+                return callback(err);
+            }
+
+            return callback(null, results);
+        }
+    );
+}
+
+
+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;
+}
--- a/lib/cartodb/controllers/base.js
+++ b/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,32 @@ 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';
+
+    var error = {
+        type: err.type || 'unknown',
+        message: stripConnectionInfo(message),
+    };
+
+    for (var prop in err) {
+        // type & message are properties from Error's prototype and will be skipped
+        if (err.hasOwnProperty(prop)) {
+            error[prop] = err[prop];
+        }
+    }
+
+    return error;
+}
 module.exports.errorMessage = errorMessage;

 function findStatusCode(err) {
--- a/lib/cartodb/controllers/index.js
+++ b/lib/cartodb/controllers/index.js
@@ -1,4 +1,5 @@
 module.exports = {
+    Analyses: require('./analyses'),
    Layergroup: require('./layergroup'),
    Map: require('./map'),
    NamedMaps: require('./named_maps'),
--- a/lib/cartodb/controllers/layergroup.js
+++ b/lib/cartodb/controllers/layergroup.js
@@ -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;

--- a/lib/cartodb/controllers/map.js
+++ b/lib/cartodb/controllers/map.js
@@ -135,6 +135,7 @@ MapController.prototype.create = function(req, res, prepareConfigFn) {
        function prepareAdapterMapConfig(err, requestMapConfig) {
            assert.ifError(err);
            context.analysisConfiguration = {
+                user: req.context.user,
                db: {
                    host: req.params.dbhost,
                    port: req.params.dbport,
@@ -161,15 +162,34 @@ MapController.prototype.create = function(req, res, prepareConfigFn) {
        },
        function afterLayergroupCreate(err, layergroup) {
            assert.ifError(err);
-            var analysesResults = context.analysesResults || [];
-            self.afterLayergroupCreate(req, res, mapConfig, analysesResults, layergroup, this);
+            self.afterLayergroupCreate(req, res, mapConfig, layergroup, context.analysesResults, this);
        },
        function finish(err, layergroup) {
            if (err) {
+                if (Number.isFinite(err.layerIndex)) {
+                    var error = new Error(err.message);
+                    error.http_status = err.http_status;
+
+                    if (!err.http_status && err.message.indexOf('column "the_geom_webmercator" does not exist') >= 0) {
+                        error.http_status = 400;
+                    }
+
+                    error.type = 'layer';
+                    error.subtype = err.message.indexOf('Postgis Plugin') >= 0 ? 'query' : undefined;
+                    error.layer = {
+                        id: mapConfig.getLayerId(err.layerIndex),
+                        index: err.layerIndex,
+                        type: mapConfig.layerType(err.layerIndex)
+                    };
+
+                    err = error;
+                }
                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);
+                addContextMetadata(layergroup, mapConfig.obj(), context);
                res.set('X-Layergroup-Id', layergroup.layergroupid);
                self.send(req, res, layergroup, 200);
            }
@@ -177,6 +197,17 @@ MapController.prototype.create = function(req, res, prepareConfigFn) {
    );
 };

+function addContextMetadata(layergroup, mapConfig, context) {
+    if (layergroup.metadata && Array.isArray(layergroup.metadata.layers) && Array.isArray(mapConfig.layers)) {
+        layergroup.metadata.layers = layergroup.metadata.layers.map(function(layer, layerIndex) {
+            if (context.turboCarto && Array.isArray(context.turboCarto.layers)) {
+                layer.meta.cartocss_meta = context.turboCarto.layers[layerIndex];
+            }
+            return layer;
+        });
+    }
+}
+
 MapController.prototype.instantiateTemplate = function(req, res, prepareParamsFn) {
    var self = this;

@@ -219,7 +250,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) {
@@ -228,9 +259,10 @@ 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());
+                var _mapConfig = mapConfig.obj();
+                addDataviewsAndWidgetsUrls(cdbuser, layergroup, _mapConfig);
                addAnalysesMetadata(cdbuser, layergroup, mapConfigProvider.analysesResults);
+                addContextMetadata(layergroup, _mapConfig, mapConfigProvider.context);

                res.set('X-Layergroup-Id', layergroup.layergroupid);
                self.surrogateKeysCache.tag(res, new NamedMapsCacheEntry(cdbuser, mapConfigProvider.getTemplateName()));
@@ -241,8 +273,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;
@@ -301,14 +332,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');
@@ -327,24 +357,41 @@ 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.getNodes().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 || [];
    layergroup.metadata.analyses = [];

    analysesResults.forEach(function(analysis) {
-        var nodes = analysis.getSortedNodes();
+        var nodes = analysis.getNodes();
        layergroup.metadata.analyses.push({
            nodes: nodes.reduce(function(nodesIdMap, node) {
                if (node.params.id) {
                    var nodeResource = layergroup.layergroupid + '/analysis/node/' + node.id();
-                    nodesIdMap[node.params.id] = {
+                    var nodeRepr = {
                        status: node.getStatus(),
                        url: getUrls(username, nodeResource)
                    };
                    if (includeQuery) {
-                        nodesIdMap[node.params.id].query = node.getQuery();
+                        nodeRepr.query = node.getQuery();
                    }
+                    if (node.getStatus() === 'failed') {
+                        nodeRepr.error_message = node.getErrorMessage();
+                    }
+                    nodesIdMap[node.params.id] = nodeRepr;
                }

                return nodesIdMap;
@@ -353,6 +400,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 || {};
@@ -365,20 +418,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) {
--- a/lib/cartodb/controllers/named_maps.js
+++ b/lib/cartodb/controllers/named_maps.js
@@ -137,9 +137,15 @@ NamedMapsController.prototype.staticMap = function(req, res) {
                this
            );
        },
-        function prepareImageOptions(err, _namedMapProvider) {
+        function prepareLayerVisibility(err, _namedMapProvider) {
            assert.ifError(err);
+
            namedMapProvider = _namedMapProvider;
+
+            self.prepareLayerFilterFromPreviewLayers(cdbUser, req, namedMapProvider, this);
+        },
+        function prepareImageOptions(err) {
+            assert.ifError(err);
            self.getStaticImageOptions(cdbUser, req.params, namedMapProvider, this);
        },
        function getImage(err, imageOpts) {
@@ -184,6 +190,45 @@ NamedMapsController.prototype.staticMap = function(req, res) {
    );
 };

+NamedMapsController.prototype.prepareLayerFilterFromPreviewLayers = function (user, req, namedMapProvider, callback) {
+    var self = this;
+    namedMapProvider.getTemplate(function (err, template) {
+        if (err) {
+            return callback(err);
+        }
+
+        if (!template || !template.view || !template.view.preview_layers) {
+           return callback();
+        }
+
+        var previewLayers = template.view.preview_layers;
+        var layerVisibilityFilter = [];
+
+        template.layergroup.layers.forEach(function (layer, index) {
+            if (previewLayers[''+index] !== false && previewLayers[layer.id] !== false) {
+                layerVisibilityFilter.push(''+index);
+            }
+        });
+
+        if (!layerVisibilityFilter.length) {
+            return callback();
+        }
+
+        // overwrites 'all' default filter
+        req.params.layer = layerVisibilityFilter.join(',');
+
+        // recreates the provider
+        self.namedMapProviderCache.get(
+            user,
+            req.params.template_id,
+            req.query.config,
+            req.query.auth_token,
+            req.params,
+            callback
+        );
+    });
+};
+
 var DEFAULT_ZOOM_CENTER = {
    zoom: 1,
    center: {
--- a/lib/cartodb/controllers/server_info.js
+++ b/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) {
--- a/lib/cartodb/models/dataview/aggregation.js
+++ b/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,
--- a/lib/cartodb/models/dataview/formula.js
+++ b/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 = {};
--- a/lib/cartodb/models/dataview/histogram.js
+++ b/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;
 }
--- a/lib/cartodb/models/dataview/list.js
+++ b/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;
    }
--- a/lib/cartodb/models/dataview/overviews/aggregation.js
+++ b/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
+    });
+};
--- a/lib/cartodb/models/dataview/overviews/base.js
+++ b/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();
+};
--- a/lib/cartodb/models/dataview/overviews/formula.js
+++ b/lib/cartodb/models/dataview/overviews/formula.js
@@ -1,9 +1,6 @@
-var _ = require('underscore');
-var BaseWidget = require('../base');
+var BaseOverviewsDataview = require('./base');
 var BaseDataview = require('../formula');

-var debug = require('debug')('windshaft:widget:formula:overviews');
-
 var dot = require('dot');
 dot.templateSettings.strip = false;

@@ -29,76 +26,31 @@ var formulaQueryTpls = {
 };

 function Formula(query, options, queryRewriter, queryRewriteData, params) {
-    this.base_dataview = new BaseDataview(query, options);
-    this.query = query;
+    BaseOverviewsDataview.call(this, query, options, BaseDataview, queryRewriter, queryRewriteData, params);
    this.column = options.column || '1';
    this.operation = options.operation;
-    this.queryRewriter = queryRewriter;
-    this.queryRewriteData = queryRewriteData;
-    this.options = params;
 }

-Formula.prototype = new BaseWidget();
+Formula.prototype = Object.create(BaseOverviewsDataview.prototype);
 Formula.prototype.constructor = Formula;

 module.exports = Formula;

-var zoom_level_factor = 100.0;
-
-// Compute zoom level so that the the resolution grid size of the
-// selected overview is smaller (zoom_level_factor times smaller at least)
-// than the bounding box size.
-function zoom_level_for_bbox(bbox) {
-    var px_per_tile = 256.0;
-    var earth_width = 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 bbox_values = _.map(bbox.split(','), function(v) { return +v; });
-      var w = Math.abs(bbox_values[2]-bbox_values[0]);
-      var h = Math.abs(bbox_values[3]-bbox_values[1]);
-      var max_dim = 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(max_dim*px_per_tile/earth_width/zoom_level_factor)/Math.log(2.0));
-      return Math.max(z, 0);
-    }
-    return 0;
-}
-
 Formula.prototype.sql = function(psql, filters, override, callback) {
-    var _query = this.query;
    var formulaQueryTpl = formulaQueryTpls[this.operation];

    if ( formulaQueryTpl ) {
        // supported formula for use with overviews
-        var zoom_level = zoom_level_for_bbox(this.options.bbox);
-        _query = this.queryRewriter.query(_query, this.queryRewriteData, { zoom_level: zoom_level });
        var formulaSql = formulaQueryTpl({
-            _query: _query,
+            _query:     this.rewrittenQuery(this.query),
            _operation: this.operation,
-            _column: this.column
+            _column:    this.column
        });
-        debug(formulaSql);
        callback = callback || override;

        return callback(null, formulaSql);
    }

-    // For non supported operations (min, max) we're not using overviews.
-    return this.base_dataview.sql(psql, filters, override, callback);
-};
-
-Formula.prototype.format = function(result) {
-    return this.base_dataview.format(result);
-};
-
-Formula.prototype.getType = function() {
-    return this.base_dataview.getType();
-};
-
-Formula.prototype.toString = function() {
-    return this.base_dataview.toString();
+    // default behaviour
+    return this.defaultSql(psql, filters, override, callback);
 };
--- a/lib/cartodb/models/dataview/overviews/histogram.js
+++ b/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);
+};
--- a/lib/cartodb/models/dataview/overviews/index.js
+++ b/lib/cartodb/models/dataview/overviews/index.js
@@ -1,3 +1,6 @@
 module.exports = {
-    Formula: require('./formula')
+  Aggregation: require('./aggregation'),
+  Formula: require('./formula'),
+  Histogram: require('./histogram'),
+  List: require('./list')
 };
--- a/lib/cartodb/models/dataview/overviews/list.js
+++ b/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;
--- a/lib/cartodb/models/filter/analysis.js
+++ b/lib/cartodb/models/filter/analysis.js
@@ -1,6 +1,6 @@
 var filters = {
-    category: require('./camshaft/category'),
-    range: require('./camshaft/range')
+    category: require('./analysis/category'),
+    range: require('./analysis/range')
 };

 function createFilter(filterDefinition) {
@@ -11,11 +11,11 @@ function createFilter(filterDefinition) {
    return new filters[filterType](filterDefinition.column, filterDefinition.params);
 }

-function CamshaftFilters(filters) {
+function AnalysisFilters(filters) {
    this.filters = filters;
 }

-CamshaftFilters.prototype.sql = function(rawSql) {
+AnalysisFilters.prototype.sql = function(rawSql) {
  var filters = this.filters || {};
  var applyFilters = {};

@@ -32,4 +32,4 @@ CamshaftFilters.prototype.sql = function(rawSql) {
      }, rawSql);
 };

-module.exports = CamshaftFilters;
+module.exports = AnalysisFilters;
--- a/lib/cartodb/models/filter/analysis/category.js
+++ b/lib/cartodb/models/filter/analysis/category.js
@@ -6,7 +6,7 @@ dot.templateSettings.strip = false;

 var filterQueryTpl = dot.template([
    'SELECT *',
-    'FROM ({{=it._sql}}) _camshaft_category_filter',
+    'FROM ({{=it._sql}}) _analysis_category_filter',
    'WHERE {{=it._filters}}'
 ].join('\n'));
 var escapeStringTpl = dot.template('$escape_{{=it._i}}${{=it._value}}$escape_{{=it._i}}$');
--- a/lib/cartodb/models/filter/analysis/range.js
+++ b/lib/cartodb/models/filter/analysis/range.js
@@ -6,7 +6,7 @@ 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}}');
+var filterQueryTpl = dot.template('SELECT * FROM ({{=it._sql}}) _analysis_range_filter WHERE {{=it._filter}}');

 function Range(column, filterParams) {
    this.column = column;
--- a/lib/cartodb/models/mapconfig/adapter/analysis-mapconfig-adapter.js
+++ b/lib/cartodb/models/mapconfig/adapter/analysis-mapconfig-adapter.js
@@ -59,10 +59,23 @@ AnalysisMapConfigAdapter.prototype.getMapConfig = function(user, requestMapConfi
    requestMapConfig = appendFiltersToNodes(requestMapConfig, dataviewsFiltersBySourceId);

    function createAnalysis(analysisDefinition, done) {
-        self.analysisBackend.create(analysisConfiguration, analysisDefinition, done);
+        self.analysisBackend.create(analysisConfiguration, analysisDefinition, function (err, analysis) {
+            if (err) {
+                var error = new Error(err.message);
+                error.type = 'analysis';
+                error.analysis = {
+                    id: analysisDefinition.id,
+                    node_id: err.node_id,
+                    type: analysisDefinition.type
+                };
+                return done(error);
+            }
+
+            done(null, analysis);
+        });
    }

-    var analysesQueue = queue(requestMapConfig.analyses.length);
+    var analysesQueue = queue(1);
    requestMapConfig.analyses.forEach(function(analysis) {
        analysesQueue.defer(createAnalysis, analysis);
    });
@@ -78,7 +91,7 @@ AnalysisMapConfigAdapter.prototype.getMapConfig = function(user, requestMapConfi
                sourceId2Query[rootNode.params.id] = rootNode;
            }

-            analysis.getSortedNodes().forEach(function(node) {
+            analysis.getNodes().forEach(function(node) {
                if (node.params && node.params.id) {
                    sourceId2Query[node.params.id] = node;
                }
@@ -101,10 +114,7 @@ AnalysisMapConfigAdapter.prototype.getMapConfig = function(user, requestMapConfi
                        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));
-                    }, []);
+                    layer.options.columns = getDataviewsColumns(getLayerDataviews(layer, dataviews));
                } else {
                    missingNodesErrors.push(
                        new Error('Missing analysis node.id="' + layerSourceId +'" for layer='+layerIndex)
@@ -114,12 +124,37 @@ AnalysisMapConfigAdapter.prototype.getMapConfig = function(user, requestMapConfi
            return layer;
        });

-        debug('mapconfig output', JSON.stringify(requestMapConfig, null, 4));
-
-        if (missingNodesErrors.length > 0) {
-            return callback(missingNodesErrors);
+        var missingDataviewsNodesErrors = getMissingDataviewsSourceIds(dataviews, sourceId2Node);
+        if (missingNodesErrors.length > 0 || missingDataviewsNodesErrors.length > 0) {
+            return callback(missingNodesErrors.concat(missingDataviewsNodesErrors));
        }

+        // Augment dataviews with sql from analyses
+        Object.keys(dataviews).forEach(function(dataviewName) {
+            var dataview = requestMapConfig.dataviews[dataviewName];
+            var dataviewSourceId = dataview.source.id;
+            var dataviewNode = sourceId2Node[dataviewSourceId];
+            dataview.node = {
+                type: dataviewNode.type,
+                filters: dataviewNode.getFilters()
+            };
+            dataview.sql = {
+                own_filter_on: dataviewQuery(dataviewNode, dataviewName, true),
+                own_filter_off: dataviewQuery(dataviewNode, dataviewName, false),
+                no_filters: dataviewNode.getQuery(Object.keys(dataviewNode.getFilters())
+                    .reduce(function(applyFilters, filterId) {
+                        applyFilters[filterId] = false;
+                        return applyFilters;
+                    }, {})
+                )
+            };
+        });
+        if (Object.keys(dataviews).length > 0) {
+            requestMapConfig.dataviews = dataviews;
+        }
+
+        debug('mapconfig output', JSON.stringify(requestMapConfig, null, 4));
+
        context.analysesResults = analysesResults;

        return callback(null, requestMapConfig);
@@ -136,7 +171,7 @@ function skipColumns(columnNames) {
        .filter(function(columnName) { return !SKIP_COLUMNS[columnName]; });
 }

-var layerQueryTemplate = dot.template([
+var wrappedQueryTpl = dot.template([
    'SELECT {{=it._columns}}',
    'FROM ({{=it._query}}) _cdb_analysis_query'
 ].join('\n'));
@@ -146,7 +181,20 @@ function layerQuery(node) {
        return node.getQuery();
    }
    var _columns = ['ST_Transform(the_geom, 3857) the_geom_webmercator'].concat(skipColumns(node.getColumns()));
-    return layerQueryTemplate({ _query: node.getQuery(), _columns: _columns.join(', ') });
+    return wrappedQueryTpl({ _query: node.getQuery(), _columns: _columns.join(', ') });
+}
+
+function dataviewQuery(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 wrappedQueryTpl({ _query: node.getQuery(applyFilters), _columns: _columns.join(', ') });
 }

 function appendFiltersToNodes(requestMapConfig, dataviewsFiltersBySourceId) {
@@ -166,8 +214,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 = {
@@ -208,11 +257,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]);
        }
    });
@@ -224,6 +284,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) {
@@ -239,3 +308,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);
--- a/lib/cartodb/models/mapconfig/adapter/dataviews-widgets-adapter.js
+++ b/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;
+}
--- a/lib/cartodb/models/mapconfig/adapter/mapconfig-overviews-adapter.js
+++ b/lib/cartodb/models/mapconfig/adapter/mapconfig-overviews-adapter.js
@@ -72,7 +72,7 @@ MapConfigOverviewsAdapter.prototype.getMapConfig = function(user, requestMapConf
                           layer = _.extend({}, layer);
                           layer.options = _.extend({}, layer.options, { query_rewrite_data: query_rewrite_data });
                       }
-                       done(err, layer);
+                       done(null, layer);
                   }
               );
           }
--- a/lib/cartodb/models/mapconfig/adapter/turbo-carto-adapter.js
+++ b/lib/cartodb/models/mapconfig/adapter/turbo-carto-adapter.js
@@ -3,10 +3,15 @@
 var dot = require('dot');
 dot.templateSettings.strip = false;
 var queue = require('queue-async');
-var SubstitutionTokens = require('../../../utils/substitution-tokens');
+var PSQL = require('cartodb-psql');
+var turboCarto = require('turbo-carto');

-function TurboCartoAdapter(turboCartoParser) {
-    this.turboCartoParser = turboCartoParser;
+var SubstitutionTokens = require('../../../utils/substitution-tokens');
+var PostgresDatasource = require('../../../backends/turbo-carto-postgres-datasource');
+
+var MapConfig = require('windshaft').model.MapConfig;
+
+function TurboCartoAdapter() {
 }

 module.exports = TurboCartoAdapter;
@@ -22,38 +27,116 @@ TurboCartoAdapter.prototype.getMapConfig = function (user, requestMapConfig, par

    var parseCartoQueue = queue(layers.length);

-    layers.forEach(function(layer) {
-        parseCartoQueue.defer(self._parseCartoCss.bind(self), user, layer);
+    layers.forEach(function(layer, index) {
+        var layerId = MapConfig.getLayerId(requestMapConfig, index);
+        parseCartoQueue.defer(self._parseCartoCss.bind(self), user, params, layer, index, layerId);
    });

-    parseCartoQueue.awaitAll(function (err, layers) {
+    parseCartoQueue.awaitAll(function (err, results) {
        if (err) {
            return callback(err);
        }

-        requestMapConfig.layers = layers;
+        var errors = results.reduce(function(errors, result) {
+            if (result.error) {
+                errors.push(result.error);
+            }
+            return errors;
+        }, []);
+        if (errors.length > 0) {
+            return callback(errors);
+        }
+
+        requestMapConfig.layers = results.map(function(result) { return result.layer; });
+        context.turboCarto = {
+            layers: results.map(function(result) {
+                return result.meta;
+            })
+        };

        return callback(null, requestMapConfig);
    });
 };

-var bboxTemplate = dot.template('(select ST_SetSRID(st_extent(the_geom_webmercator), 3857) from ({{=it._sql}}) __c)');
-var zoomTemplate = dot.template([
-    'GREATEST(',
-    'ceil(log(40075017000 / 256 / GREATEST(',
-    '  st_xmax({{=it._bbox}}) - st_xmin({{=it._bbox}}),',
-    '  st_ymax({{=it._bbox}}) - st_ymin({{=it._bbox}})',
-    '))/log(2)),',
-    '0',
-    ')'
+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'));
-var pixelSizeTemplate = dot.template('40075017 * cos(ST_Y(ST_Centroid({{=it._bbox}}))) / 2 ^ (({{=it._zoom}}) + 8)');
-var scaleDenominatorTemplate = dot.template('({{=it._pixelSize}} / 0.00028)::numeric');

-
-TurboCartoAdapter.prototype._parseCartoCss = function (username, layer, callback) {
+TurboCartoAdapter.prototype._parseCartoCss = function (username, params, layer, layerIndex, layerId, callback) {
    if (!shouldParseLayerCartocss(layer)) {
-        return callback(null, layer);
+        return callback(null, { layer: layer });
+    }
+
+    var pg = new PSQL(dbParamsFromReqParams(params));
+    function processCallback(err, cartocss, meta) {
+        // Only return turbo-carto errors
+        if (err && err.name === 'TurboCartoError') {
+            var error = new Error(err.message);
+            error.http_status = 400;
+            error.type = 'layer';
+            error.subtype = 'turbo-carto';
+            error.layer = {
+                id: layerId,
+                index: layerIndex,
+                type: layer.type,
+                context: err.context
+            };
+
+            return callback(null, { error: error });
+        }
+
+        // Try to continue in the rest of the cases
+        if (cartocss) {
+            layer.options.cartocss = cartocss;
+        }
+        return callback(null, { layer: layer, meta: meta });
+    }
+
+    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) {
+                return processCallback(err);
+            }
+
+            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 = {
@@ -63,40 +146,35 @@ TurboCartoAdapter.prototype._parseCartoCss = function (username, layer, callback
        pixel_height: '156412'
    };

-    var layerSql = layer.options.sql;
-    var layerRawSql = layer.options.sql_raw;
-    if (SubstitutionTokens.hasTokens(layerSql) && layerRawSql) {
-        var bbox = bboxTemplate({ _sql: layerRawSql });
-        var zoom = zoomTemplate({ _bbox: bbox });
-        var pixelSize = pixelSizeTemplate({ _bbox: bbox, _zoom: zoom });
-        var scaleDenominator = scaleDenominatorTemplate({ _pixelSize: pixelSize });
-
-        tokens = {
-            bbox: bbox,
-            scale_denominator: scaleDenominator,
-            pixel_width: pixelSize,
-            pixel_height: pixelSize
-        };
-    }
-
    var sql = SubstitutionTokens.replace(layerSql, tokens);
+    this.process(pg, layer.options.cartocss, sql, processCallback);
+};

-    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);
-    });
+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;
+}
--- a/lib/cartodb/models/mapconfig/provider/named-map-provider.js
+++ b/lib/cartodb/models/mapconfig/provider/named-map-provider.js
@@ -95,6 +95,7 @@ NamedMapMapConfigProvider.prototype.getMapConfig = function(callback) {
        function prepareAdapterMapConfig(err, requestMapConfig) {
            assert.ifError(err);
            context.analysisConfiguration = {
+                user: self.owner,
                db: {
                    host: rendererParams.dbhost,
                    port: rendererParams.dbport,
@@ -119,6 +120,7 @@ NamedMapMapConfigProvider.prototype.getMapConfig = function(callback) {
            self.mapConfig = (mapConfig === null) ? null : new MapConfig(mapConfig, context.datasource);
            self.analysesResults = context.analysesResults || [];
            self.rendererParams = rendererParams;
+            self.context = context;
            self.context.limits = renderLimits || {};
            return callback(self.err, self.mapConfig, self.rendererParams, self.context);
        }
--- a/lib/cartodb/server.js
+++ b/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');

@@ -34,13 +33,12 @@ var AnalysisBackend = require('./backends/analysis');
 var timeoutErrorTilePath = __dirname + '/../../assets/render-timeout-fallback.png';
 var timeoutErrorTile = require('fs').readFileSync(timeoutErrorTilePath, {encoding: null});

-var TurboCartoParser = require('./utils/style/turbo-carto-parser');
-
 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) {
@@ -149,19 +147,19 @@ module.exports = function(serverOptions) {
    var tileBackend = new windshaft.backend.Tile(rendererCache);
    var mapValidatorBackend = new windshaft.backend.MapValidator(tileBackend, attributesBackend);
    var mapBackend = new windshaft.backend.Map(rendererCache, mapStore, mapValidatorBackend);
-    var analysisBackend = new AnalysisBackend(serverOptions.analysis);
+
+    var analysisBackend = new AnalysisBackend(metadataBackend, serverOptions.analysis);

    var layergroupAffectedTablesCache = new LayergroupAffectedTablesCache();
    app.layergroupAffectedTablesCache = layergroupAffectedTablesCache;

-    var turboCartoParser = new TurboCartoParser(pgQueryRunner);
-
    var mapConfigAdapter = new MapConfigAdapter(
        new MapConfigNamedLayersAdapter(templateMaps, pgConnection),
        new SqlWrapMapConfigAdapter(),
+        new DataviewsWidgetsAdapter(),
        new AnalysisMapConfigAdapter(analysisBackend),
        new MapConfigOverviewsAdapter(overviewsMetadataApi, filterStatsApi),
-        new TurboCartoAdapter(turboCartoParser)
+        new TurboCartoAdapter()
    );

    var namedMapProviderCache = new NamedMapProviderCache(
@@ -181,6 +179,8 @@ module.exports = function(serverOptions) {
    var TablesExtentApi = require('./api/tables_extent_api');
    var tablesExtentApi = new TablesExtentApi(pgQueryRunner);

+    var versions = getAndValidateVersions(serverOptions);
+
    /*******************************************************************************************************************
     * Routing
     ******************************************************************************************************************/
@@ -192,7 +192,6 @@ module.exports = function(serverOptions) {
        tileBackend,
        previewBackend,
        attributesBackend,
-        new windshaft.backend.Widget(),
        surrogateKeysCache,
        userLimitsApi,
        layergroupAffectedTablesCache,
@@ -224,7 +223,9 @@ module.exports = function(serverOptions) {

    new controller.NamedMapsAdmin(authApi, pgConnection, templateMaps).register(app);

-    new controller.ServerInfo().register(app);
+    new controller.Analyses(authApi, pgConnection).register(app);
+
+    new controller.ServerInfo(versions).register(app);

    /*******************************************************************************************************************
     * END Routing
@@ -237,12 +238,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) {
--- a/lib/cartodb/server_options.js
+++ b/lib/cartodb/server_options.js
@@ -36,7 +36,11 @@ var analysisConfig = _.defaults(global.environment.analysis || {}, {
        inlineExecution: false,
        endpoint: 'http://127.0.0.1:8080/api/v2/sql/job',
        hostHeaderTemplate: '{{=it.username}}.localhost.lan'
-    }
+    },
+    logger: {
+        filename: undefined
+    },
+    limits: {}
 });

 module.exports = {
@@ -95,7 +99,11 @@ module.exports = {
            inlineExecution: analysisConfig.batch.inlineExecution,
            endpoint: analysisConfig.batch.endpoint,
            hostHeaderTemplate: analysisConfig.batch.hostHeaderTemplate
-        }
+        },
+        logger: {
+            filename: analysisConfig.logger.filename
+        },
+        limits: analysisConfig.limits
    },
    // Do not send unwatch on release. See http://github.com/CartoDB/Windshaft-cartodb/issues/161
    redis: _.extend(global.environment.redis, {unwatchOnRelease: false}),
--- a/lib/cartodb/utils/overviews_query_rewriter.js
+++ b/lib/cartodb/utils/overviews_query_rewriter.js
@@ -2,7 +2,7 @@ var _ = require('underscore');
 var TableNameParser = require('./table_name_parser');

 var BBoxFilter = require('../models/filter/bbox');
-var CamshaftFilter = require('../models/filter/camshaft');
+var AnalysisFilter = require('../models/filter/analysis');

 // Minimim number of filtered rows to use overviews
 var FILTER_MIN_ROWS = 65536;
@@ -11,8 +11,8 @@ 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);
+        var analysisFilter = new AnalysisFilter(filters);
+        query = analysisFilter.sql(query);
    }
    if ( bbox_filter ) {
        var bboxFilter = new BBoxFilter(bbox_filter.options, bbox_filter.params);
--- a/lib/cartodb/utils/style/turbo-carto-parser.js
+++ b/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);
-};
--- a/npm-shrinkwrap.json
+++ b/npm-shrinkwrap.json
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
  "private": true,
  "name": "windshaft-cartodb",
-  "version": "2.44.0",
+  "version": "2.84.2",
  "description": "A map tile server for CartoDB",
  "keywords": [
    "cartodb"
@@ -20,26 +20,27 @@
  ],
  "dependencies": {
    "body-parser": "~1.14.0",
-    "camshaft": "0.11.0",
+    "camshaft": "0.48.3",
    "cartodb-psql": "~0.6.1",
    "cartodb-query-tables": "~0.1.0",
-    "cartodb-redis": "~0.13.0",
+    "cartodb-redis": "0.13.1",
    "debug": "~2.2.0",
    "dot": "~1.0.2",
    "express": "~4.13.3",
    "fastly-purge": "~1.0.1",
-    "log4js": "https://github.com/CartoDB/log4js-node/tarball/cdb",
+    "log4js": "cartodb/log4js-node#cdb",
    "lru-cache": "2.6.5",
-    "lzma": "~1.3.7",
+    "lzma": "~2.3.2",
    "node-statsd": "~0.0.7",
    "queue-async": "~1.0.7",
    "redis-mpool": "~0.4.0",
    "request": "~2.62.0",
    "step": "~0.0.6",
    "step-profiler": "~0.3.0",
-    "turbo-carto": "0.10.0",
+    "turbo-carto": "0.18.0",
    "underscore": "~1.6.0",
-    "windshaft": "1.19.0"
+    "windshaft": "2.6.2",
+    "yargs": "~5.0.0"
  },
  "devDependencies": {
    "istanbul": "~0.4.3",
--- a/run_tests.sh
+++ b/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
--- a/test/acceptance/analysis/analysis-layers.js
+++ b/test/acceptance/analysis/analysis-layers.js
@@ -202,7 +202,7 @@ describe('analysis-layers', function() {
            assert.equal(analyses.length, 1, 'Invalid number of analyses in metadata');
            var nodes = analyses[0].nodes;
            var nodesIds = Object.keys(nodes);
-            assert.deepEqual(nodesIds, ['2570e105-7b37-40d2-bdf4-1af889598745', 'HEAD']);
+            assert.deepEqual(nodesIds, ['HEAD', '2570e105-7b37-40d2-bdf4-1af889598745']);
            nodesIds.forEach(function(nodeId) {
                var node = nodes[nodeId];
                assert.ok(node.hasOwnProperty('url'), 'Missing "url" attribute in node');
--- a/test/acceptance/analysis/error-cases.js
+++ b/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,307 @@ 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].analysis.id, 'HEAD');
+            assert.equal(layergroupResult.errors_with_context[0].analysis.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": "HEAD2",
+                            "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].analysis.id, 'HEAD');
+            assert.equal(layergroupResult.errors_with_context[0].analysis.type, 'buffer');
+
+            testClient.drain(done);
+        });
+    });
+
+    it('should return missing param error of outer node indicating the node_id and 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": "HEAD2",
+                    "type": "buffer",
+                    "params": {
+                        "source": {
+                            "id": "HEAD3",
+                            "type": "source",
+                            "params": {
+                                "query": "select * from populated_places_simple_reduced"
+                            }
+                        },
+                        "radius": 10
+                    }
+                }
+            }
+            // radius: 'missing'
+        }]);
+
+        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].analysis.id, 'HEAD');
+            assert.equal(layergroupResult.errors_with_context[0].analysis.type, 'buffer');
+            assert.equal(layergroupResult.errors_with_context[0].analysis.node_id, 'HEAD');
+
+            testClient.drain(done);
+        });
+    });
+
+    it('should return invalid param type error of inner node indicating the node_id and 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": "HEAD2",
+                    "type": "buffer",
+                    "params": {
+                        "source": {
+                            "id": "HEAD3",
+                            "type": "source",
+                            "params": {
+                                "query": "select * from populated_places_simple_reduced"
+                            }
+                        },
+                        "radius": 'invalid_radius'
+                    }
+                },
+                "radius": 10
+            }
+        }]);
+
+        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],
+                'Invalid type for param "radius", expects "number" type, got `"invalid_radius"`'
+            );
+
+            assert.equal(layergroupResult.errors_with_context[0].type, 'analysis');
+            assert.equal(
+                layergroupResult.errors_with_context[0].message,
+                'Invalid type for param "radius", expects "number" type, got `"invalid_radius"`'
+            );
+            assert.equal(layergroupResult.errors_with_context[0].analysis.id, 'HEAD');
+            assert.equal(layergroupResult.errors_with_context[0].analysis.type, 'buffer');
+            assert.equal(layergroupResult.errors_with_context[0].analysis.node_id, 'HEAD2');
+
+            testClient.drain(done);
+        });
+    });
+
+
 });
--- a/test/acceptance/analysis/named-maps.js
+++ b/test/acceptance/analysis/named-maps.js
@@ -141,7 +141,7 @@ describe('named-maps analysis', function() {
                    assert.equal(analyses.length, 1, 'Invalid number of analyses in metadata');
                    var nodes = analyses[0].nodes;
                    var nodesIds = Object.keys(nodes);
-                    assert.deepEqual(nodesIds, ['2570e105-7b37-40d2-bdf4-1af889598745', 'HEAD']);
+                    assert.deepEqual(nodesIds, ['HEAD', '2570e105-7b37-40d2-bdf4-1af889598745']);
                    nodesIds.forEach(function(nodeId) {
                        var node = nodes[nodeId];
                        assert.ok(node.hasOwnProperty('url'), 'Missing "url" attribute in node');
--- a/test/acceptance/analysis/regressions.js
+++ b/test/acceptance/analysis/regressions.js
@@ -0,0 +1,115 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var TestClient = require('../../support/test-client');
+
+describe('analysis-layers regressions', function() {
+    it('should return a complete list of nodes from analysis', function(done) {
+        var mapConfig = {
+            "version": "1.5.0",
+            "layers": [
+                {
+                    "type": "cartodb",
+                    "options": {
+                        "cartocss": TestClient.CARTOCSS.POINTS,
+                        "cartocss_version": "2.1.1",
+                        "interactivity": [],
+                        "source": {
+                            "id": "a4"
+                        }
+                    }
+                },
+                {
+                    "type": "cartodb",
+                    "options": {
+                        "cartocss": TestClient.CARTOCSS.POINTS,
+                        "cartocss_version": "2.1.0",
+                        "interactivity": [],
+                        "source": {
+                            "id": "b1"
+                        }
+                    }
+                }
+            ],
+            "dataviews": {
+                "74493a30-4679-4b72-a60c-b6f808b57c98": {
+                    "type": "histogram",
+                    "source": {
+                        "id": "b0"
+                    },
+                    "options": {
+                        "column": "customer_value",
+                        "bins": 10
+                    }
+                }
+            },
+            "analyses": [
+                {
+                    "id": "a4",
+                    "type": "point-in-polygon",
+                    "params": {
+                        "polygons_source": {
+                            "id": "a3",
+                            "type": "buffer",
+                            "params": {
+                                "source": {
+                                    "id": "a2",
+                                    "type": "centroid",
+                                    "params": {
+                                        "source": {
+                                            "id": "b1",
+                                            "type": "kmeans",
+                                            "params": {
+                                                "source": {
+                                                    "id": "b0",
+                                                    "type": "source",
+                                                    "params": {
+                                                        "query": "SELECT * FROM populated_places_simple_reduced"
+                                                    }
+                                                },
+                                                "clusters": 5
+                                            }
+                                        },
+                                        "category_column": "cluster_no"
+                                    }
+                                },
+                                "radius": 200000
+                            }
+                        },
+                        "points_source": {
+                            "id": "customer_home_locations",
+                            "type": "source",
+                            "params": {
+                                "query": "SELECT * FROM populated_places_simple_reduced"
+                            }
+                        }
+                    }
+                }
+            ]
+        };
+
+        var testClient = new TestClient(mapConfig, 1234);
+
+        testClient.getLayergroup(function(err, layergroupResult) {
+            assert.ok(!err, err);
+
+            assert.ok(layergroupResult);
+            assert.ok(layergroupResult.metadata);
+            var analyses = layergroupResult.metadata.analyses;
+            assert.ok(analyses);
+            assert.equal(analyses.length, 1);
+
+            var expectedIds = ['customer_home_locations', 'b0', 'b1', 'a2', 'a3', 'a4'];
+            expectedIds.forEach(function(expectedId) {
+                assert.ok(
+                    analyses[0].nodes.hasOwnProperty(expectedId),
+                    'Missing "' + expectedId + '" from node list.'
+                );
+            });
+            assert.equal(Object.keys(analyses[0].nodes).length, expectedIds.length, Object.keys(analyses[0].nodes));
+
+            testClient.drain(done);
+        });
+    });
+
+});
--- a/test/acceptance/dataviews/aggregation.js
+++ b/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();
+            });
+        });
+    });
+});
--- a/test/acceptance/dataviews/error-cases.js
+++ b/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();
+        });
+    });
+});
--- a/test/acceptance/dataviews/histogram.js
+++ b/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();
+        });
+    });
+});
--- a/test/acceptance/errors-with-context.js
+++ b/test/acceptance/errors-with-context.js
@@ -0,0 +1,68 @@
+var assert = require('../support/assert');
+var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
+var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
+var server = new CartodbWindshaft(serverOptions);
+
+describe('error with context', function () {
+    var layerOK = {
+        options: {
+            sql: 'select cartodb_id, ST_Translate(the_geom_webmercator, 5e6, 0) as the_geom_webmercator ' +
+                 'from test_table',
+            cartocss: '#layer { marker-fill:red; marker-width:32; marker-allow-overlap:true; }',
+            cartocss_version: '2.0.1',
+            interactivity: 'cartodb_id'
+        }
+    };
+    var layerKO = {
+        options: {
+            sql: 'select cartodb_id from test_table offset 3', // it doesn't return the_geom_webmercator so it must fail
+            cartocss: '#layer { marker-fill:blue; marker-allow-overlap:true; }',
+            cartocss_version: '2.0.2',
+            interactivity: 'cartodb_id'
+        }
+    };
+
+    var DB_ERROR_MESSAGE = 'Postgis Plugin: ERROR:  column "the_geom_webmercator" does not exist';
+    var scenarios = [{
+        description: 'layergroup with 2 layers, second one has query error',
+        layergroup: {
+            version: '1.0.0',
+            layers: [layerOK, layerKO]
+        },
+        expectedFailingLayer: { id: 'layer1', index: 1, type: 'mapnik' }
+    }, {
+        description: 'layergroup with 2 layers, first one has query error',
+        layergroup: {
+            version: '1.0.0',
+            layers: [layerKO, layerOK]
+        },
+        expectedFailingLayer: { id: 'layer0', index: 0, type: 'mapnik' }
+    }];
+
+    scenarios.forEach(function (scenario) {
+        it(scenario.description, function (done) {
+            assert.response(server, {
+                url: '/api/v1/map',
+                method: 'POST',
+                headers: {
+                    host: 'localhost',
+                    'Content-Type': 'application/json'
+                },
+                data: JSON.stringify(scenario.layergroup)
+            }, {
+                status: 400
+            }, function (res) {
+                var parsedBody = JSON.parse(res.body);
+
+                assert.ok(Array.isArray(parsedBody.errors_with_context));
+
+                var err = parsedBody.errors_with_context[0];
+                assert.equal(err.type, 'layer');
+                assert.equal(err.subtype, 'query');
+                assert.ok(err.message.indexOf(DB_ERROR_MESSAGE) >= 0);
+                assert.deepEqual(err.layer, scenario.expectedFailingLayer);
+                done();
+            });
+        });
+    });
+});
--- a/test/acceptance/geojson-renderer.js
+++ b/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();
+        });
+    });
+
+});
--- a/test/acceptance/limits.js
+++ b/test/acceptance/limits.js
@@ -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();
                            }
                        );
--- a/test/acceptance/multilayer_server.js
+++ b/test/acceptance/multilayer_server.js
@@ -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();
            }
--- a/test/acceptance/named_layers.js
+++ b/test/acceptance/named_layers.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;
            },
--- a/test/acceptance/named_layers_visibility.js
+++ b/test/acceptance/named_layers_visibility.js
@@ -0,0 +1,210 @@
+var step = require('step');
+var test_helper = require('../support/test_helper');
+
+var assert = require('../support/assert');
+var CartodbWindshaft = require(__dirname + '/../../lib/cartodb/server');
+var serverOptions = require(__dirname + '/../../lib/cartodb/server_options');
+var server = new CartodbWindshaft(serverOptions);
+
+var RedisPool = require('redis-mpool');
+var TemplateMaps = require('../../lib/cartodb/backends/template_maps.js');
+var mapnik = require('windshaft').mapnik;
+
+var IMAGE_TOLERANCE = 20;
+
+describe('layers visibility for previews', function() {
+    // configure redis pool instance to use in tests
+    var redisPool = new RedisPool(global.environment.redis);
+    var templateMaps = new TemplateMaps(redisPool, {
+        max_user_templates: global.environment.maxUserTemplates
+    });
+
+    var username = 'localhost';
+
+    function createLayer (color, layerId) {
+        var mod;
+
+        if (color === 'red') {
+            mod = 0;
+        } else if (color === 'orange') {
+            mod = 1;
+        } else if (color === 'blue') {
+            mod = 2;
+        } else {
+            mod = 0;
+        }
+
+        return {
+            type: 'mapnik',
+            id: layerId,
+            options: {
+                sql: 'select * from populated_places_simple_reduced where cartodb_id % 3 = ' + mod,
+                cartocss: '#layer { marker-fill: ' + color + '; }',
+                cartocss_version: '2.3.0'
+            }
+        };
+    }
+
+    function createTemplate(scenario) {
+        return {
+            version: '0.0.1',
+            name: scenario.name,
+            auth: {
+                method: 'open'
+            },
+            view: {
+                bounds: {
+                    west: 0,
+                    south: 0,
+                    east: 45,
+                    north: 45
+                },
+                zoom: 4,
+                center: {
+                    lng: 40,
+                    lat: 20
+                },
+                preview_layers: scenario.layerPerview
+            },
+            layergroup: {
+                layers: scenario.layers
+            }
+        };
+    }
+
+    afterEach(function (done) {
+        test_helper.deleteRedisKeys({
+            'user:localhost:mapviews:global': 5
+        }, done);
+    });
+
+    function previewFixture(version) {
+        return './test/fixtures/previews/populated_places_simple_reduced-' + version + '.png';
+    }
+
+    var threeLayerPointDistintColor = [
+        createLayer('red'),
+        createLayer('orange'),
+        createLayer('blue', 'layer2')
+    ];
+
+    var scenarios = [{
+        name: 'preview_layers_red',
+        layerPerview: {
+            '0': true,
+            '1': false,
+            'layer2': false
+        },
+        layers: threeLayerPointDistintColor
+    }, {
+        name: 'preview_layers_orange',
+        layerPerview: {
+            '0': false,
+            '1': true,
+            'layer2': false
+        },
+        layers: threeLayerPointDistintColor
+    }, {
+        name: 'preview_layers_blue',
+        layerPerview: {
+            '0': false,
+            '1': false,
+            'layer2': true
+        },
+        layers: threeLayerPointDistintColor
+    }, {
+        name: 'preview_layers_red_orange',
+        layerPerview: {
+            '0': true,
+            '1': true,
+            'layer2': false
+        },
+        layers: threeLayerPointDistintColor
+    }, {
+        name: 'preview_layers_red_blue',
+        layerPerview: {
+            '0': true,
+            '1': false,
+            'layer2': true
+        },
+        layers: threeLayerPointDistintColor
+    }, {
+        name: 'preview_layers_orange_blue',
+        layerPerview: {
+            '0': false,
+            '1': true,
+            'layer2': true
+        },
+        layers: threeLayerPointDistintColor
+    }, {
+        name: 'preview_layers_red_orange_blue',
+        layerPerview: {
+            '0': true,
+            '1': true,
+            'layer2': true
+        },
+        layers: threeLayerPointDistintColor
+    }, {
+        name: 'preview_layers_all',
+        layerPerview: {},
+        layers: threeLayerPointDistintColor
+    },  {
+        name: 'preview_layers_undefined',
+        layerPerview: undefined,
+        layers: threeLayerPointDistintColor
+    }];
+
+    scenarios.forEach(function (scenario) {
+        it('should filter layers for template: ' + scenario.name, function (done) {
+            step(
+                function addTemplate () {
+                    var next = this;
+                    var template = createTemplate(scenario);
+
+                    templateMaps.addTemplate(username, template, next);
+                },
+                function requestPreview (err) {
+                    assert.ifError(err);
+
+                    var next = this;
+
+                    assert.response(server, {
+                        url: '/api/v1/map/static/named/' + scenario.name + '/640/480.png',
+                        method: 'GET',
+                        headers: {
+                            host: 'localhost'
+                        },
+                        encoding: 'binary'
+                    }, {
+                        status: 200,
+                        headers: {
+                            'content-type': 'image/png'
+                        }
+                    }, function (res, err) {
+                        next(err, res);
+                    });
+                },
+                function checkPreview (err, res) {
+                    assert.ifError(err);
+
+                    var next = this;
+                    var img = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
+                    var previewFixturePath = previewFixture(scenario.name);
+
+                    assert.imageIsSimilarToFile(img, previewFixturePath, IMAGE_TOLERANCE, next);
+                },
+                function deleteTemplate(err) {
+                    assert.ifError(err);
+
+                    var next = this;
+
+                    templateMaps.delTemplate(username, scenario.name, next);
+                },
+                function finish (err) {
+                    done(err);
+                }
+            );
+        });
+    });
+
+});
--- a/test/acceptance/named_maps_authentication.js
+++ b/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();
            });
        });
--- a/test/acceptance/named_maps_cache.js
+++ b/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
--- a/test/acceptance/ported/attributes.js
+++ b/test/acceptance/ported/attributes.js
@@ -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"' +
+                    '}]});'
                );
                return null;
            },
--- a/test/acceptance/ported/blend_http_fallback.js
+++ b/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();
        });
    });
--- a/test/acceptance/ported/external_resources.js
+++ b/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();
        });
    });

 });
-
--- a/test/acceptance/ported/multilayer_error_cases.js
+++ b/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"}]});'
            );
            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) {
--- a/test/acceptance/ported/raster.js
+++ b/test/acceptance/ported/raster.js
@@ -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();
            }
        );
    });

 });
-
--- a/test/acceptance/ported/regressions.js
+++ b/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);
            });
        });
--- a/test/acceptance/ported/retina.js
+++ b/test/acceptance/ported/retina.js
@@ -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();
            }
--- a/test/acceptance/ported/server.js
+++ b/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();
        });
    });
--- a/test/acceptance/templates.js
+++ b/test/acceptance/templates.js
@@ -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();
            };
--- a/test/acceptance/turbo-cartocss/anonymous-maps.js
+++ b/test/acceptance/turbo-cartocss/anonymous-maps.js
--- a/test/acceptance/turbo-carto/error-cases.js
+++ b/test/acceptance/turbo-carto/error-cases.js
@@ -0,0 +1,190 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var TestClient = require('../../support/test-client');
+
+function makeMapconfig(markerWidth, markerFill) {
+    return {
+        "version": "1.4.0",
+        "layers": [
+            {
+                "type": 'mapnik',
+                "options": {
+                    "cartocss_version": '2.3.0',
+                    "sql": 'SELECT * FROM populated_places_simple_reduced',
+                    "cartocss": createCartocss(markerWidth, markerFill)
+                }
+            }
+        ]
+    };
+}
+
+function createCartocss(markerWidth, markerFill) {
+    return [
+        "#populated_places_simple_reduced {",
+        "  marker-fill-opacity: 0.9;",
+        "  marker-line-color: #FFF;",
+        "  marker-line-width: 1;",
+        "  marker-line-opacity: 1;",
+        "  marker-placement: point;",
+        "  marker-type: ellipse;",
+        "  marker-allow-overlap: true;",
+        "  marker-width: " + (markerWidth || '10') + ";",
+        "  marker-fill: " + (markerFill || 'red') + ";",
+        "}"
+    ].join('\n');
+}
+
+var ERROR_RESPONSE = {
+    status: 400,
+    headers: {
+        'Content-Type': 'application/json; charset=utf-8'
+    }
+};
+
+describe('turbo-carto error cases', function() {
+    afterEach(function (done) {
+        if (this.testClient) {
+            this.testClient.drain(done);
+        }
+    });
+
+    it('should return invalid number of ramp error', function(done) {
+        this.testClient = new TestClient(makeMapconfig('ramp([pop_max], 8, 96, 3, (8,24,96,128))'));
+        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(/^Failed\sto\sprocess/), layergroup.errors[0]);
+            assert.ok(layergroup.errors[0].match(/invalid\sramp\slength/i), layergroup.errors[0]);
+
+            done();
+        });
+    });
+
+    it('should return invalid column from datasource', 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.length, 1);
+            assert.ok(layergroup.errors[0].match(/^Failed\sto\sprocess/));
+            assert.ok(layergroup.errors[0].match(/unable\sto\scompute\sramp/i));
+            assert.ok(layergroup.errors[0].match(/wadus_column/));
+
+            done();
+        });
+    });
+
+    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(/^Failed\sto\sprocess/));
+            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) {
+            assert.ok(!err, err);
+
+            assert.ok(layergroup.hasOwnProperty('errors'));
+            assert.equal(layergroup.errors.length, 1);
+            assert.ok(!layergroup.errors[0].match(/^Failed\sto\sprocess/));
+            assert.ok(layergroup.errors[0].match(/invalid\scode/i));
+
+            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, 'layer');
+            assert.equal(layergroup.errors_with_context[0].subtype, 'turbo-carto');
+            assert.ok(layergroup.errors_with_context[0].message.match(/^Failed\sto\sprocess/));
+            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].layer.id, 'layer0');
+            assert.equal(layergroup.errors_with_context[0].layer.index, 0);
+            assert.equal(layergroup.errors_with_context[0].layer.type, 'mapnik');
+
+            assert.equal(layergroup.errors_with_context[0].layer.context.selector, '#populated_places_simple_reduced');
+            assert.deepEqual(layergroup.errors_with_context[0].layer.context.source, {
+                start: {
+                    line: 10,
+                    column: 3
+                },
+                end: {
+                    line: 10,
+                    column: 56
+                }
+            });
+            done();
+        });
+    });
+
+    it('should return multiple errors', function(done) {
+
+        var multipleErrorsMapConfig = {
+            "version": "1.4.0",
+            "layers": [
+                {
+                    "type": 'mapnik',
+                    "options": {
+                        "cartocss_version": '2.3.0',
+                        "sql": 'SELECT * FROM populated_places_simple_reduced',
+                        "cartocss": createCartocss(null, 'ramp([wadus_column], (red, green, blue))')
+                    }
+                },
+                {
+                    "type": 'mapnik',
+                    "options": {
+                        "cartocss_version": '2.3.0',
+                        "sql": 'SELECT * FROM populated_places_simple_reduced',
+                        "cartocss": createCartocss('ramp([invalid_column], (red, green, blue))')
+                    }
+                }
+            ]
+        };
+
+        this.testClient = new TestClient(multipleErrorsMapConfig);
+        this.testClient.getLayergroup(ERROR_RESPONSE, function(err, layergroup) {
+            assert.ok(!err, err);
+
+            assert.ok(layergroup.hasOwnProperty('errors'));
+            assert.equal(layergroup.errors_with_context.length, 2);
+
+            assert.equal(layergroup.errors_with_context[0].type, 'layer');
+            assert.equal(layergroup.errors_with_context[0].subtype, 'turbo-carto');
+            assert.ok(layergroup.errors_with_context[0].message.match(/^Failed\sto\sprocess/));
+            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].layer.id, 'layer0');
+
+            assert.equal(layergroup.errors_with_context[1].type, 'layer');
+            assert.equal(layergroup.errors_with_context[1].subtype, 'turbo-carto');
+            assert.ok(layergroup.errors_with_context[1].message.match(/^Failed\sto\sprocess/));
+            assert.ok(layergroup.errors_with_context[1].message.match(/unable\sto\scompute\sramp/i));
+            assert.ok(layergroup.errors_with_context[1].message.match(/invalid_column/));
+            assert.equal(layergroup.errors_with_context[1].layer.id, 'layer1');
+
+            done();
+        });
+    });
+});
--- a/test/acceptance/turbo-carto/named-maps.js
+++ b/test/acceptance/turbo-carto/named-maps.js
@@ -0,0 +1,252 @@
+var assert = require('../../support/assert');
+var step = require('step');
+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');
+var server = new CartodbWindshaft(serverOptions);
+var mapnik = require('windshaft').mapnik;
+var IMAGE_TOLERANCE_PER_MIL = 10;
+
+describe('turbo-carto for named maps', function() {
+
+    var keysToDelete;
+
+    beforeEach(function() {
+        keysToDelete = {};
+    });
+
+    afterEach(function(done) {
+        testHelper.deleteRedisKeys(keysToDelete, done);
+    });
+
+    var templateId = 'turbo-carto-template-1';
+
+    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' };
+
+    var scenarios = [
+        {
+            desc: 'with public tables',
+            table: 'test_table'
+        },
+        {
+            desc: 'with private tables',
+            table: 'test_table_private_1'
+        }
+    ];
+
+    scenarios.forEach(function(scenario) {
+        it('should create a template with turbo-carto parsed properly: ' + scenario.desc, function (done) {
+            step(
+                function postTemplate() {
+                    var next = this;
+
+                    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
+                    });
+
+                    return null;
+                },
+                function instantiateTemplateWithReds(err) {
+                    assert.ifError(err);
+
+                    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);
+
+                    assert.equal(res.statusCode, 200);
+
+                    var parsedBody = JSON.parse(res.body);
+
+                    keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
+                    keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                    assert.ok(parsedBody.layergroupid);
+                    assert.ok(parsedBody.last_updated);
+
+                    return parsedBody.layergroupid;
+                },
+                function requestTileReds(err, layergroupId) {
+                    assert.ifError(err);
+
+                    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);
+
+                    var next = this;
+
+                    assert.equal(res.statusCode, 200);
+                    assert.equal(res.headers['content-type'], 'image/png');
+
+                    var fixturePath = './test/fixtures/turbo-carto-named-maps-reds.png';
+                    var image = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
+
+                    assert.imageIsSimilarToFile(image, fixturePath, IMAGE_TOLERANCE_PER_MIL, next);
+                },
+                function instantiateTemplateWithBlues(err) {
+                    assert.ifError(err);
+
+                    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);
+
+                    var parsedBody = JSON.parse(res.body);
+
+                    keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
+                    keysToDelete['user:localhost:mapviews:global'] = 5;
+
+                    assert.ok(parsedBody.layergroupid);
+                    assert.ok(parsedBody.last_updated);
+
+                    return parsedBody.layergroupid;
+                },
+                function requestTileBlues(err, layergroupId) {
+                    assert.ifError(err);
+
+                    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);
+
+                    var next = this;
+
+                    assert.equal(res.statusCode, 200);
+                    assert.equal(res.headers['content-type'], 'image/png');
+
+                    var fixturePath = './test/fixtures/turbo-carto-named-maps-blues.png';
+                    var image = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
+
+                    assert.imageIsSimilarToFile(image, fixturePath, IMAGE_TOLERANCE_PER_MIL, next);
+                },
+                function deleteTemplate(err) {
+                    assert.ifError(err);
+
+                    var next = this;
+
+                    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);
+                }
+            );
+        });
+    });
+});
--- a/test/acceptance/turbo-carto/regressions.js
+++ b/test/acceptance/turbo-carto/regressions.js
@@ -0,0 +1,383 @@
+require('../../support/test_helper');
+
+var assert = require('../../support/assert');
+var TestClient = require('../../support/test-client');
+
+function makeMapconfig(sql, cartocss) {
+    return {
+        "version": "1.4.0",
+        "layers": [
+            {
+                "type": 'mapnik',
+                "options": {
+                    "cartocss_version": '2.3.0',
+                    "sql": sql,
+                    "cartocss": cartocss
+                }
+            }
+        ]
+    };
+}
+
+describe('turbo-carto regressions', function() {
+
+    afterEach(function (done) {
+        if (this.testClient) {
+            this.testClient.drain(done);
+        } else {
+            done();
+        }
+    });
+
+    it('should accept // comments', function(done) {
+        var cartocss = [
+            "/** simple visualization */",
+            "",
+            "Map {",
+            "  buffer-size: 256;",
+            "}",
+            "",
+            "#county_points_with_population{",
+            "  marker-fill-opacity: 0.1;",
+            "  marker-line-color:#FFFFFF;//#CF1C90;",
+            "  marker-line-width: 0;",
+            "  marker-line-opacity: 0.3;",
+            "  marker-placement: point;",
+            "  marker-type: ellipse;",
+            "  //marker-comp-op: overlay;",
+            "  marker-width: [cartodb_id];",
+            "  [zoom=5]{marker-width: [cartodb_id]*2;}",
+            "  [zoom=6]{marker-width: [cartodb_id]*4;}",
+            "  marker-fill: #000000;",
+            "  marker-allow-overlap: true;",
+            "  ",
+            "",
+            "}"
+        ].join('\n');
+
+        this.testClient = new TestClient(makeMapconfig('SELECT * FROM populated_places_simple_reduced', cartocss));
+        this.testClient.getLayergroup(function(err, layergroup) {
+            assert.ok(!err, err);
+
+            assert.ok(layergroup.hasOwnProperty('layergroupid'));
+            assert.ok(!layergroup.hasOwnProperty('errors'));
+
+            done();
+        });
+    });
+
+    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, 'layer');
+            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 {",
+            "  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');
+
+        this.testClient = new TestClient(makeMapconfig(sql, cartocss));
+        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 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"
+                        }
+                    }
+                ]
+            };
+        }
+
+        var methods = ['quantiles', 'equal', 'jenks', 'headtails', 'category'];
+
+        methods.forEach(function(method) {
+            it('should work for "' + method+ '" method', function(done) {
+                var makerFillRule = 'ramp([pop_max], (#E5F5F9,#99D8C9,#2CA25F), ' + method + ')';
+
+                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();
+                });
+            });
+        });
+    });
+
+    var scenarios = [
+        {
+            desc: 'numeric datasource',
+            cartocss: [
+                "#points {",
+                "  marker-fill: ramp([scalerank], colorbrewer(Reds), category);",
+                "}"
+            ].join('\n'),
+            expected: [
+                '#points {',
+                '  marker-fill: #fee5d9;',
+                '  [ scalerank = 6 ] {',
+                '    marker-fill: #fcae91',
+                '  }',
+                '  [ scalerank = 8 ] {',
+                '    marker-fill: #fb6a4a',
+                '  }',
+                '  [ scalerank = 4 ] {',
+                '    marker-fill: #de2d26',
+                '  }',
+                '  [ scalerank = 10 ] {',
+                '    marker-fill: #a50f15',
+                '  }',
+                '}',
+            ].join('\n')
+        },
+        {
+            desc: 'string datasource',
+            cartocss: [
+                "#points {",
+                "  marker-fill: ramp([adm0name], colorbrewer(Reds), category);",
+                "}"
+            ].join('\n'),
+            expected: [
+                '#points {',
+                '  marker-fill: #fee5d9;',
+                '  [ adm0name = "Russia" ] {',
+                '    marker-fill: #fcae91',
+                '  }',
+                '  [ adm0name = "China" ] {',
+                '    marker-fill: #fb6a4a',
+                '  }',
+                '  [ adm0name = "Brazil" ] {',
+                '    marker-fill: #de2d26',
+                '  }',
+                '  [ adm0name = "Canada" ] {',
+                '    marker-fill: #a50f15',
+                '  }',
+                '}',
+            ].join('\n')
+        },
+        {
+            desc: 'numeric manual',
+            cartocss: [
+                "#points {",
+                "  marker-fill: ramp([scalerank], colorbrewer(Reds), (-1, 6, 8, 4, 10), category);",
+                "}"
+            ].join('\n'),
+            expected: [
+                '#points {',
+                '  marker-fill: #fee5d9;',
+                '  [ scalerank = 6 ] {',
+                '    marker-fill: #fcae91',
+                '  }',
+                '  [ scalerank = 8 ] {',
+                '    marker-fill: #fb6a4a',
+                '  }',
+                '  [ scalerank = 4 ] {',
+                '    marker-fill: #de2d26',
+                '  }',
+                '  [ scalerank = 10 ] {',
+                '    marker-fill: #a50f15',
+                '  }',
+                '}',
+            ].join('\n')
+        }
+    ];
+
+    scenarios.forEach(function(scenario) {
+        it('category ramps should use original type: ' + scenario.desc, function(done) {
+            var mapConfig = makeMapconfig('SELECT * FROM populated_places_simple_reduced', scenario.cartocss);
+            this.testClient = new TestClient(mapConfig);
+            this.testClient.getLayergroup(function(err, layergroup) {
+                assert.ok(!err, err);
+
+                assert.ok(layergroup.hasOwnProperty('layergroupid'));
+                assert.deepEqual(layergroup.metadata.layers[0].meta.cartocss, scenario.expected);
+
+                done();
+            });
+        });
+    });
+
+});
--- a/test/acceptance/turbo-cartocss/error-cases.js
+++ b/test/acceptance/turbo-cartocss/error-cases.js
@@ -1,109 +0,0 @@
-require('../../support/test_helper');
-
-var assert = require('../../support/assert');
-var TestClient = require('../../support/test-client');
-
-function makeMapconfig(markerWidth, markerFill) {
-    return {
-        "version": "1.4.0",
-        "layers": [
-            {
-                "type": 'mapnik',
-                "options": {
-                    "cartocss_version": '2.3.0',
-                    "sql": 'SELECT * FROM populated_places_simple_reduced',
-                    "cartocss": createCartocss(markerWidth, markerFill)
-                }
-            }
-        ]
-    };
-}
-
-function createCartocss(markerWidth, markerFill) {
-    return [
-        "#populated_places_simple_reduced {",
-        "  marker-fill-opacity: 0.9;",
-        "  marker-line-color: #FFF;",
-        "  marker-line-width: 1;",
-        "  marker-line-opacity: 1;",
-        "  marker-placement: point;",
-        "  marker-type: ellipse;",
-        "  marker-allow-overlap: true;",
-        "  marker-width: " + (markerWidth || '10') + ";",
-        "  marker-fill: " + (markerFill || 'red') + ";",
-        "}"
-    ].join('\n');
-}
-
-var ERROR_RESPONSE = {
-    status: 400,
-    headers: {
-        'Content-Type': 'application/json; charset=utf-8'
-    }
-};
-
-describe('turbo-carto error cases', function() {
-    afterEach(function (done) {
-        if (this.testClient) {
-            this.testClient.drain(done);
-        }
-    });
-
-    it('should return invalid number of ramp error', function(done) {
-        this.testClient = new TestClient(makeMapconfig('ramp([pop_max], (8,24,96), (8,24,96,128))'));
-        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(/invalid\sramp\slength/i));
-
-            done();
-        });
-    });
-
-    it('should return invalid column from datasource', 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.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(/wadus_column/));
-
-            done();
-        });
-    });
-
-    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) {
-            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(/invalid\scode/i));
-
-            done();
-        });
-    });
-});
--- a/test/acceptance/turbo-cartocss/named-maps.js
+++ b/test/acceptance/turbo-cartocss/named-maps.js
@@ -1,236 +0,0 @@
-var assert = require('../../support/assert');
-var step = require('step');
-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');
-var server = new CartodbWindshaft(serverOptions);
-var mapnik = require('windshaft').mapnik;
-var IMAGE_TOLERANCE_PER_MIL = 10;
-
-describe('turbo-carto for named maps', function() {
-
-    var keysToDelete;
-
-    beforeEach(function() {
-        keysToDelete = {};
-    });
-
-    afterEach(function(done) {
-        testHelper.deleteRedisKeys(keysToDelete, done);
-    });
-
-    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'
-                    }
-                }
-            ]
-        }
-    };
-
-    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;
-
-                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
-                });
-
-                return null;
-            },
-            function instantiateTemplateWithReds(err) {
-                assert.ifError(err);
-
-                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);
-
-                assert.equal(res.statusCode, 200);
-
-                var parsedBody = JSON.parse(res.body);
-
-                keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
-                keysToDelete['user:localhost:mapviews:global'] = 5;
-
-                assert.ok(parsedBody.layergroupid);
-                assert.ok(parsedBody.last_updated);
-
-                return parsedBody.layergroupid;
-            },
-            function requestTileReds(err, layergroupId) {
-                assert.ifError(err);
-
-                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);
-
-                var next = this;
-
-                assert.equal(res.statusCode, 200);
-                assert.equal(res.headers['content-type'], 'image/png');
-
-                var fixturePath = './test/fixtures/turbo-carto-named-maps-reds.png';
-                var image = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
-
-                assert.imageIsSimilarToFile(image, fixturePath, IMAGE_TOLERANCE_PER_MIL, next);
-            },
-            function instantiateTemplateWithBlues(err) {
-                assert.ifError(err);
-
-                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);
-
-                var parsedBody = JSON.parse(res.body);
-
-                keysToDelete['map_cfg|' + LayergroupToken.parse(parsedBody.layergroupid).token] = 0;
-                keysToDelete['user:localhost:mapviews:global'] = 5;
-
-                assert.ok(parsedBody.layergroupid);
-                assert.ok(parsedBody.last_updated);
-
-                return parsedBody.layergroupid;
-            },
-            function requestTileBlues(err, layergroupId) {
-                assert.ifError(err);
-
-                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);
-
-                var next = this;
-
-                assert.equal(res.statusCode, 200);
-                assert.equal(res.headers['content-type'], 'image/png');
-
-                var fixturePath = './test/fixtures/turbo-carto-named-maps-blues.png';
-                var image = mapnik.Image.fromBytes(new Buffer(res.body, 'binary'));
-
-                assert.imageIsSimilarToFile(image, fixturePath, IMAGE_TOLERANCE_PER_MIL, next);
-            },
-            function deleteTemplate(err) {
-                assert.ifError(err);
-
-                var next = this;
-
-                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);
-            }
-        );
-    });
-});
--- a/test/acceptance/turbo-cartocss/regressions.js
+++ b/test/acceptance/turbo-cartocss/regressions.js
@@ -1,170 +0,0 @@
-require('../../support/test_helper');
-
-var assert = require('../../support/assert');
-var TestClient = require('../../support/test-client');
-
-function makeMapconfig(sql, cartocss) {
-    return {
-        "version": "1.4.0",
-        "layers": [
-            {
-                "type": 'mapnik',
-                "options": {
-                    "cartocss_version": '2.3.0',
-                    "sql": sql,
-                    "cartocss": cartocss
-                }
-            }
-        ]
-    };
-}
-
-describe('turbo-carto regressions', function() {
-
-    afterEach(function (done) {
-        if (this.testClient) {
-            this.testClient.drain(done);
-        }
-    });
-
-    it('should accept // comments', function(done) {
-        var cartocss = [
-            "/** simple visualization */",
-            "",
-            "Map {",
-            "  buffer-size: 256;",
-            "}",
-            "",
-            "#county_points_with_population{",
-            "  marker-fill-opacity: 0.1;",
-            "  marker-line-color:#FFFFFF;//#CF1C90;",
-            "  marker-line-width: 0;",
-            "  marker-line-opacity: 0.3;",
-            "  marker-placement: point;",
-            "  marker-type: ellipse;",
-            "  //marker-comp-op: overlay;",
-            "  marker-width: [cartodb_id];",
-            "  [zoom=5]{marker-width: [cartodb_id]*2;}",
-            "  [zoom=6]{marker-width: [cartodb_id]*4;}",
-            "  marker-fill: #000000;",
-            "  marker-allow-overlap: true;",
-            "  ",
-            "",
-            "}"
-        ].join('\n');
-
-        this.testClient = new TestClient(makeMapconfig('SELECT * FROM populated_places_simple_reduced', cartocss));
-        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 {",
-            "  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');
-
-        this.testClient = new TestClient(makeMapconfig(sql, cartocss));
-        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 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();
-        });
-    });
-});
--- a/test/acceptance/widgets/ported/aggregation.js
+++ b/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();
+                    });
+                });
+            });
+        });
+
+    });
+
+});
--- a/test/acceptance/widgets/ported/formula.js
+++ b/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();
+            });
+        });
+
+    });
+
+});
--- a/test/acceptance/widgets/ported/histogram.js
+++ b/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();
+                });
+            });
+        });
+
+    });
+
+});
--- a/test/acceptance/widgets/ported/list.js
+++ b/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;
+        }
+
+    });
+
+});
--- a/test/acceptance/widgets/regressions.js
+++ b/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();
+            });
+        });
+
+    });
+
+});
--- a/test/fixtures/analysis/named-map-buffer-static-preview.png
+++ b/test/fixtures/analysis/named-map-buffer-static-preview.png
--- a/test/fixtures/previews/populated_places_simple_reduced-preview_layers_all.png
+++ b/test/fixtures/previews/populated_places_simple_reduced-preview_layers_all.png
--- a/test/fixtures/previews/populated_places_simple_reduced-preview_layers_blue.png
+++ b/test/fixtures/previews/populated_places_simple_reduced-preview_layers_blue.png
--- a/test/fixtures/previews/populated_places_simple_reduced-preview_layers_orange.png
+++ b/test/fixtures/previews/populated_places_simple_reduced-preview_layers_orange.png
--- a/test/fixtures/previews/populated_places_simple_reduced-preview_layers_orange_blue.png
+++ b/test/fixtures/previews/populated_places_simple_reduced-preview_layers_orange_blue.png
--- a/test/fixtures/previews/populated_places_simple_reduced-preview_layers_red.png
+++ b/test/fixtures/previews/populated_places_simple_reduced-preview_layers_red.png
--- a/test/fixtures/previews/populated_places_simple_reduced-preview_layers_red_blue.png
+++ b/test/fixtures/previews/populated_places_simple_reduced-preview_layers_red_blue.png
--- a/test/fixtures/previews/populated_places_simple_reduced-preview_layers_red_orange.png
+++ b/test/fixtures/previews/populated_places_simple_reduced-preview_layers_red_orange.png
--- a/test/fixtures/previews/populated_places_simple_reduced-preview_layers_red_orange_blue.png
+++ b/test/fixtures/previews/populated_places_simple_reduced-preview_layers_red_orange_blue.png
--- a/test/fixtures/previews/populated_places_simple_reduced-preview_layers_undefined.png
+++ b/test/fixtures/previews/populated_places_simple_reduced-preview_layers_undefined.png
--- a/test/integration/analysis-backend-limits.js
+++ b/test/integration/analysis-backend-limits.js
@@ -0,0 +1,167 @@
+var testHelper = require('../support/test_helper');
+
+var assert = require('assert');
+var redis = require('redis');
+
+var RedisPool = require('redis-mpool');
+var cartodbRedis = require('cartodb-redis');
+
+var AnalysisBackend = require('../../lib/cartodb/backends/analysis');
+
+describe('analysis-backend limits', function() {
+
+    var redisClient;
+    var keysToDelete;
+    var user = 'localhost';
+
+    beforeEach(function() {
+        redisClient = redis.createClient(global.environment.redis.port);
+        keysToDelete = {};
+        var redisPool = new RedisPool(global.environment.redis);
+        this.metadataBackend = cartodbRedis({pool: redisPool});
+    });
+
+    afterEach(function(done) {
+        redisClient.quit(function() {
+            testHelper.deleteRedisKeys(keysToDelete, done);
+        });
+    });
+
+    function withAnalysesLimits(limits, callback) {
+        redisClient.SELECT(5, function(err) {
+            if (err) {
+                return callback(err);
+            }
+            var analysesLimitsKey = 'limits:analyses:' + user;
+            redisClient.HMSET([analysesLimitsKey].concat(limits), function(err) {
+                if (err) {
+                    return callback(err);
+                }
+                keysToDelete[analysesLimitsKey] = 5;
+                return callback();
+            });
+        });
+    }
+
+    it("should use limits from configuration", function(done) {
+        var analysisBackend = new AnalysisBackend(this.metadataBackend, {
+            limits: {
+                moran: { timeout: 5000 },
+                kmeans: { timeout: 5000 }
+            }
+        });
+        analysisBackend.getAnalysesLimits(user, function(err, result) {
+            assert.ok(!err, err);
+
+            assert.ok(result.analyses.moran);
+            assert.equal(result.analyses.moran.timeout, 5000);
+
+            assert.ok(result.analyses.kmeans);
+            assert.equal(result.analyses.kmeans.timeout, 5000);
+
+            done();
+        });
+    });
+
+    it("should use limits from redis", function(done) {
+        var self = this;
+        var limits = ['moran', 5000];
+
+        withAnalysesLimits(limits, function(err) {
+            if (err) {
+                return done(err);
+            }
+
+            var analysisBackend = new AnalysisBackend(self.metadataBackend);
+            analysisBackend.getAnalysesLimits(user, function(err, result) {
+                assert.ok(!err, err);
+
+                assert.ok(result.analyses.moran);
+                assert.equal(result.analyses.moran.timeout, 5000);
+
+                done();
+            });
+        });
+    });
+
+    it("should use limits from redis and configuration, redis takes priority", function(done) {
+        var self = this;
+        var limits = ['moran', 5000];
+
+        withAnalysesLimits(limits, function(err) {
+            if (err) {
+                return done(err);
+            }
+
+            var analysisBackend = new AnalysisBackend(self.metadataBackend, {
+                limits: {
+                    moran: { timeout: 1000 }
+                }
+            });
+            analysisBackend.getAnalysesLimits(user, function(err, result) {
+                assert.ok(!err, err);
+
+                assert.ok(result.analyses.moran);
+                assert.equal(result.analyses.moran.timeout, 5000);
+
+                done();
+            });
+        });
+    });
+
+    it("should use limits from redis and configuration, defaulting for values not present in redis", function(done) {
+        var self = this;
+        var limits = ['moran', 5000];
+
+        withAnalysesLimits(limits, function(err) {
+            if (err) {
+                return done(err);
+            }
+
+            var analysisBackend = new AnalysisBackend(self.metadataBackend, {
+                limits: {
+                    moran: { timeout: 1000 },
+                    kmeans: { timeout: 1000 }
+                }
+            });
+            analysisBackend.getAnalysesLimits(user, function(err, result) {
+                assert.ok(!err, err);
+
+                assert.ok(result.analyses.moran);
+                assert.equal(result.analyses.moran.timeout, 5000);
+
+                assert.ok(result.analyses.kmeans);
+                assert.equal(result.analyses.kmeans.timeout, 1000);
+
+                done();
+            });
+        });
+    });
+
+    it("should allow to set other limits per analysis via configuration, and keep timeout from redis", function(done) {
+        var self = this;
+        var limits = ['aggregate-intersection', 5000];
+
+        withAnalysesLimits(limits, function(err) {
+            if (err) {
+                return done(err);
+            }
+
+            var analysisBackend = new AnalysisBackend(self.metadataBackend, {
+                limits: {
+                    'aggregate-intersection': { timeout: 10000, maxNumberOfRows: 1e5 }
+                }
+            });
+            analysisBackend.getAnalysesLimits(user, function(err, result) {
+                assert.ok(!err, err);
+
+                assert.ok(result.analyses['aggregate-intersection']);
+                assert.equal(result.analyses['aggregate-intersection'].timeout, 5000);
+                assert.equal(result.analyses['aggregate-intersection'].maxNumberOfRows, 1e5);
+
+                done();
+            });
+        });
+    });
+
+});
--- a/test/support/prepare_db.sh
+++ b/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='analysis_catalog windshaft.test gadm4 ported/populated_places_simple_reduced cdb_analysis_check'
+  REMOTE_SQL_SCRIPTS='CDB_QueryStatements CDB_QueryTables CDB_CartodbfyTable CDB_TableMetadata CDB_ForeignTable CDB_UserTables CDB_ColumnNames 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"
--- a/Show More
+++ b/Show More