Release 0.16.2

Merge pull request #246 from CartoDB/245-categories-mode
Use the mode to aggregate category columns in overviews
2016-04-27 18:30:26 +02:00 · 2016-04-27 18:16:05 +02:00 · 2016-04-27 16:23:46 +02:00 · 2016-04-27 16:23:25 +02:00 · 2016-04-27 15:06:09 +02:00 · 2016-04-26 18:27:52 +02:00
106 changed files with 8335 additions and 1228 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,5 @@ results/
 regression.*
 expected/test
 sql/test
+.idea/*
+*.swp
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,14 +9,6 @@ before_install:
  - sudo apt-get update
  - sudo apt-get install -q postgresql-server-dev-9.3
  - sudo apt-get install -q postgresql-plpython-9.3
-  # Install schema_triggers
-  - hg clone https://bitbucket.org/malloclabs/pg_schema_triggers &&
-    cd pg_schema_triggers && make && sudo make install && cd -
-  # Preload schema_triggers module
-  # NOTE: might change if we make it part of the installcheck instead
-  - echo "shared_preload_libraries = 'schema_triggers.so'" |
-    sudo tee -a /etc/postgresql/9.3/main/postgresql.conf &&
-    sudo service postgresql restart

 script:
  - make
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -19,7 +19,7 @@ in which those scripts are loaded.

 Scripts would be best coded in a way to be usable both for creation
 and upgrade of the objects. This means using CREATE OR REPLACE for
-the functions, and whatever it takes to check existance of any previous
+the functions, and whatever it takes to check existence of any previous
 version of objects in other cases.

 When used as an extension (probably always from version 0.2.0 onwards)
@@ -27,8 +27,8 @@ all the objects will be installed in a "cartodb" schema. Take this into
 account to fully-qualify internal calls to avoid (possibly dangerous)
 name clashes.

-Every new feature (as well as bugfixes) should come with a testcase,
-see next session.
+Every new feature (as well as bugfixes) should come with a test case,
+see next section.

 Writing testcases
 -----------------
@@ -44,18 +44,21 @@ the extension into your test database.

 During development the cartodb extension version doesn't change with
 every commit, so testing latest change requires cheating with PostgreSQL
-so to enforce re-load of the scripts. To help with cheating, "make install"
+as to enforce the scripts to reload. To help with cheating, "make install"
 also installs migration scripts to go from "V" to "V"next and from "V"next
 to "V". Example to upgrade a 0.2.0dev version:

 ```sql
-ALTER EXTENSION cartodb UPDATE TO '0.2.0devnext';
+ALTER EXTENSION cartodb UPDATE TO '0.2.0next';
 ALTER EXTENSION cartodb UPDATE TO '0.2.0dev';
 ```
-
 Starting with 0.2.0, the in-place reload can be done with an ad-hoc function:

 ```sql
 SELECT cartodb.cdb_extension_reload();
 ```

+A useful query:
+```sql
+SELECT * FROM pg_extension_update_paths('cartodb') WHERE path IS NOT NULL AND source = cdb_version();
+```
--- a/76
+++ b/76
@@ -1,16 +1,16 @@
 # cartodb/Makefile

 EXTENSION = cartodb
-EXTVERSION = 0.3.4
+EXTVERSION = 0.16.2

 SED = sed

 CDBSCRIPTS = \
  scripts-enabled/*.sql \
  scripts-available/CDB_SearchPath.sql \
-  scripts-available/CDB_DDLTriggers.sql \
  scripts-available/CDB_ExtensionPost.sql \
  scripts-available/CDB_ExtensionUtils.sql \
+  scripts-available/CDB_Helper.sql \
  $(END)

 UPGRADABLE = \
@@ -24,6 +24,51 @@ UPGRADABLE = \
  0.3.1 \
  0.3.2 \
  0.3.3 \
+  0.3.4 \
+  0.3.5 \
+  0.3.6 \
+  0.4.0 \
+  0.4.1 \
+  0.5.0 \
+  0.5.1 \
+  0.5.2 \
+  0.5.3 \
+  0.6.0 \
+  0.7.0 \
+  0.7.1 \
+  0.7.2 \
+  0.7.3 \
+  0.7.4 \
+  0.8.0 \
+  0.8.1 \
+  0.8.2 \
+  0.9.0 \
+  0.9.1 \
+  0.9.2 \
+  0.9.3 \
+  0.9.4 \
+  0.10.0 \
+  0.10.1 \
+  0.10.2 \
+  0.11.0 \
+  0.11.1 \
+  0.11.2 \
+  0.11.3 \
+  0.11.4 \
+  0.11.5 \
+  0.12.0 \
+  0.13.0 \
+  0.13.1 \
+  0.14.0 \
+  0.14.1 \
+  0.14.2 \
+  0.14.3 \
+  0.14.4 \
+  0.15.0 \
+  0.15.1 \
+  0.16.0 \
+  0.16.1 \
+  0.16.2 \
  $(EXTVERSION)dev \
  $(EXTVERSION)next \
  $(END)
@@ -34,7 +79,6 @@ UPGRADES = \
     $(SED) 's/$$/--$(EXTVERSION).sql/' | \
     $(SED) 's/ /--$(EXTVERSION).sql $(EXTENSION)--/g')

-REV=$(shell git describe)
 GITDIR=$(shell test -d .git && echo '.git' || cat .git | $(SED) 's/^gitdir: //')

 DATA_built = \
@@ -46,10 +90,9 @@ DATA_built = \
 EXTRA_CLEAN = cartodb_version.sql

 DOCS = README.md
-REGRESS_NEW = test_ddl_triggers
 REGRESS_OLD = $(wildcard test/*.sql)
 REGRESS_LEGACY = $(REGRESS_OLD:.sql=)
-REGRESS = test_setup $(REGRESS_NEW) $(REGRESS_LEGACY)
+REGRESS = test_setup $(REGRESS_LEGACY)

 PG_CONFIG = pg_config
 PGXS := $(shell $(PG_CONFIG) --pgxs)
@@ -59,7 +102,8 @@ $(EXTENSION)--$(EXTVERSION).sql: $(CDBSCRIPTS) cartodb_version.sql Makefile
 	echo '\echo Use "CREATE EXTENSION $(EXTENSION)" to load this file. \quit' > $@
 	cat $(CDBSCRIPTS) | \
    $(SED) -e 's/public\./cartodb./g' \
-        -e 's/:DATABASE_USERNAME/cdb_org_admin/g' >> $@
+        -e 's/:DATABASE_USERNAME/cdb_org_admin/g' \
+        -e "s/''public''/''cartodb''/g" >> $@
 	echo "GRANT USAGE ON SCHEMA cartodb TO public;" >> $@
 	cat cartodb_version.sql >> $@

@@ -76,7 +120,10 @@ $(EXTENSION).control: $(EXTENSION).control.in Makefile
 	$(SED) -e 's/@@VERSION@@/$(EXTVERSION)/' $< > $@

 cartodb_version.sql: cartodb_version.sql.in Makefile $(GITDIR)/index
-	$(SED) -e 's/@@VERSION@@/$(EXTVERSION) $(REV)/' $< > $@
+	$(SED) -e 's/@@VERSION@@/$(EXTVERSION)/' $< > $@
+
+# Needed for consistent `echo` results with backslashes
+SHELL = bash

 legacy_regress: $(REGRESS_OLD) Makefile
 	mkdir -p sql/test/
@@ -85,21 +132,24 @@ legacy_regress: $(REGRESS_OLD) Makefile
 	for f in $(REGRESS_OLD); do \
    tn=`basename $${f} .sql`; \
    of=sql/test/$${tn}.sql; \
-    echo '\\set ECHO off' > $${of}; \
-    echo '\\a' >> $${of}; \
-    echo '\\t' >> $${of}; \
-    echo '\\set QUIET off' >> $${of}; \
+    echo '\set ECHO none' > $${of}; \
+    echo '\a' >> $${of}; \
+    echo '\t' >> $${of}; \
+    echo '\set QUIET off' >> $${of}; \
    cat $${f} | \
      $(SED) -e 's/public\./cartodb./g' >> $${of}; \
    exp=expected/test/$${tn}.out; \
-    echo '\\set ECHO off' > $${exp}; \
+    echo '\set ECHO none' > $${exp}; \
    cat test/$${tn}_expect >> $${exp}; \
  done

 test_organization:
 	bash test/organization/test.sh

+test_extension_new:
+	bash test/extension/test.sh
+
 legacy_tests: legacy_regress 

-installcheck: legacy_tests test_organization
+installcheck: legacy_tests test_extension_new test_organization

--- a/65
+++ b/65
@@ -1,65 +0,0 @@
-0.3.3 (2014-07-xx)
------------------
-* Splitting of CartodbfyTable method in subfunctions to be able to call in fragments and evade timeouts on hot zones
-
-0.3.2 (2014-07-28)
------------------
-* Make 0.3.0dev version upgradeable
-
-0.3.1 (2014-07-22)
------------------
-* Dummy version. We start using semantic versioning
-
-0.3.0 (2014-07-15)
------------------
-* Permission management functions
-* Adapt functions to use schemas
-
-0.2.1 - 2014-06-11
------------------
-
-Enhancements:
-
- - Do not force re-cartodbfication on CREATE FROM unpackaged
- - Drop useless DEFAULT specification in plpgsql variable declarations
- - List plpythonu requirement first, to get pg_catalog scanned before public
-
-Bug fixes:
-
- - Do not add unique index on cartodb_id if already a primary key (#38)
-
-0.2.0 - 2014-06-09
------------------
-
-Important changes:
-
- - This release adds dependency on "plpythonu" extension
- - Roles are not created anymore, previously private functions
-   for table information extraction (CDB_UserTables, CDB_TableIndexes,
-   CDB_ColumnNames, CDB_ColumnType) will now be callable by anyone while
-   only returning information about tables over which the calling user
-   has SELECT privilege (#36)
-
-Bug fixes:
-
- - Fix recursive trigger on create table (#32)
- - Ensure cartodb_id uses an associated sequence (#33)
- - Fully qualify call to cdb_disable_ddl_hooks from cdb_enable_ddl_hooks
- - Fully qualify call to CDB_UserDataSize from quota trigger
- - Fully qualify call to CDB_TransformToWebmercator from CDB_CartodbfyTable
- - Fix potential infinite loop in CDB_CartodbfyTable
- - Fix potential infinite loop in CDB_QueryStatements
-
-Enhancements:
-
- - Include revision info in cdb_version() output (#34)
-
-New features:
-
- - Add a cdb_extension_reload() function
-
-
-0.1.0 - 2014-05-23
------------------
-
-Initial release
--- a/NEWS.md
+++ b/NEWS.md
@@ -0,0 +1,319 @@
+0.16.2 (2016-04-27)
+-------------------
+
+* Use the mode to aggregate category columns in overviews
+  [#246](https://github.com/CartoDB/cartodb-postgresql/pull/246)
+
+0.16.1 (2016-04-25)
+-------------------
+
+* Optimize column information functions performance
+  [#238](https://github.com/CartoDB/cartodb-postgresql/pull/238)
+
+* Adjust overview points to pixel CDB_EqualIntervalBins
+  [#242](https://github.com/CartoDB/cartodb-postgresql/pull/242)
+
+* Compute webmercator resolution using full numeric precision
+  [#243](https://github.com/CartoDB/cartodb-postgresql/pull/243)
+
+
+0.16.0 (2016-04-15)
+-------------------
+* Adds table for storing camshaft analysis nodes
+  [#237](https://github.com/CartoDB/cartodb-postgresql/pull/237)
+
+0.15.1 (2016-04-15)
+-------------------
+* Fix problems with org users in overviews functions
+  [#224](https://github.com/CartoDB/cartodb-postgresql/pull/224)
+* Add `_feature_count` to overviews
+  [#227](https://github.com/CartoDB/cartodb-postgresql/pull/227)
+* Change point clustering behaviour of overviews
+  [#228](https://github.com/CartoDB/cartodb-postgresql/pull/228)
+* Change default tolerance of overviews
+  [#230](https://github.com/CartoDB/cartodb-postgresql/pull/230)
+* Fix problem with aggregated numerical fields in overviews
+  [#233](https://github.com/CartoDB/cartodb-postgresql/pull/233)
+* Enhance aggregation of text fields in overviews
+  [#234]https://github.com/CartoDB/cartodb-postgresql/pull/234
+
+0.15.0 (2016-04-05)
+-------------------
+* New function CDB_CreateOverviewsWithToleranceInPixels that adds tolerance parameter for overview creation
+  [#221](https://github.com/CartoDB/cartodb-postgresql/pull/221)
+* New default value for the overviews tolerance in pixels is 2 (used to be 7.5) (also in #221)
+* The feature density limit used to choose the reference Z level now depends on the tolerance in pixels (also in #221)
+* Tables that require an explicit schema can now be passed to overview functions
+  [#220](https://github.com/CartoDB/cartodb-postgresql/pull/220)
+
+0.14.4 (2016-03-29)
+-------------------
+* Fix creating overviews for tables with boolean columns
+  [#214](https://github.com/CartoDB/cartodb-postgresql/pull/214)
+* Fix tests for some systems [#215](https://github.com/CartoDB/cartodb-postgresql/pull/215)
+
+0.14.3 (2016-03-17)
+-------------------
+* Fix for `cartodb_id` bigint casting hardcoded in 0.14.2 to support `cartodb_id` text columns [#210](https://github.com/CartoDB/cartodb-postgresql/pull/210)
+
+0.14.2 (2016-03-15)
+-------------------
+* Support text `cartodb_id` columns in `_CDB_Has_Usable_Primary_ID` [#202](https://github.com/CartoDB/cartodb-postgresql/pull/202)
+
+0.14.1 (2016-03-07)
+-------------------
+* Fully qualify table names in cache cdb_invalidate_varnish calls [#198](https://github.com/CartoDB/cartodb-postgresql/issues/198)
+
+0.14.0 (2016-02-14)
+-------------------
+* Add CDB_ForeignTable.sql to support FDW's [#199](https://github.com/CartoDB/cartodb-postgresql/pull/199)
+
+0.13.1 (2016-02-01)
+-------------------
+* Fix migration fron unpackaged. [193](https://github.com/CartoDB/cartodb-postgresql/pull/193)
+
+0.13.0 (2016-01-29)
+-------------------
+* Add CDB_CreateOverviews, CDB_DropOverviews and CDB_Overviews for vector overviews support. [185](https://github.com/CartoDB/cartodb-postgresql/pull/185)
+* Convert some simple functions from plpgsql to sql. [188](https://github.com/CartoDB/cartodb-postgresql/pull/188)
+
+0.12.0 (2016-01-27)
+-------------------
+* Remove schema_triggers extension dependency, to ensure compatibility with PostgreSQL 9.5. [#190](https://github.com/CartoDB/cartodb-postgresql/pull/190)
+* Remove DDL trigger functions (unused by CartoDB).
+
+0.11.5 (2015-11-27)
+-------------------
+* Disable log invalidation time [#178](https://github.com/CartoDB/cartodb-postgresql/pull/178)
+
+0.11.4 (2015-11-24)
+-------------------
+* Fix for existing PK cartodb_id problem [#174](https://github.com/CartoDB/cartodb-postgresql/issues/174)
+* Add cartodbfication support for column names with embedded points to fix [#6114](https://github.com/CartoDB/cartodb/issues/6114)
+* Add CDB_GreatCircle for creating great circle routes between two points [#171](https://github.com/CartoDB/cartodb-postgresql/pull/171)
+* Fix to prevent cartodbfication problems [#155](https://github.com/CartoDB/cartodb-postgresql/issues/155)
+
+0.11.3 (2015-10-27)
+-------------------
+* Added CDB_Helper.sql [#173](https://github.com/CartoDB/cartodb-postgresql/pull/173)
+* Added `_CDB_Unique_Identifier` for creating UTF8 aware unique identifiers
+* Added `_CDB_Unique_Column_Identifier` for creating UTF8 aware unique identifiers for columns
+* Added `_CDB_Octet_Truncate` that truncates text to a certain amount of octets.
+
+0.11.2 (2015-10-19)
+-------------------
+* Fix schema not being specified on pg_get_serial_sequence [#170](https://github.com/CartoDB/cartodb-postgresql/pull/170)
+* Log invalidation function call duration in seconds [#163](https://github.com/CartoDB/cartodb-postgresql/pull/163)
+
+0.11.1 (2015-10-06)
+-------------------
+* Added CDB_DateToNumber(timestamp with time zone) [#169](https://github.com/CartoDB/cartodb-postgresql/pull/169)
+* cartodbfy now discards cartodb_id candidates that contain nulls [#148](https://github.com/CartoDB/cartodb-postgresql/issues/148)
+
+0.11.0 (2015-09-dd)
+-------------------
+* Groups API
+
+0.10.2 (2015-09-24)
+-------------------
+* Add back the `DROP FUNCTION IF EXISTS CDB_UserTables(text);` to be able to upgrade from `0.7.3` upward [#160](https://github.com/CartoDB/cartodb-postgresql/issues/160)
+
+0.10.1 (2015-09-16)
+-------------------
+* Get back the `update_updated_at` function (still used by old tables) [#143](https://github.com/CartoDB/cartodb-postgresql/pull/143)
+* Fix for CDB_StatsTest.sql test failing randomly [#144](https://github.com/CartoDB/cartodb-postgresql/issues/144)
+* Fix for table cartodbfy'ed without default seq value [#138](https://github.com/CartoDB/cartodb-postgresql/issues/138)
+* Fix for cartodbfy error column `the_geom` already exists [#141](https://github.com/CartoDB/cartodb-postgresql/issues/141)
+* Fix for columns with geometry cartodbfy'ed without SRID [#154](https://github.com/CartoDB/cartodb-postgresql/issues/154)
+
+0.10.0 (2015-09-07)
+-----------------
+* Quote schema and table names returned by CDB_QueryTables [#134](https://github.com/CartoDB/cartodb-postgresql/pull/134). Use quote_ident to quote schema and table names when necessary.
+* Fixed CDB_ColumnNames [#122](https://github.com/CartoDB/cartodb-postgresql/issues/122) and CDB_ColumnType [#130](https://github.com/CartoDB/cartodb-postgresql/issues/130) should honor regclass, returning columns for just the table in the schema and not in any other one [#131](https://github.com/CartoDB/cartodb-postgresql/pull/131).
+* Add kurtosis and skewness [#124](https://github.com/CartoDB/cartodb-postgresql/pull/124).
+* Removed `DROP FUNCTION IF EXISTS cdb_usertables(text);` [#129](https://github.com/CartoDB/cartodb-postgresql/pull/129). This was needed for upgrading between 0.7.4 to 0.8.0 but is no longer needed.
+
+0.9.4 (2015-08-28)
+------------------
+* Fixed issue with indices when renaming tables [#123](https://github.com/CartoDB/cartodb-postgresql/issues/123)
+
+0.9.3 (2015-08-27)
+------------------
+* Modify sampling of quota trigger [#126](https://github.com/CartoDB/cartodb-postgresql/issues/126)
+
+0.9.2 (2015-08-24)
+------------------
+* Fix for `the_geom` column present but not SRID (EWKT) and other corner cases [#121](https://github.com/CartoDB/cartodb-postgresql/pull/121)
+
+0.9.1 (2015-08-19)
+------------------
+* Fix for transformation to webmercator in corner cases [#116](https://github.com/CartoDB/cartodb-postgresql/issues/116)
+
+0.9.0 (2015-08-19)
+------------------
+* Re-implementation of `CDB_CartodbfyTable` functions
+  - The signature of the main function changes to
+    ```
+    FUNCTION CDB_CartodbfyTable(destschema TEXT, reloid REGCLASS)
+    RETURNS REGCLASS
+    ```
+    - The `destschema` does not need to match the origin schema of `reloid`
+	- It returns the `regclass` of the cartodbfy'ed table, if it needs to be rewritten.
+  - There are many optimizations
+  - The columns `created_at` and `updated_at` will no longer be added
+* Fix for CDB_UserDataSize failing due `ERROR: relation "*" does not exist.` #110
+* Review test to validate permissions in public tables [#112](https://github.com/CartoDB/cartodb-postgresql/pull/112)
+
+0.8.3 (2015-08-14)
+------------------
+* Fixes CDB_UserDataSize failing due `ERROR: relation "*" does not exist.` [#108](https://github.com/CartoDB/cartodb-postgresql/issues/108)
+
+0.8.2 (2015-07-27)
+------------------
+* Fix for CDB_UserTables returning wrong listings when publicuser is used
+
+0.8.1 (2015-06-30)
+------------------
+* Fix for [#95](https://github.com/CartoDB/cartodb-postgresql/issues/95) *cdb_usertables should return public tables when the user is publicuser*
+
+0.8.0 (2015-06-30)
+------------------
+* Adds new function CDB_QueryTablesText that can deal with "schema.table_name"
+  longer than 63 chars.
+* Adds a set of statistical functions:
+  - CDB_DistType
+  - CDB_DistinctMeasure
+  - CDB_EqualIntervalBins
+* Fix for CDB_UserTables returns 0 entries for multiuser accounts [#64](https://github.com/CartoDB/cartodb-postgresql/issues/64)
+
+0.7.4 (2015-06-29)
+------------------
+Dummy transitional version.
+
+0.7.3 (2015-03-03)
+------------------
+* Fix upgrade of CDB_StringToDate function
+* Add a test for to validate CDB_TableMetadataTouch usage with OID
+
+0.7.2 (2015-03-03)
+------------------
+* Fix conversion of strings to datetime
+
+0.7.1 (2015-02-27)
+------------------
+* Revert quota checks to `pg_total_relation_size`
+
+0.7.0 (2015-02-19)
+------------------
+* Adds CDB_ZoomFromScale function
+
+0.6.0 (2015-02-19)
+------------------
+* Select permission in CDB_TableMetadata no longer granted to public
+* New function to upsert the updated_at in CDB_TableMetadata for a regclass
+
+0.5.3 (2015-02-17)
+------------------
+* Fixed security problem related with system tables
+* Changed quota checks to use `pg_relation_size` instead of `pg_total_relation_size`
+
+0.5.2 (2015-01-29)
+------------------
+* Improvement: make CDB_UserDataSize functions much faster.
+
+0.5.1 (2014-11-21)
+------------------
+* Bugfix: Quota check and some organization permissions functions were not properly escaping table name.
+
+0.5.0 (2014-11-03)
+------------------
+* Support of raster tables for cartodbfication
+* Modified quota functions: vector tables stay the same, raster tables count as full size (as have no
+  the_geom + the_geom_webmercator combo) and raster overviews are not counted
+
+0.4.1 (2014-09-21)
+------------------
+* Bugfix for Cartodbfication: Set primary key of the table if not already present (e.g. tables created from SQL API)
+
+0.4.0 (2014-08-27)
+------------------
+Added CDB_Math_Mode function
+Changes in versioning: no revision is attached so it no longer uses `git describe` for the version.
+
+0.3.6 (2014-08-11)
+------------------
+Dummy release to solve some issues with cdb branch/tag
+
+0.3.5 (2014-08-11)
+------------------
+Inverting priority of CDB_CheckQuota qmax so gies more priority to existing user quota function over parameter value.
+
+0.3.4 (2014-08-01)
+------------------
+Fixes issue with schemas in CDB_QueryTables
+
+0.3.3 (2014-07-30)
+------------------
+* Splitting of CartodbfyTable method in subfunctions to be able to call in fragments and evade timeouts on hot zones
+
+0.3.2 (2014-07-28)
+------------------
+* Make 0.3.0dev version upgradeable
+
+0.3.1 (2014-07-22)
+------------------
+* Dummy version. We start using semantic versioning
+
+0.3.0 (2014-07-15)
+------------------
+* Permission management functions
+* Adapt functions to use schemas
+
+0.2.1 - 2014-06-11
+------------------
+
+Enhancements:
+
+ - Do not force re-cartodbfication on CREATE FROM unpackaged
+ - Drop useless DEFAULT specification in plpgsql variable declarations
+ - List plpythonu requirement first, to get pg_catalog scanned before public
+
+Bug fixes:
+
+ - Do not add unique index on cartodb_id if already a primary key (#38)
+
+0.2.0 - 2014-06-09
+------------------
+
+Important changes:
+
+ - This release adds dependency on "plpythonu" extension
+ - Roles are not created anymore, previously private functions
+   for table information extraction (CDB_UserTables, CDB_TableIndexes,
+   CDB_ColumnNames, CDB_ColumnType) will now be callable by anyone while
+   only returning information about tables over which the calling user
+   has SELECT privilege (#36)
+
+Bug fixes:
+
+ - Fix recursive trigger on create table (#32)
+ - Ensure cartodb_id uses an associated sequence (#33)
+ - Fully qualify call to cdb_disable_ddl_hooks from cdb_enable_ddl_hooks
+ - Fully qualify call to CDB_UserDataSize from quota trigger
+ - Fully qualify call to CDB_TransformToWebmercator from CDB_CartodbfyTable
+ - Fix potential infinite loop in CDB_CartodbfyTable
+ - Fix potential infinite loop in CDB_QueryStatements
+
+Enhancements:
+
+ - Include revision info in cdb_version() output (#34)
+
+New features:
+
+ - Add a cdb_extension_reload() function
+
+
+0.1.0 - 2014-05-23
+------------------
+
+Initial release
--- a/README.md
+++ b/README.md
@@ -1,38 +1,37 @@
 cartodb-postgresql
 ==================

-[![Build Status](http://travis-ci.org/CartoDB/cartodb-postgresql.png)]
+[![Build Status](http://api.travis-ci.org/CartoDB/cartodb-postgresql.svg?branch=master)]
 (http://travis-ci.org/CartoDB/cartodb-postgresql)

 PostgreSQL extension for CartoDB

-See https://github.com/CartoDB/cartodb/wiki/CartoDB-PostgreSQL-extension
+See [the cartodb-postgresql wiki](https://github.com/CartoDB/cartodb-postgresql/wiki).

 Dependencies
 ------------

- * PostgreSQL 9.3+ (with plpythonu extension)
+ * PostgreSQL 9.3+ (with plpythonu extension and xml support)
 * [PostGIS extension](http://postgis.net) 
- * [Schema triggers extension]
-   (https://bitbucket.org/malloclabs/pg_schema_triggers)
-   (or [fork](https://github.com/CartoDB/pg_schema_triggers))

 Install
 -------

- make all install
+```sh
+make all install
+```

 Test installation
 -----------------

- make installcheck
-
-NOTE: if ``test_ddl_triggers`` fails it's likely due to an incomplete
-      installation of schema_triggers: you need to add ``schema_triggers.so``
-      to the ``shared_preload_libraries`` setting in postgresql.conf !
+```sh
+make installcheck
+```

 NOTE: you need to run the installcheck as a superuser, use PGUSER
      env variable if needed, like: PGUSER=postgres make installcheck
+      
+NOTE: the tests need to run against a **clean postgres instance**, if you have some roles already created test will likely fail due `publicuser` not being dropped.

 Enable database
 ---------------
@@ -41,7 +40,6 @@ In a database that needs to be turned into a "cartodb" user database, run:

 ```sql
 CREATE EXTENSION postgis;
-CREATE EXTENSION schema_triggers;
 CREATE EXTENSION cartodb;
 ```

@@ -57,7 +55,6 @@ be in the "cartodb" schema.

 ```sql
 CREATE EXTENSION postgis FROM unpackaged;
-CREATE EXTENSION schema_triggers;
 CREATE EXTENSION cartodb FROM unpackaged;
 ```

@@ -92,3 +89,8 @@ ls `pg_config --sharedir`/extension/cartodb*
 During development the cartodb extension version doesn't change with
 every commit, so testing latest change requires special steps documented
 in the CONTRIBUTING document, under "Testing changes live".
+
+Limitations
+-----------
+
+- The main schema of an organization user must have one only owner (the user).
--- a/cartodb.control.in
+++ b/cartodb.control.in
@@ -3,4 +3,4 @@ comment = 'Turn a database into a cartodb user database.'
 superuser = true
 relocatable = false
 schema = cartodb
-requires = 'plpythonu, schema_triggers, postgis'
+requires = 'plpythonu, postgis'
--- a/doc/CDB_ColumnNames.md
+++ b/doc/CDB_ColumnNames.md
@@ -0,0 +1,14 @@
+Retrieve all column names in a particular table
+
+#### Using the function
+
+```sql
+SELECT CDB_ColumnNames('table_name')
+--- Returns a set of rows with column names
+```
+
+#### Arguments
+
+CDB_ColumnNames(table_name)
+
+* **table_name** text
--- a/doc/CDB_ColumnType.md
+++ b/doc/CDB_ColumnType.md
@@ -0,0 +1,15 @@
+Returns a column type for any column in a table
+
+#### Using the function
+
+```sql
+SELECT CDB_ColumnType('column_name','table_name')
+--- Returns a set of rows with column types
+```
+
+#### Arguments
+
+CDB_ColumnType(column_name, table_name)
+
+* **column_name** text
+* **table_name** text
--- a/doc/CDB_GreatCircle.md
+++ b/doc/CDB_GreatCircle.md
@@ -0,0 +1,16 @@
+Based on Paul Ramsey's [blog post](http://blog.cartodb.com/jets-and-datelines/).
+#### Using the function
+
+Creates a great circle line.
+
+```sql
+SELECT CDB_GreatCircle(start_point, end_point) FROM table_name
+-- Results a line reprsenting the great circle between the two points
+```
+
+#### Arguments
+
+CDB_GreatCircle(start_point, end_point)
+
+* **start_point** ST_Point indicating the start of the line.
+* **end_point** ST_point indicating the end of the line.
--- a/doc/CDB_HeadsTailsBins.md
+++ b/doc/CDB_HeadsTailsBins.md
@@ -0,0 +1,21 @@
+Find the breaks for N categories in a numerical column based on the [Heads/Tails optimization](http://arxiv.org/pdf/1209.2801v1.pdf). Below, Heads/Tails used to color based on the area of the polygons.
+
+![headtails](https://f.cloud.github.com/assets/370259/140655/6eebb918-7228-11e2-89fa-149745f25d34.png)
+
+#### Using the function
+
+We can determine the 7 most optimal breaks in a column of numerical data as follows, 
+
+```sql
+SELECT CDB_HeadsTailsBins(array_agg(numeric_column), 7) FROM table_name
+-- Results in an ordered array like, {7824,23492,52696,233857,666089,1001709,1638094}
+-- Each break happens up to, and equal, to a number: 
+-- (bin1 is less than or equal to 7824, bin2 is less than or equal to 23492, etc.)
+```
+
+#### Arguments
+
+CDB_HeadsTailsBins(in_array, breaks)
+
+* **in_array** numeric[]. A NUMERIC array of values.
+* **breaks** int. The number of categories you want to create
--- a/doc/CDB_HexagonGrid.md
+++ b/doc/CDB_HexagonGrid.md
@@ -0,0 +1,43 @@
+Fill given extent with an hexagonal coverage
+
+#### Using the function
+
+Create a hexagonal grid from a polygon geometry. For example, take the geometry
+
+```sql
+  ST_SetSRID(
+    ST_Envelope(
+      ST_Collect(
+        ST_MakePoint(10000000,-10000000),
+        ST_MakePoint(-10000000,10000000)
+      )
+     ),
+     3857)
+```
+
+We can create a grid as follows, 
+
+```sql
+SELECT CDB_HexagonGrid(
+  ST_SetSRID(
+    ST_Envelope(
+      ST_Collect(
+        ST_MakePoint(10000000,-10000000),
+        ST_MakePoint(-10000000,10000000)
+      )
+     ),
+     3857),
+   1000000) the_geom_webmercator
+```
+
+Which will look something like this,
+
+![grid tile](http://i.imgur.com/4rZXGMb.png)
+
+#### Arguments
+
+CDB_HexagonGrid(ext, side, origin)
+
+* **ext** geometry. Extent to fill. Only hexagons with center point falling inside the extent (or at the lower or leftmost edge) will be emitted. The returned hexagons will have the same SRID as this extent.
+* **side** float. Side measure for the hexagon. Maximum diameter will be 2 * side. Measure is in the same projection as **ext**
+* **origin** OPTIONAL geometry. Optional origin to allow for exact tiling. If omitted the origin will be 0,0. The parameter is checked for having the same SRID as the extent.
--- a/doc/CDB_JenksBins.md
+++ b/doc/CDB_JenksBins.md
@@ -0,0 +1,23 @@
+Find the breaks for N categories in a numerical column based on the [Jenks optimization](http://en.wikipedia.org/wiki/Jenks_natural_breaks_optimization). Below, Jenks used to color based on the area of the polygons.
+
+![Jenks](https://f.cloud.github.com/assets/370259/140093/b64a9382-7210-11e2-81a4-c65cce3c885e.png)
+
+#### Using the function
+
+We can determine the 7 most optimal breaks in a column of numerical data as follows, 
+
+```sql
+SELECT CDB_JenksBins(array_agg(numeric_column), 7) FROM table_name
+-- Results in an ordered array like, {0,73,2568,9408,29411,768230,1638094}
+-- Each break happens up to, and equal, to a number: 
+-- (bin1 is less than or equal to 0, bin2 is less than or equal to 73, etc.)
+```
+
+#### Arguments
+
+CDB_JenksBins(in_array, breaks, invert)
+
+* **in_array** numeric[]. A NUMERIC array of values.
+* **breaks** int. The number of categories you want to create
+* **iterations** OPTIONAL int. The number of iterations used for calculating breaks.
+* **invert** OPTIONAL boolean. Flips whether you receive top down breaks or bottom up breaks. Default is top down (so, <=). Bottom up would give you values that define the lower-end start of a bin (so >=).
--- a/doc/CDB_MakeHexagon.md
+++ b/doc/CDB_MakeHexagon.md
@@ -0,0 +1,21 @@
+Return an Hexagon with given center and side (or maximal radius)
+
+#### Using the function
+
+Running the following SQL
+
+```sql
+SELECT CDB_MakeHexagon(ST_MakePoint(0,0),10000000)
+```
+
+Would give you back a single hexagon geometry, 
+
+![hexagon](http://i.imgur.com/6jeGStb.png)
+
+
+#### Arguments
+
+CDB_MakeHexagon(center, radius)
+
+* **center** geometry
+* **radius** float. Radius of hexagon measured in same projection as **center**
--- a/doc/CDB_Overviews.md
+++ b/doc/CDB_Overviews.md
@@ -0,0 +1,123 @@
+Overviews are tables that represent a *reduced* version of a dataset intended
+for efficient rendering at certain zoom levels while preserving the
+general visual appearance of the complete dataset.
+
+The *reduction* consists in havig a fewer number of records
+(while each overview record may represent an aggregation of multiple records)
+and/or simplified record geometries.
+
+Overviews are created through the `CDB_CreateOverviews` function.
+The statement timeout may need to be adjusted before using this function,
+as overview creation for large tables is a time-consuming operation.
+
+The `CDB_Overviews` function can be used determine what overview tables
+exist for a given dataset table and which zoom levels correspond to it.
+
+The `CDB_DropOverviews` function removes a dataset's existing overviews.
+
+To know if overview tables exist for some base table, and to obtain
+a list of which overview tables are approrpiate for which zoom levels,
+the `CDB_Overviews` functions can be used.
+
+The zoom level we're referring here to are those used
+by the tiler: http://wiki.openstreetmap.org/wiki/Zoom_levels
+
+### CDB_CreateOverviews
+
+Create overviews for vector dataset.
+
+#### Using the function
+
+The table for which overviews will be generated should be
+a Cartodbfied dataset with vector geometry.
+
+```sql
+SELECT CDB_CreateOverviews('table_name');
+--- Generates overview tables for the dataset
+```
+
+#### Arguments
+
+CDB_CreateOverviews(table_name, ref_z_strategy, reduction_strategy)
+
+* **table_name** regclass, table for which overviews will be generated
+* **ref_z_strategy** regproc, optional function that provides
+  the Z-scale strategy.
+  It returns the base Z level for the dataset.
+  It should have these arguments:
+  - **table_name** regclass, table to compute the reference Z scale for
+* **reduction_strategy** regproc, optional function that provides
+  the reduction strategy to generate an overview table from a table
+  for a smaller scale (higher Z number).
+  It returns the name of the generated table.
+  It should have these arguments:
+  - **base_table_name** regclass, base table to be reduced.
+  - **base_z** integer, base Z level assigned to the base table.
+  - **overview_z** integer, Z level for which to generate the overview.
+
+#### Tolerance / level of detail
+
+The level of detail to be representable by each overview layer can
+be specified as a tolerance in pixels (if different from the default of 1 pixel)
+with the function `CDB_CreateOverviewsWithToleranceInPixels`
+which has as a second additional argument the desired tolerance.
+
+This tolerance defines the maximum deviation in pixels of the overviews
+geometries with respect to the original geometries when overview tables
+are used for their intendend zoom level.
+
+### CDB_Overviews
+
+Obtain overview metadata for a given table (existing overviews).
+The returned relation will be empty if the table has no overviews.
+
+The function can be applied to a single table:
+
+```sql
+SELECT CDB_Overviews('table_name');
+--- Return existing overview Z levels and corresponding tables
+```
+
+Or to multiple tables passed as an array; this can be used
+to obtain the overviews that can be applied to a query by
+combining it with `CDB_QueryTablesText`:
+
+```sql
+SELECT CDB_Overviews(CDB_QueryTablesText('SELECT * FROM table1, table2'));
+--- Return existing overview Z levels and corresponding tables
+```
+
+The result of `CDB_Overviews` has three columns:
+
+| base_table | z | overview_table |
+| ---------- | - | -------------- |
+| table1     | 1 | table1_ov1     |
+| table1     | 2 | table1_ov2     |
+| table1     | 4 | table1_ov4     |
+| table2     | 1 | table1_ov1     |
+| table2     | 2 | table1_ov2     |
+
+#### Arguments
+
+CDB_Overviews(table_name)
+
+* **table_name** regclass, oid of table to obtain existing overviews for
+
+CDB_Overviews(table_names)
+
+* **table_names** regclass[], array of table oids
+
+
+### CDB_DropOverviews
+
+Remove the overviews of a table, if present.
+
+```sql
+SELECT CDB_DropOverviews('table_name');
+```
+
+#### Arguments
+
+CDB_Overviews(table_name)
+
+* **table_name** regclass, table for which to drop existing overviews.
--- a/doc/CDB_QuantileBins.md
+++ b/doc/CDB_QuantileBins.md
@@ -0,0 +1,21 @@
+Find the breaks for N categories in a numerical column based on the [Quantile bins]. Below, the quantile method is used to determine color based on the area of the polygons.
+
+![qunatile](https://f.cloud.github.com/assets/370259/140714/932ed0e6-722b-11e2-9807-ffbd0fddb9ac.png)
+
+#### Using the function
+
+We can determine the 7 most optimal breaks in a column of numerical data as follows, 
+
+```sql
+SELECT CDB_QuantileBins(array_agg(numeric_column), 7) FROM table_name
+-- Results in an ordered array like, {80,2281,7162,17652,39730,91077,1638094}
+-- Each break happens up to, and equal, to a number: 
+-- (bin1 is less than or equal to 80, bin2 is less than or equal to 2281, etc.)
+```
+
+#### Arguments
+
+CDB_QuantileBins(in_array, breaks)
+
+* **in_array** numeric[]. A NUMERIC array of values.
+* **breaks** int. The number of categories you want to create
--- a/doc/CDB_RectangleGrid.md
+++ b/doc/CDB_RectangleGrid.md
@@ -0,0 +1,46 @@
+Fill given extent with a rectangular coverage
+
+#### Using the function
+
+Create a rectangular grid from a polygon geometry. For example, take the geometry
+
+```sql
+  ST_SetSRID(
+    ST_Envelope(
+      ST_Collect(
+        ST_MakePoint(10000000,-10000000),
+        ST_MakePoint(-10000000,10000000)
+      )
+     ),
+     3857)
+```
+
+We can create a grid as follows, 
+
+```sql
+SELECT CDB_RectangleGrid(
+  ST_SetSRID(
+    ST_Envelope(
+      ST_Collect(
+        ST_MakePoint(10000000,-10000000),
+        ST_MakePoint(-10000000,10000000)
+      )
+     ),
+     3857),
+   1000000,
+   1000000
+) the_geom_webmercator
+```
+
+Which will look something like this,
+
+![rect grid](http://i.imgur.com/HuhOJRs.png)
+
+#### Arguments
+
+CDB_RectangleGrid(ext, width, height, origin)
+
+* **ext** geometry. Extent to fill. Only rectangles with center point falling inside the extent (or at the lower or leftmost edge) will be emitted. The returned hexagons will have the same SRID as this extent.
+* **width** float. Width of each rectangle. Measure is in the same projection as **ext**
+* **height** float. Height of each rectangle. Measure is in the same projection as **ext**
+* **origin** OPTIONAL geometry. Optional origin to allow for exact tiling. If omitted the origin will be 0,0. The parameter is checked for having the same SRID as the extent.
--- a/doc/CDB_SetUserQuotaInBytes.md
+++ b/doc/CDB_SetUserQuotaInBytes.md
@@ -0,0 +1,11 @@
+Sets user quota in bytes (superuser only)
+
+#### Using the function
+
+```sql
+SELECT CDB_SetUserQuotaInBytes(10485760);
+--- Returns the previously set quota.
+--- Use 0 to disable quota.
+```
+
+REF: https://github.com/CartoDB/cartodb-postgresql/blob/master/scripts-available/CDB_Quota.sql
--- a/doc/CDB_TransformToWebmercator.md
+++ b/doc/CDB_TransformToWebmercator.md
@@ -0,0 +1,44 @@
+Function to "safely" transform to webmercator. This function is most useful for rendering custom geometries using the CartoDB tiler. Often, transforming a projection like WGS84 can cause issues with extents beyond what are actually valid in webmercator, this attempts to fix those issues.
+
+#### Using the function
+
+Using a box that is nearly the full globe,
+
+```sql
+ST_SetSRID(
+  ST_Envelope(
+    ST_Collect(
+      ST_MakePoint(-180,60),
+      ST_MakePoint(180,-60)
+    )
+   ),
+   4326
+)
+```
+
+We can then convert it to a renderable webmercator geometry.
+
+```sql
+SELECT CDB_TransformToWebmercator(
+ ST_SetSRID(
+  ST_Envelope(
+    ST_Collect(
+      ST_MakePoint(-10,60),
+      ST_MakePoint(300,-60)
+    )
+   ),
+   4326
+ )
+)
+```
+
+Would give you back a single valid rectangle in webmercator. Since a longitude of 300 would convert to an unallowed webmercator coordinate, it gets clipped first. Valid extent is WGS84 (-180, -89, 180, 89)
+
+![valid geom](http://i.imgur.com/EFdXiqt.png)
+
+
+#### Arguments
+
+CDB_TransformToWebmercator(geom)
+
+* **geom** geometry
--- a/doc/CDB_UserTables.md
+++ b/doc/CDB_UserTables.md
@@ -0,0 +1,11 @@
+List the name of available tables (only the usable ones)
+
+#### Using the function
+
+```sql
+--- Returns a row for each table having given permission with the table name
+--- Currently accepted permissions are: 'public', 'private' or 'all'
+SELECT CDB_UserTables(perms)
+```
+
+REF: https://github.com/CartoDB/cartodb-postgresql/blob/master/scripts-available/CDB_UserTables.sql
--- a/doc/CDB_XYZ_Extent.md
+++ b/doc/CDB_XYZ_Extent.md
@@ -0,0 +1,22 @@
+Determine the spatial extent of a tile based on the tile's XYZ coordinate.
+
+#### Using the function
+
+Take a common tile with coordinates x=3, y=2, z=2,
+
+![2/3/2](https://viz2.cartodb.com/tiles/quantile_breaks/2/3/2.png)
+
+To determine its extent you would run,
+
+```sql
+SELECT CDB_XYZ_Extent(3,2,2)
+--- Returns a WKB polygon in Webmercator (SRID 3857)
+```
+
+#### Arguments
+
+CDB_XYZ_Extent(x,y,z)
+
+* **x** integer
+* **y** integer
+* **z** integer
--- a/doc/CDB_XYZ_Resolution.md
+++ b/doc/CDB_XYZ_Resolution.md
@@ -0,0 +1,20 @@
+Return pixel resolution of tiles at a given zoom level
+
+#### Using the function
+
+Take a common tile with zoom, z=2,
+
+![2/3/2](https://viz2.cartodb.com/tiles/quantile_breaks/2/3/2.png)
+
+To determine the resolution of these pixels,
+
+```sql
+SELECT CDB_XYZ_Resolution(2)
+--- Returns a float, 39135.7587890625
+```
+
+#### Arguments
+
+CDB_XYZ_Resolution(z)
+
+* **z** integer
--- a/doc/CartoDB-PLpgSQL.md
+++ b/doc/CartoDB-PLpgSQL.md
@@ -0,0 +1,38 @@
+INTRODUCTION
+============
+
+CartoDB uses a number of custom [PLpgSQL](http://www.postgresql.org/docs/8.3/static/plpgsql.html) functions to perform a few magical things. Those functions are accessible to users on CartoDB as well, so we would like to document what they are and what they do here.
+
+## Spatial functions
+
+[CDB_HexagonGrid](CDB_HexagonGrid) - create hexagonal grid from extent and size
+
+[CDB_MakeHexagon](CDB_MakeHexagon) - make a hexagon with given center and side
+
+[CDB_RectangleGrid](CDB_RectangleGrid) - fill given extent with a rectangular coverage
+
+##### Tile based
+
+[CDB_XYZ_Extent](CDB_XYZ_Extent) - Find the extent of a tile by XYZ
+
+[CDB_XYZ_Resolution](CDB_XYZ_Resolution) - Find the pixel resolution of tiles
+
+[CDB_TransformToWebmercator](CDB_TransformToWebmercator) - Convert a geometry to valid webmercator
+
+## Statistical functions
+
+[CDB_JenksBins](CDB_JenksBins) - Find breaks in an array of numbers using Jenks method
+
+[CDB_HeadsTailsBins](CDB_HeadsTailsBins) - Find breaks in an array of numbers using Heads/Tails method
+
+[CDB_QuantileBins](CDB_QuantileBins) - Find quantile breaks in an array of numbers
+
+## System functions
+
+[CDB_UserTables](CDB_UserTables) - Get a list of all tables in your account
+
+[[CDB_SetUserQuotaInBytes]] - Set maximum user quota in bytes
+
+column names - now returned in JSON response
+
+column types - now returned in JSON response
--- a/doc/CartoDB-user-table.rst
+++ b/doc/CartoDB-user-table.rst
@@ -0,0 +1,68 @@
+CartoDB User Table
+==================
+
+Introduction
+----------
+A CartoDB user table is a table with a well-known set of columns and a well-known set of triggers attached on.
+
+Columns
+----------
+The required columns of a CartoDB table are:
+
+-  ``cartodb_id``
+  - This column will be used as the primary key of the table and it has a sequence as default value
+  - Its values must be integer, non-zero, non-null and unique
+  -  B-Tree indexed
+-  ``the_geom``
+  - This column stores the main geometric features of a table
+  - The type of the column in the Postgres database is ``geometry(Geometry,4326)```
+  - GiST indexed
+  -  geometry, GiST indexed, constrained (see below)
+-  ``the_geom_webmercator``
+  - This column stores the geometries used for rendering purposes
+  - The type of the column in the Postgres database is ``geometry(Geometry,3857)``
+  - GiST indexed
+  - This column is automatically updated by the system when the ``the_geom`` column is updated or when there is an insertion of a new row into the table (See triggers below)
+
+The values of ``the_geom`` and ``the_geom_webmercator`` must be two-dimensional Points, MultiLineStrings or MultiPolygons. Different geometric types in a CartoDB table are not supported.
+
+Described table example
+^^^^^^^^^^
+::
+
+        Column        |          Type           |                       Modifiers                        
+  ----------------------+-------------------------+--------------------------------------------------------
+   cartodb_id           | bigint                  | not null default nextval('t_cartodb_id_seq'::regclass)
+   the_geom             | geometry(Geometry,4326) | 
+   the_geom_webmercator | geometry(Geometry,3857) | 
+  Indexes:
+      "table_name_pkey" PRIMARY KEY, btree (cartodb_id)
+      "table_name_the_geom_idx" gist (the_geom)
+      "table_name_the_geom_webmercator_idx" gist (the_geom_webmercator)
+
+Triggers
+----------
+The triggers generated in each CartoDB table are:
+
+-  ``track_updates`` after modifying statement updates ``cdb_tablemetadata``
+-  ``test_quota`` before changing statement to forbid if overquota
+-  ``test_quota_per_row`` before insert ot update row to forbid if overquota (checked on a probabilistic basis)
+-  ``update_the_geom_webmercator`` before insert or update row to maintain the ``the_geom_webmercator`` updated with the contents in ``the_geom``
+
+Described triggers example
+^^^^^^^^^^
+::
+
+  test_quota BEFORE INSERT OR UPDATE ON t FOR EACH STATEMENT EXECUTE PROCEDURE cdb_checkquota('0.1', '-1', 'public')
+  test_quota_per_row BEFORE INSERT OR UPDATE ON t FOR EACH ROW EXECUTE PROCEDURE cdb_checkquota('0.001', '-1', 'public')
+  track_updates AFTER INSERT OR DELETE OR UPDATE OR TRUNCATE ON t FOR EACH STATEMENT EXECUTE PROCEDURE cdb_tablemetadata_trigger()
+  update_the_geom_webmercator_trigger BEFORE INSERT OR UPDATE OF the_geom ON t FOR EACH ROW EXECUTE PROCEDURE _cdb_update_the_geom_webmercator()
+
+
+Further details
+----------
+
+Some conversions will be attempted to perform upon cartodbfication when certain fields appear:
+
+-  ``cartodb_id``: If found type TEXT will be attempted to cast to integer. If not casteable, an eror will be raised.
+-  ``the_geom``: If found type TEXT will be attempted to cast to geometry(Geometry,4326).
--- a/doc/README.md
+++ b/doc/README.md
@@ -0,0 +1,23 @@
+# Contents
+
+* [CartoDB-user-table](CartoDB-user-table.md)
+* [CartoDB-PLpgSQL](CartoDB-PLpgSQL.md)
+* [CDB_ColumnNames](CDB_ColumnNames.md)
+* [CDB_ColumnType](CDB_ColumnType.md)
+* [CDB_HeadsTailsBins](CDB_HeadsTailsBins.md)
+* [CDB_HexagonGrid](CDB_HexagonGrid.md)
+* [CDB_JenksBins](CDB_JenksBins.md)
+* [CDB_MakeHexagon](CDB_MakeHexagon.md)
+* [CDB_QuantileBins](CDB_QuantileBins.md)
+* [CDB_RectangleGrid](CDB_RectangleGrid.md)
+* [CDB_SetUserQuotaInBytes](CDB_SetUserQuotaInBytes.md)
+* [CDB_TransformToWebmercator](CDB_TransformToWebmercator.md)
+* [CDB_UserTables](CDB_UserTables.md)
+* [CDB_XYZ_Extent](CDB_XYZ_Extent.md)
+* [CDB_XYZ_Resolution](CDB_XYZ_Resolution.md)
+
+The CartoDB PostgreSQL extension is a module to load into each CartoDB user database to perform cartodb-specific security and functionality checks.
+
+# Checks
+
+User tables need to match certain structure criteria (See [[CartoDB-user-table]]) so the extension should provide a mean to enforce such structure everytime an attempt to change structure is encountered. 
--- a/doc/cartodbfy-requirements.rst
+++ b/doc/cartodbfy-requirements.rst
@@ -0,0 +1,63 @@
+CartoDBfy Requirements
+======================
+
+Introduction
+------------
+
+This document aims at describing what the CartoDBfication is and what its formal requirements are, with the following goals in mind:
+
+- Clarify what are the expectations of the "cartodbfycation process".
+- Define an important part of what should be a stable, public API
+- Allow for better testing, which should in turn...
+- ...ease modifications and increase quality of the code
+
+
+What is the CartoDBfycation
+---------------------------
+
+The CartoDBfycation is the process of converting an arbitrary postgres table into a valid CartoDB table, and register it in the system so that it can be used in the CartoDB editor and platform to generate maps and analysis.
+
+It is performed by running the function ``CDB_CartodbfyTable(reloid REGCLASS)`` over a target table.
+
+Valid CartoDB tables
+--------------------
+
+A valid CartoDB table shall meet the following conditions:
+
+- Have a ``cartodb_id`` column with integer, unique, non-zero and non-null values as primary key with a sequence as default value
+- Have a ``the_geom`` column of type ``Geometry`` with SRID 4326
+- Have a ``the_geom_webmercator`` column of type ``Geometry`` with SRID 3857
+- The columns ``the_geom`` and ``the_geom_webmercator`` shall be in sync (task of the ``update_the_geom_webmercator`` trigger)
+
+Additionally, a CartoDB table can contain other columns.
+
+See the `CartoDB User Table documentation`_
+
+.. _CartoDB User Table documentation: https://github.com/CartoDB/cartodb-postgresql/blob/master/doc/CartoDB-user-table.rst 
+for further information.
+
+High level requirements
+-----------------------
+
+Here is a list of high level requirments for the public function ``CDB_CartodbfyTable()``:
+
+- A call to the function shall modify/rewrite the table and produce a valid CartoDB table with the same name.
+- A call to the function shall cause the registration of the table into the platform.
+- It shall be idempotent, meaning that successive calls to the function shall not produce any visible effect in the system.
+- If there's a column containing a geometry, it shall be used to generate ``the_geom`` and the ``the_geom_webmercator`` columns.
+- Exporting and re-importing the same table in CartoDB shall produce equivalent tables, with the same features associated to the same ``cartodb_id``'s.
+
+
+Note that there should be only one geometry per row in the source table. If there's more than one, then which one is used for ``the_geom`` and ``the_geom_webmercator`` fields is not determined.
+
+
+Low-level requirements
+----------------------
+
+- If the original table contains a valid (integer, unique, non-zero and not null) ``cartodb_id`` column, it shall be used
+- If the original table contains a ``the_geom`` column or a ``the_geom_webmercator`` geometric column in the expected projection (EPSG 4326 and EPSG 3857, respectively) they shall be used.
+- A modification of a cartodbfy'ed table shall insert or update a row in ``CDB_TableMetadata``
+- A cartodbfy'ed table shall have a ``btree`` index on ``cartodb_id``
+- A cartodbfy'ed table shall have ``gist`` indices on ``the_geom`` and ``the_geom_webmercator``
+- Cartodbfy shall deal with text columns for imports, regarding CartoDB columns (``cartodb_id``, ``the_geom``, ``the_geom_webmercator``)
+
--- a/expected/test_ddl_triggers.out
+++ b/expected/test_ddl_triggers.out
@@ -1,258 +0,0 @@
-\set VERBOSITY terse
-- Set user quota to infinite
-SELECT CDB_SetUserQuotaInBytes(0);
- cdb_setuserquotainbytes 
-------------------------
-                       0
-(1 row)
-
-- Enable ddl triggers
-SELECT cartodb.cdb_enable_ddl_hooks();
-NOTICE:  event trigger "cdb_on_relation_create" does not exist, skipping
-NOTICE:  event trigger "cdb_on_relation_drop" does not exist, skipping
-NOTICE:  event trigger "cdb_on_alter_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_drop_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_add_column" does not exist, skipping
- cdb_enable_ddl_hooks 
----------------------
- 
-(1 row)
-
-create schema c;
-CREATE USER cartodb_postgresql_unpriv_user;
-GRANT ALL ON SCHEMA c to cartodb_postgresql_unpriv_user;
-SET SESSION AUTHORIZATION 'cartodb_postgresql_unpriv_user';
--SELECT session_user, current_user;
----------------------
-- CREATE TABLE
----------------------
-select 1 as i INTO c.t3;
-NOTICE:  trigger "track_updates" for table "c.t3" does not exist, skipping
-NOTICE:  trigger "update_the_geom_webmercator_trigger" for table "c.t3" does not exist, skipping
-NOTICE:  trigger "update_updated_at_trigger" for table "c.t3" does not exist, skipping
-NOTICE:  trigger "test_quota" for table "c.t3" does not exist, skipping
-NOTICE:  trigger "test_quota_per_row" for table "c.t3" does not exist, skipping
-NOTICE:  event trigger "cdb_on_relation_create" does not exist, skipping
-NOTICE:  event trigger "cdb_on_relation_drop" does not exist, skipping
-NOTICE:  event trigger "cdb_on_alter_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_drop_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_add_column" does not exist, skipping
-NOTICE:  cdb_invalidate_varnish(c.t3) called
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i
-from c.t3;
- cartodb_id | c=u | u<1s | the_geom | the_geom_webmercator | i 
------------+-----+------+----------+----------------------+---
-          1 | t   | t    |          |                      | 1
-(1 row)
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)) as age
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
- tabname | age 
---------+-----
- c.t3    |   0
-(1 row)
-
-- Table with cartodb_id field, see
-- http://github.com/CartoDB/cartodb-postgresql/issues/32
-select 1 as cartodb_id INTO c.t4;
-NOTICE:  trigger "track_updates" for table "c.t4" does not exist, skipping
-NOTICE:  trigger "update_the_geom_webmercator_trigger" for table "c.t4" does not exist, skipping
-NOTICE:  trigger "update_updated_at_trigger" for table "c.t4" does not exist, skipping
-NOTICE:  trigger "test_quota" for table "c.t4" does not exist, skipping
-NOTICE:  trigger "test_quota_per_row" for table "c.t4" does not exist, skipping
-NOTICE:  Column cartodb_id already exists
-NOTICE:  Existing cartodb_id field does not have an associated sequence, renaming
-NOTICE:  Trying to recover data from _cartodb_id0 column
-NOTICE:  event trigger "cdb_on_relation_create" does not exist, skipping
-NOTICE:  event trigger "cdb_on_relation_drop" does not exist, skipping
-NOTICE:  event trigger "cdb_on_alter_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_drop_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_add_column" does not exist, skipping
-NOTICE:  cdb_invalidate_varnish(c.t4) called
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator
-from c.t4;
- cartodb_id | c=u | u<1s | the_geom | the_geom_webmercator 
------------+-----+------+----------+----------------------
-          1 | t   | t    |          | 
-(1 row)
-
-select
- tabname::text,
- round(extract('secs' from now() - updated_at)) as age
-FROM CDB_TableMetadata WHERE tabname = 'c.t4'::regclass;
- tabname | age 
---------+-----
- c.t4    |   0
-(1 row)
-
----------------------------
-- ALTER TABLE RENAME COLUMN
----------------------------
-select pg_sleep(.1);
- pg_sleep 
----------
- 
-(1 row)
-
-alter table c.t3 rename column the_geom_webmercator to webmerc;
-NOTICE:  Column cartodb_id already exists
-NOTICE:  Column created_at already exists
-NOTICE:  Column updated_at already exists
-NOTICE:  Column the_geom already exists
-NOTICE:  event trigger "cdb_on_relation_create" does not exist, skipping
-NOTICE:  event trigger "cdb_on_relation_drop" does not exist, skipping
-NOTICE:  event trigger "cdb_on_alter_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_drop_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_add_column" does not exist, skipping
-NOTICE:  cdb_invalidate_varnish(c.t3) called
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i, webmerc
-from c.t3;
- cartodb_id | c=u | u<1s | the_geom | the_geom_webmercator | i | webmerc 
------------+-----+------+----------+----------------------+---+---------
-          1 | t   | t    |          |                      | 1 | 
-(1 row)
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)*10) as agecs
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
- tabname | agecs 
---------+-------
- c.t3    |     0
-(1 row)
-
-select pg_sleep(.1);
- pg_sleep 
----------
- 
-(1 row)
-
-alter table c.t3 rename column the_geom_webmercator to webmerc2;
-NOTICE:  Column cartodb_id already exists
-NOTICE:  Column created_at already exists
-NOTICE:  Column updated_at already exists
-NOTICE:  Column the_geom already exists
-NOTICE:  event trigger "cdb_on_relation_create" does not exist, skipping
-NOTICE:  event trigger "cdb_on_relation_drop" does not exist, skipping
-NOTICE:  event trigger "cdb_on_alter_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_drop_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_add_column" does not exist, skipping
-NOTICE:  cdb_invalidate_varnish(c.t3) called
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i, webmerc, webmerc2
-from c.t3;
- cartodb_id | c=u | u<1s | the_geom | the_geom_webmercator | i | webmerc | webmerc2 
------------+-----+------+----------+----------------------+---+---------+----------
-          1 | t   | t    |          |                      | 1 |         | 
-(1 row)
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)*10) as agecs
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
- tabname | agecs 
---------+-------
- c.t3    |     0
-(1 row)
-
----------------------------
-- ALTER TABLE DROP COLUMN
----------------------------
-select pg_sleep(.1);
- pg_sleep 
----------
- 
-(1 row)
-
-alter table c.t3 drop column the_geom_webmercator;
-NOTICE:  Column cartodb_id already exists
-NOTICE:  Column created_at already exists
-NOTICE:  Column updated_at already exists
-NOTICE:  Column the_geom already exists
-NOTICE:  event trigger "cdb_on_relation_create" does not exist, skipping
-NOTICE:  event trigger "cdb_on_relation_drop" does not exist, skipping
-NOTICE:  event trigger "cdb_on_alter_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_drop_column" does not exist, skipping
-NOTICE:  event trigger "cdb_on_add_column" does not exist, skipping
-NOTICE:  cdb_invalidate_varnish(c.t3) called
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i, webmerc, webmerc2
-from c.t3;
- cartodb_id | c=u | u<1s | the_geom | the_geom_webmercator | i | webmerc | webmerc2 
------------+-----+------+----------+----------------------+---+---------+----------
-          1 | t   | t    |          |                      | 1 |         | 
-(1 row)
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)*10) as agecs
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
- tabname | agecs 
---------+-------
- c.t3    |     0
-(1 row)
-
----------------------------
-- ALTER TABLE ADD COLUMN
----------------------------
-select pg_sleep(.1);
- pg_sleep 
----------
- 
-(1 row)
-
-alter table c.t3 add column id2 int;
-NOTICE:  cdb_invalidate_varnish(c.t3) called
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i, webmerc, webmerc2, id2
-from c.t3;
- cartodb_id | c=u | u<1s | the_geom | the_geom_webmercator | i | webmerc | webmerc2 | id2 
------------+-----+------+----------+----------------------+---+---------+----------+-----
-          1 | t   | t    |          |                      | 1 |         |          |    
-(1 row)
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)*10) as agecs
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
- tabname | agecs 
---------+-------
- c.t3    |     0
-(1 row)
-
----------------------------
-- DROP TABLE
----------------------------
-RESET SESSION AUTHORIZATION;
-drop schema c cascade;
-NOTICE:  drop cascades to 2 other objects
-select count(*) from CDB_TableMetadata;
- count 
-------
-     0
-(1 row)
-
-DROP USER cartodb_postgresql_unpriv_user;
-DROP FUNCTION _CDB_UserQuotaInBytes();
--- a/expected/test_setup.out
+++ b/expected/test_setup.out
@@ -1,5 +1,4 @@
 CREATE EXTENSION postgis;
-CREATE EXTENSION schema_triggers;
 CREATE EXTENSION plpythonu;
 CREATE EXTENSION cartodb;
 CREATE FUNCTION public.cdb_invalidate_varnish(table_name text)
--- a/scripts-available/CDB_AnalysisCatalog.sql
+++ b/scripts-available/CDB_AnalysisCatalog.sql
@@ -0,0 +1,24 @@
+-- Table to register analysis nodes from https://github.com/cartodb/camshaft
+CREATE TABLE IF NOT EXISTS
+cartodb.cdb_analysis_catalog (
+    -- md5 hex hash
+    node_id char(40) CONSTRAINT cdb_analysis_catalog_pkey PRIMARY KEY,
+    -- being json allows to do queries like analysis_def->>'type' = 'buffer'
+    analysis_def json NOT NULL,
+    -- can reference other nodes in this very same table, allowing recursive queries
+    input_nodes char(40) ARRAY NOT NULL DEFAULT '{}',
+    status TEXT NOT NULL DEFAULT 'pending',
+    CONSTRAINT valid_status CHECK (
+        status IN ( 'pending', 'waiting', 'running', 'canceled', 'failed', 'ready' )
+    ),
+    created_at timestamp with time zone NOT NULL DEFAULT now(),
+    -- should be updated when some operation was performed in the node
+    -- and anything associated to it might have changed
+    updated_at timestamp with time zone DEFAULT NULL,
+    -- should register last time the node was used
+    used_at timestamp with time zone NOT NULL DEFAULT now(),
+    -- should register the number of times the node was used
+    hits NUMERIC DEFAULT 0,
+    -- should register what was the last node using current node
+    last_used_from char(40)
+);
--- a/scripts-available/CDB_CartodbfyTable.sql
+++ b/scripts-available/CDB_CartodbfyTable.sql
--- a/scripts-available/CDB_ColumnNames.sql
+++ b/scripts-available/CDB_ColumnNames.sql
@@ -2,13 +2,13 @@
 CREATE OR REPLACE FUNCTION CDB_ColumnNames(REGCLASS)
 RETURNS SETOF information_schema.sql_identifier
 AS $$
-
-    SELECT column_name 
-      FROM information_schema.columns 
-      WHERE
-        table_name IN (SELECT CDB_UserTables())
-        AND table_name = '' || $1 || '';
-         
+  SELECT
+    a.attname::information_schema.sql_identifier column_name
+    FROM pg_class c
+         LEFT JOIN pg_attribute a ON a.attrelid = c.oid
+    WHERE c.oid = $1::oid
+    AND a.attstattarget < 0 -- exclude system columns
+   ORDER BY a.attnum;
 $$ LANGUAGE SQL;

 -- This is to migrate from pre-0.2.0 version
--- a/scripts-available/CDB_ColumnType.sql
+++ b/scripts-available/CDB_ColumnType.sql
@@ -2,14 +2,13 @@
 CREATE OR REPLACE FUNCTION CDB_ColumnType(REGCLASS, TEXT)
 RETURNS information_schema.character_data
 AS $$
-
-    SELECT data_type 
-      FROM information_schema.columns 
-      WHERE
-        table_name IN (SELECT CDB_UserTables())
-        AND table_name = '' || $1 || ''
-        AND column_name = '' || quote_ident($2) || '';
-         
+  SELECT
+    format_type(a.atttypid, NULL)::information_schema.character_data data_type
+  FROM pg_class c
+       LEFT JOIN pg_attribute a ON a.attrelid = c.oid
+  WHERE c.oid = $1::oid
+  AND a.attname = $2
+  AND a.attstattarget < 0; -- exclude system columns
 $$ LANGUAGE SQL;

 -- This is to migrate from pre-0.2.0 version
--- a/scripts-available/CDB_Conf.sql
+++ b/scripts-available/CDB_Conf.sql
@@ -0,0 +1,48 @@
+----------------------------------
+-- CONF MANAGEMENT FUNCTIONS
+--
+-- Meant to be used by superadmin user.
+-- Functions needing reading configuration should use SECURITY DEFINER.
+----------------------------------
+
+-- This will trigger NOTICE if cartodb.CDB_CONF already exists
+DO LANGUAGE 'plpgsql' $$
+BEGIN
+    CREATE TABLE IF NOT EXISTS cartodb.CDB_CONF ( KEY TEXT PRIMARY KEY, VALUE JSON NOT NULL );
+END
+$$;
+
+-- This can only be called from an SQL script executed by CREATE EXTENSION
+DO LANGUAGE 'plpgsql' $$
+BEGIN
+    PERFORM pg_catalog.pg_extension_config_dump('cartodb.CDB_CONF', '');
+END
+$$;
+
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Conf_SetConf(key text, value JSON)
+    RETURNS void AS $$
+BEGIN
+    PERFORM cartodb.CDB_Conf_RemoveConf(key);
+    EXECUTE 'INSERT INTO cartodb.CDB_CONF (KEY, VALUE) VALUES ($1, $2);' USING key, value;
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Conf_RemoveConf(key text)
+    RETURNS void AS $$
+BEGIN
+    EXECUTE 'DELETE FROM cartodb.CDB_CONF WHERE KEY = $1;' USING key;
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Conf_GetConf(key text)
+    RETURNS JSON AS $$
+DECLARE
+    value JSON;
+BEGIN
+    EXECUTE 'SELECT VALUE FROM cartodb.CDB_CONF WHERE KEY = $1;' INTO value USING key;
+    RETURN value;
+END
+$$ LANGUAGE PLPGSQL STABLE;
--- a/scripts-available/CDB_DDLTriggers.sql
+++ b/scripts-available/CDB_DDLTriggers.sql
@@ -1,187 +0,0 @@
-- Table creation
-- {
-CREATE OR REPLACE FUNCTION cartodb.cdb_handle_create_table ()
-RETURNS event_trigger SECURITY DEFINER LANGUAGE plpgsql AS $$
-DECLARE
-  event_info RECORD;
-BEGIN
-  event_info := schema_triggers.get_relation_create_eventinfo();
-
-  -- We're only interested in real relations
-  IF (event_info.new).relkind != 'r' THEN RETURN; END IF;
-
-  RAISE DEBUG 'Relation % of kind % created in namespace oid %',
-	 event_info.relation, (event_info.new).relkind, (event_info.new).relnamespace;
-
-  -- We don't want to react to alters triggered by superuser,
-  IF current_setting('is_superuser') = 'on' THEN
-    RAISE DEBUG 'no ddl trigger for superuser';
-    RETURN;
-  END IF;
-
-  PERFORM cartodb.cdb_disable_ddl_hooks();
-
-  -- CDB_CartodbfyTable must not create tables, or infinite loop will happen
-  PERFORM cartodb.CDB_CartodbfyTable(event_info.relation);
-
-  PERFORM cartodb.cdb_enable_ddl_hooks();
-
-  RAISE DEBUG 'Inserting into cartodb.CDB_TableMetadata';
-
-  -- Add entry to CDB_TableMetadata (should CartodbfyTable do this?)
-  INSERT INTO cartodb.CDB_TableMetadata(tabname,updated_at) 
-  VALUES (event_info.relation, now());
-
-END; $$;
-- }
-
-- Table drop
-- {
-CREATE OR REPLACE FUNCTION cartodb.cdb_handle_drop_table ()
-RETURNS event_trigger SECURITY DEFINER LANGUAGE plpgsql AS $$
-DECLARE
-  event_info RECORD;
-BEGIN
-  event_info := schema_triggers.get_relation_drop_eventinfo();
-
-  -- We're only interested in real relations
-  IF (event_info.old).relkind != 'r' THEN RETURN; END IF;
-
-  RAISE DEBUG 'Relation % of kind % dropped from namespace oid %',
-	 event_info.old_relation_oid, (event_info.old).relkind, (event_info.old).relnamespace;
-
-  -- delete record from CDB_TableMetadata (should invalidate varnish)
-  DELETE FROM cartodb.CDB_TableMetadata WHERE tabname = event_info.old_relation_oid;
-
-END; $$;
-- }
-
-- Column alter
-- {
-CREATE OR REPLACE FUNCTION cartodb.cdb_handle_alter_column ()
-RETURNS event_trigger SECURITY DEFINER LANGUAGE plpgsql AS $$
-DECLARE
-  event_info RECORD;
-  rel RECORD;
-BEGIN
-  event_info := schema_triggers.get_column_alter_eventinfo();
-
-  SELECT oid,* FROM pg_class WHERE oid = event_info.relation INTO rel;
-
-  RAISE DEBUG 'Column % altered by % (superuser? %) in relation % of kind %',
-	 (event_info.old).attname, current_user, current_setting('is_superuser'), event_info.relation::regclass, rel.relkind;
-
-  -- We're only interested in real relations
-  IF rel.relkind != 'r' THEN RETURN; END IF;
-
-  -- We don't want to react to alters triggered by superuser,
-  IF current_setting('is_superuser') = 'on' THEN
-    RAISE DEBUG 'no ddl trigger for superuser';
-    RETURN;
-  END IF;
-
-  PERFORM cartodb.cdb_disable_ddl_hooks();
-
-  PERFORM cartodb.CDB_CartodbfyTable(event_info.relation);
-
-  PERFORM cartodb.cdb_enable_ddl_hooks();
-
-  -- update CDB_TableMetadata.updated_at (should invalidate varnish)
-  UPDATE cartodb.CDB_TableMetadata SET updated_at = NOW()
-  WHERE tabname = event_info.relation; 
-
-END; $$;
-- }
-
-- Column drop
-- {
-CREATE OR REPLACE FUNCTION cartodb.cdb_handle_drop_column ()
-RETURNS event_trigger SECURITY DEFINER LANGUAGE plpgsql AS $$
-DECLARE
-  event_info RECORD;
-  rel RECORD;
-BEGIN
-  event_info := schema_triggers.get_column_drop_eventinfo();
-
-  SELECT oid,* FROM pg_class WHERE oid = event_info.relation INTO rel;
-
-  RAISE DEBUG 'Column % drop by % (superuser? %) in relation % of kind %',
-	 (event_info.old).attname, current_user, current_setting('is_superuser'), event_info.relation::regclass, rel.relkind;
-
-  -- We're only interested in real relations
-  IF rel.relkind != 'r' THEN RETURN; END IF;
-
-  -- We don't want to react to drops triggered by superuser,
-  IF current_setting('is_superuser') = 'on' THEN
-    RAISE DEBUG 'no ddl trigger for superuser';
-    RETURN;
-  END IF;
-
-  PERFORM cartodb.cdb_disable_ddl_hooks();
-
-  PERFORM cartodb.CDB_CartodbfyTable(event_info.relation);
-
-  PERFORM cartodb.cdb_enable_ddl_hooks();
-
-  -- update CDB_TableMetadata.updated_at (should invalidate varnish)
-  UPDATE cartodb.CDB_TableMetadata SET updated_at = NOW()
-  WHERE tabname = event_info.relation; 
-
-END; $$;
-- }
-
-- Column add
-- {
-CREATE OR REPLACE FUNCTION cartodb.cdb_handle_add_column ()
-RETURNS event_trigger SECURITY DEFINER LANGUAGE plpgsql AS $$
-DECLARE
-  event_info RECORD;
-  rel RECORD;
-BEGIN
-  event_info := schema_triggers.get_column_add_eventinfo();
-
-  SELECT oid,* FROM pg_class WHERE oid = event_info.relation INTO rel;
-
-  RAISE DEBUG 'Column % added by % (superuser? %) in relation % of kind %',
-	 (event_info.new).attname, current_user, current_setting('is_superuser'), event_info.relation::regclass, rel.relkind;
-
-  -- We're only interested in real relations
-  IF rel.relkind != 'r' THEN RETURN; END IF;
-
-  -- We don't want to react to drops triggered by superuser,
-  IF current_setting('is_superuser') = 'on' THEN
-    RAISE DEBUG 'no ddl trigger for superuser';
-    RETURN;
-  END IF;
-
-  -- update CDB_TableMetadata.updated_at (should invalidate varnish)
-  UPDATE cartodb.CDB_TableMetadata SET updated_at = NOW()
-  WHERE tabname = event_info.relation; 
-
-END; $$;
-- }
-
-CREATE OR REPLACE FUNCTION cartodb.cdb_disable_ddl_hooks() returns void AS $$
- DROP EVENT TRIGGER IF EXISTS cdb_on_relation_create;
- DROP EVENT TRIGGER IF EXISTS cdb_on_relation_drop;
- DROP EVENT TRIGGER IF EXISTS cdb_on_alter_column;
- DROP EVENT TRIGGER IF EXISTS cdb_on_drop_column;
- DROP EVENT TRIGGER IF EXISTS cdb_on_add_column;
-$$ LANGUAGE sql;
-
-CREATE OR REPLACE FUNCTION cartodb.cdb_enable_ddl_hooks() returns void AS $$
- SELECT cartodb.cdb_disable_ddl_hooks();
- CREATE EVENT TRIGGER cdb_on_relation_create
-    ON "relation_create" EXECUTE PROCEDURE cartodb.cdb_handle_create_table();
- CREATE EVENT TRIGGER cdb_on_relation_drop
-    ON "relation_drop" EXECUTE PROCEDURE cartodb.cdb_handle_drop_table();
- CREATE EVENT TRIGGER cdb_on_alter_column
-    ON "column_alter" EXECUTE PROCEDURE cartodb.cdb_handle_alter_column();
- CREATE EVENT TRIGGER cdb_on_drop_column
-    ON "column_drop" EXECUTE PROCEDURE cartodb.cdb_handle_drop_column();
- CREATE EVENT TRIGGER cdb_on_add_column
-    ON "column_add" EXECUTE PROCEDURE cartodb.cdb_handle_add_column();
-$$ LANGUAGE sql;
-
-- Do not enable hooks by default
--SELECT cartodb.cdb_enable_ddl_hooks();
--- a/scripts-available/CDB_DateToNumber.sql
+++ b/scripts-available/CDB_DateToNumber.sql
@@ -13,3 +13,19 @@ RETURN output;
 END;
 $$
 LANGUAGE 'plpgsql' STABLE STRICT;
+
+-- Convert timestamp with time zone to double precision
+--
+CREATE OR REPLACE FUNCTION CDB_DateToNumber(input timestamp with time zone)
+RETURNS double precision AS $$
+DECLARE output double precision;
+BEGIN
+    BEGIN
+        SELECT extract (EPOCH FROM input) INTO output;
+    EXCEPTION WHEN OTHERS THEN
+        RETURN NULL;
+    END;
+RETURN output;
+END;
+$$
+LANGUAGE 'plpgsql' STABLE STRICT;
--- a/scripts-available/CDB_DistType.sql
+++ b/scripts-available/CDB_DistType.sql
@@ -0,0 +1,122 @@
+--
+-- CDB_DistType classifies the histograms of a column into
+-- one of the basic types listed by Galtung: http://druedin.com/2012/12/08/galtungs-ajus-system/
+-- 
+-- Future improvements:
+--    variable number of bins (7 is baked in right now)
+--    catch the number of items to ensure that the sample is large enough
+--
+-- Refs:
+--    1. width_bucket/histograms: http://tapoueh.org/blog/2014/02/21-PostgreSQL-histogram
+--    2. R implementation: https://github.com/cran/agrmt
+
+CREATE OR REPLACE FUNCTION CDB_DistType ( in_array NUMERIC[] ) RETURNS text as $$
+DECLARE
+    element_count INT4;
+    minv numeric;
+    maxv numeric;
+    bins numeric[];
+    freqs numeric[];
+    ajus INT[];
+    freq INT4;
+    signature text;
+    i INT := 1;
+BEGIN
+    SELECT min(e), max(e), count(e) INTO minv, maxv, element_count FROM ( SELECT unnest(in_array) e ) x;
+
+    IF abs(maxv - minv) < 1e-7 THEN -- if max and min are nearly equal, call if 'F' (make relative to maxv?)
+        signature = 'F';
+    ELSE
+        -- Calculate bins and count in bins
+        EXECUTE 'WITH stats as (
+            SELECT min(e) as minv,
+                   max(e) as maxv,
+                   count(e) as total
+            FROM (SELECT unnest($1) e) x
+            WHERE e is not null
+        ),
+        hist as (
+            SELECT width_bucket(e, s.minv, s.maxv, 7) bucket,
+                   count(*) freq
+            FROM (SELECT unnest($1) e) x, stats s
+            WHERE e is not null
+            GROUP BY 1
+            ORDER BY 1
+        )
+        SELECT array_agg(round(100.0 * hist.freq::numeric / stats.total::numeric,1)) freqs,
+               array_agg(hist.bucket) buckets
+        FROM hist, stats'
+        INTO freqs, bins
+        USING in_array;
+
+        LOOP
+            IF i < 7 THEN
+                ajus[i] = CASE WHEN freqs[i] > freqs[i+1] THEN -1
+                               WHEN abs(freqs[i] - freqs[i+1]) <= 0.05 THEN 0
+                               ELSE 1 END;
+            ELSE
+                EXIT;
+            END IF;
+            i := i + 1;
+        END LOOP;
+
+        signature = _CDB_DistTypeClassify(ajus);
+    END IF;
+
+    RETURN signature;
+END;
+$$ language plpgsql IMMUTABLE;
+
+-- Classify data into AJUSFL
+
+CREATE OR REPLACE FUNCTION _CDB_DistTypeClassify ( in_array INT[] ) RETURNS text as $$
+DECLARE
+    element_count INT4;
+    maxv numeric;
+    minv numeric;
+    uniques INT[];
+    type text;
+BEGIN
+    SELECT max(e), min(e) INTO maxv, minv FROM ( SELECT unnest(in_array) e ) x;
+
+    IF (maxv = 0 AND minv = 0) THEN
+        type = 'F';
+    ELSIF maxv < 1 THEN
+        type = 'L';
+    ELSIF minv > -1 THEN
+        type = 'J';
+    ELSE
+        -- Get distinct elements ordered by original position
+        EXECUTE 'WITH b AS (
+            SELECT a
+            FROM (SELECT unnest($1) a) x
+        ),
+        c AS (
+            SELECT a, row_number() OVER () r
+            FROM b
+        ),
+        d AS (
+            SELECT DISTINCT a
+            FROM c
+        ),
+        e AS (
+            SELECT a FROM d ORDER BY (
+                SELECT r FROM c WHERE d.a = c.a ORDER BY r ASC LIMIT 1
+            ) ASC)
+        SELECT array_agg(a) FROM e'
+        INTO uniques
+        USING in_array;
+
+        -- Decide if it's an A, U, or other
+        IF (uniques = ARRAY[1,-1] OR uniques = ARRAY[1,0,-1] OR uniques = ARRAY[1,-1,0] OR uniques = ARRAY[0,1,-1]) THEN
+            type = 'A';
+        ELSIF (uniques = ARRAY[-1,1] OR uniques = ARRAY[-1,0,1] OR uniques = ARRAY[-1,1,0] OR uniques = ARRAY[0,-1,1]) THEN
+            type = 'U';
+        ELSE
+            type = 'S';
+        END IF;
+    END IF;
+
+    RETURN type;
+END;
+$$ language plpgsql IMMUTABLE;
--- a/scripts-available/CDB_DistinctMeasure.sql
+++ b/scripts-available/CDB_DistinctMeasure.sql
@@ -0,0 +1,46 @@
+--
+-- CDB_DistinctMeasure 
+--     calculates the fraction of rows in the 10 most common distinct categories
+--     returns true if the number of rows in these 10 categories is >= 0.9 * total number of rows
+-- 
+-- 
+
+CREATE OR REPLACE FUNCTION CDB_DistinctMeasure ( in_array text[], threshold numeric DEFAULT null ) RETURNS numeric as $$
+DECLARE
+    element_count INT4;
+    maxval numeric;
+    passes numeric;
+BEGIN
+    SELECT count(e) INTO element_count FROM ( SELECT unnest(in_array) e ) x;
+
+    -- count number of occurrences per bin
+    -- calculate the normalized cumulative sum
+    -- return the max value: which corresponds nth entry 
+    -- for n <= 10 depending on # of distinct values
+    EXECUTE 'WITH a As (
+              SELECT
+                count(*) cnt
+              FROM
+                (SELECT * FROM unnest($2) e ) x
+              WHERE e is not null
+              GROUP BY e
+              ORDER BY cnt DESC
+            ),
+            b As (
+              SELECT
+                sum(cnt) OVER (ORDER BY cnt DESC) / $1 As cumsum
+              FROM a
+              LIMIT 10
+            )
+            SELECT max(cumsum) maxval FROM b'
+            INTO maxval
+            USING element_count, in_array;
+    IF threshold is null THEN
+        passes = maxval;
+    ELSE
+        passes = CASE WHEN (maxval >= threshold) THEN 1 ELSE 0 END;
+    END IF;
+
+    RETURN passes;
+END;
+$$ language plpgsql IMMUTABLE;
--- a/scripts-available/CDB_EqualIntervalBins.sql
+++ b/scripts-available/CDB_EqualIntervalBins.sql
@@ -0,0 +1,37 @@
+--
+-- Calculate the equal interval bins for a given column
+--
+-- @param in_array A numeric array of numbers to determine the best
+--                   to determine the bin boundary
+--
+-- @param breaks The number of bins you want to find.
+--  
+--
+-- Returns: upper edges of bins
+-- 
+--
+
+CREATE OR REPLACE FUNCTION CDB_EqualIntervalBins ( in_array NUMERIC[], breaks INT ) RETURNS NUMERIC[] as $$
+DECLARE 
+    diff numeric;
+    min_val numeric;
+    max_val numeric;
+    tmp_val numeric;
+    i INT := 1;
+    reply numeric[];
+BEGIN
+    SELECT min(e), max(e) INTO min_val, max_val FROM ( SELECT unnest(in_array) e ) x WHERE e IS NOT NULL;
+    diff = (max_val - min_val) / breaks::numeric;
+    LOOP
+        IF i < breaks THEN
+            tmp_val = min_val + i::numeric * diff;
+            reply = array_append(reply, tmp_val);
+            i := i+1;
+        ELSE
+            reply = array_append(reply, max_val);
+            EXIT;
+        END IF;
+    END LOOP;
+    RETURN reply;
+END;
+$$ language plpgsql IMMUTABLE;
--- a/scripts-available/CDB_ForeignTable.sql
+++ b/scripts-available/CDB_ForeignTable.sql
@@ -0,0 +1,199 @@
+---------------------------
+-- FDW MANAGEMENT FUNCTIONS
+--
+-- All the FDW settings are read from the `cdb_conf.fdws` entry json file.
+---------------------------
+
+CREATE OR REPLACE FUNCTION cartodb._CDB_Setup_FDW(fdw_name text, config json)
+RETURNS void
+AS $$
+DECLARE
+  row record;
+  option record;
+  org_role text;
+BEGIN
+  -- This function tries to be as idempotent as possible, by not creating anything more than once
+  -- (not even using IF NOT EXIST to avoid throwing warnings)
+  IF NOT EXISTS ( SELECT * FROM pg_extension WHERE extname = 'postgres_fdw') THEN
+    CREATE EXTENSION postgres_fdw;
+  END IF;
+  -- Create FDW first if it does not exist
+  IF NOT EXISTS ( SELECT * FROM pg_foreign_server WHERE srvname = fdw_name)
+    THEN
+    EXECUTE FORMAT('CREATE SERVER %I FOREIGN DATA WRAPPER postgres_fdw', fdw_name);
+  END IF;
+
+  -- Set FDW settings
+  FOR row IN SELECT p.key, p.value from lateral json_each_text(config->'server') p
+    LOOP
+      IF NOT EXISTS (WITH a AS (select split_part(unnest(srvoptions), '=', 1) as options from pg_foreign_server where srvname=fdw_name) SELECT * from a where options = row.key)
+        THEN
+        EXECUTE FORMAT('ALTER SERVER %I OPTIONS (ADD %I %L)', fdw_name, row.key, row.value);
+      ELSE
+        EXECUTE FORMAT('ALTER SERVER %I OPTIONS (SET %I %L)', fdw_name, row.key, row.value);
+      END IF;
+    END LOOP;
+
+    -- Create user mappings
+    FOR row IN SELECT p.key, p.value from lateral json_each(config->'users') p LOOP
+        -- Check if entry on pg_user_mappings exists
+
+        IF NOT EXISTS ( SELECT * FROM pg_user_mappings WHERE srvname = fdw_name AND usename = row.key ) THEN
+          EXECUTE FORMAT ('CREATE USER MAPPING FOR %I SERVER %I', row.key, fdw_name);
+        END IF;
+
+    -- Update user mapping settings
+    FOR option IN SELECT o.key, o.value from lateral json_each_text(row.value) o LOOP
+        IF NOT EXISTS (WITH a AS (select split_part(unnest(umoptions), '=', 1) as options from pg_user_mappings WHERE srvname = fdw_name AND usename = row.key) SELECT * from a where options = option.key) THEN
+          EXECUTE FORMAT('ALTER USER MAPPING FOR %I SERVER %I OPTIONS (ADD %I %L)', row.key, fdw_name, option.key, option.value);
+        ELSE
+          EXECUTE FORMAT('ALTER USER MAPPING FOR %I SERVER %I OPTIONS (SET %I %L)', row.key, fdw_name, option.key, option.value);
+        END IF;
+      END LOOP;
+    END LOOP;
+
+    -- Create schema if it does not exist.
+    IF NOT EXISTS ( SELECT * from pg_namespace WHERE nspname=fdw_name) THEN
+      EXECUTE FORMAT ('CREATE SCHEMA %I', fdw_name);
+    END IF;
+
+    -- Give the organization role usage permisions over the schema
+    SELECT cartodb.CDB_Organization_Member_Group_Role_Member_Name() INTO org_role;
+    EXECUTE FORMAT ('GRANT USAGE ON SCHEMA %I TO %I', fdw_name, org_role);
+
+    -- Bring here the remote cdb_tablemetadata
+    IF NOT EXISTS ( SELECT * FROM PG_CLASS WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname=fdw_name) and relname='cdb_tablemetadata') THEN
+      EXECUTE FORMAT ('CREATE FOREIGN TABLE %I.cdb_tablemetadata (tabname text, updated_at timestamp with time zone) SERVER %I OPTIONS (table_name ''cdb_tablemetadata_text'', schema_name ''public'', updatable ''false'')', fdw_name, fdw_name);
+    END IF;
+    EXECUTE FORMAT ('GRANT SELECT ON %I.cdb_tablemetadata TO %I', fdw_name, org_role);
+
+END
+$$
+LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE FUNCTION cartodb._CDB_Setup_FDWS()
+RETURNS VOID AS 
+$$
+DECLARE
+row record;
+BEGIN
+  FOR row IN SELECT p.key, p.value from lateral json_each(cartodb.CDB_Conf_GetConf('fdws')) p LOOP
+      EXECUTE 'SELECT cartodb._CDB_Setup_FDW($1, $2)' USING row.key, row.value;
+    END LOOP;
+  END
+$$
+LANGUAGE PLPGSQL;
+
+
+CREATE OR REPLACE FUNCTION cartodb._CDB_Setup_FDW(fdw_name text)
+  RETURNS void AS
+$BODY$
+DECLARE
+config json;
+BEGIN
+  SELECT p.value FROM LATERAL json_each(cartodb.CDB_Conf_GetConf('fdws')) p WHERE p.key = fdw_name INTO config;
+  EXECUTE 'SELECT cartodb._CDB_Setup_FDW($1, $2)' USING fdw_name, config;
+END
+$BODY$
+LANGUAGE plpgsql VOLATILE;
+
+CREATE OR REPLACE FUNCTION cartodb.CDB_Add_Remote_Table(source text, table_name text)
+  RETURNS void AS
+$$
+BEGIN
+  PERFORM cartodb._CDB_Setup_FDW(source);
+  EXECUTE FORMAT ('IMPORT FOREIGN SCHEMA %I LIMIT TO (%I) FROM SERVER %I INTO %I;', source, table_name, source, source);
+  --- Grant SELECT to publicuser
+  EXECUTE FORMAT ('GRANT SELECT ON %I.%I TO publicuser;', source, table_name);
+END
+$$
+LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION cartodb.CDB_Get_Foreign_Updated_At(foreign_table regclass)
+  RETURNS timestamp with time zone AS
+$$
+DECLARE
+  remote_table_name text;
+  fdw_schema_name text;
+  time timestamp with time zone;
+BEGIN
+  -- This will turn a local foreign table (referenced as regclass) to its fully qualified text remote table reference.
+  WITH a AS (SELECT ftoptions FROM pg_foreign_table WHERE ftrelid=foreign_table LIMIT 1),
+    b as (SELECT (pg_options_to_table(ftoptions)).* FROM a)
+    SELECT FORMAT('%I.%I', (SELECT option_value FROM b WHERE option_name='schema_name'), (SELECT option_value FROM b WHERE option_name='table_name'))
+  INTO remote_table_name;
+
+  -- We assume that the remote cdb_tablemetadata is called cdb_tablemetadata and is on the same schema as the queried table.
+  SELECT nspname FROM pg_class c, pg_namespace n WHERE c.oid=foreign_table AND c.relnamespace = n.oid INTO fdw_schema_name;
+  EXECUTE FORMAT('SELECT updated_at FROM %I.cdb_tablemetadata WHERE tabname=%L ORDER BY updated_at DESC LIMIT 1', fdw_schema_name, remote_table_name) INTO time;
+  RETURN time;
+END
+$$
+LANGUAGE plpgsql;
+
+
+CREATE OR REPLACE FUNCTION cartodb._cdb_dbname_of_foreign_table(reloid oid)
+RETURNS TEXT AS $$
+    SELECT option_value FROM pg_options_to_table((
+
+        SELECT fs.srvoptions
+        FROM pg_foreign_table ft
+        LEFT JOIN pg_foreign_server fs ON ft.ftserver = fs.oid
+        WHERE ft.ftrelid = reloid
+
+    )) WHERE option_name='dbname';
+$$ LANGUAGE SQL;
+
+
+-- Return a set of (dbname, schema_name, table_name, updated_at)
+-- It is aware of foreign tables
+-- It assumes the local (schema_name, table_name) map to the remote ones with the same name
+-- Note: dbname is never quoted whereas schema and table names are when needed.
+CREATE OR REPLACE FUNCTION cartodb.CDB_QueryTables_Updated_At(query text)
+RETURNS TABLE(dbname text, schema_name text, table_name text, updated_at timestamptz)
+AS $$
+    WITH query_tables AS (
+      SELECT unnest(CDB_QueryTablesText(query)) schema_table_name
+    ), query_tables_oid AS (
+      SELECT schema_table_name, schema_table_name::regclass::oid AS reloid
+      FROM query_tables
+    ),
+    fqtn AS (
+      SELECT
+        (CASE WHEN c.relkind = 'f' THEN cartodb._cdb_dbname_of_foreign_table(query_tables_oid.reloid)
+              ELSE current_database()
+         END)::text AS dbname,
+         quote_ident(n.nspname::text) schema_name,
+         quote_ident(c.relname::text) table_name,
+         c.relkind,
+         query_tables_oid.reloid
+      FROM query_tables_oid, pg_catalog.pg_class c
+      LEFT JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+      WHERE c.oid = query_tables_oid.reloid
+    )
+    SELECT fqtn.dbname, fqtn.schema_name, fqtn.table_name,
+      (CASE WHEN relkind = 'f' THEN cartodb.CDB_Get_Foreign_Updated_At(reloid)
+            ELSE (SELECT md.updated_at FROM CDB_TableMetadata md WHERE md.tabname = reloid)
+      END) AS updated_at
+    FROM fqtn;
+$$ LANGUAGE SQL;
+
+
+-- Return the last updated time of a set of tables
+-- It is aware of foreign tables
+-- It assumes the local (schema_name, table_name) map to the remote ones with the same name
+CREATE OR REPLACE FUNCTION cartodb.CDB_Last_Updated_Time(tables text[])
+RETURNS timestamptz AS $$
+    WITH t AS (
+        SELECT unnest(tables) AS schema_table_name
+    ), t_oid AS (
+        SELECT (t.schema_table_name)::regclass::oid as reloid FROM t
+    ), t_updated_at AS (
+        SELECT
+            (CASE WHEN relkind = 'f' THEN cartodb.CDB_Get_Foreign_Updated_At(reloid)
+                  ELSE (SELECT md.updated_at FROM CDB_TableMetadata md WHERE md.tabname = reloid)
+             END) AS updated_at
+        FROM t_oid
+        LEFT JOIN pg_catalog.pg_class c ON c.oid = reloid
+    ) SELECT max(updated_at) FROM t_updated_at;
+$$ LANGUAGE SQL;
--- a/scripts-available/CDB_GreatCircle.sql
+++ b/scripts-available/CDB_GreatCircle.sql
@@ -0,0 +1,26 @@
+-- Great circle point-to-point routes, based on:
+--   http://blog.cartodb.com/jets-and-datelines/
+--
+CREATE OR REPLACE FUNCTION CDB_GreatCircle(start_point geometry, end_point geometry, max_segment_length NUMERIC DEFAULT 100000)
+RETURNS geometry AS $$
+DECLARE
+  line geometry;
+BEGIN
+  line = ST_Segmentize(
+    ST_Makeline(
+      start_point,
+      end_point
+    )::geography,
+    max_segment_length
+  )::geometry;
+
+  IF ST_XMax(line) - ST_XMin(line) > 180 THEN
+    line = ST_Difference(
+      ST_Shift_Longitude(line),
+			ST_Buffer(ST_GeomFromText('LINESTRING(180 90, 180 -90)', 4326), 0.00001)
+		);
+  END IF;
+RETURN line;
+END;
+$$
+LANGUAGE 'plpgsql';
--- a/scripts-available/CDB_Groups.sql
+++ b/scripts-available/CDB_Groups.sql
@@ -0,0 +1,252 @@
+----------------------------------
+-- GROUP MANAGEMENT FUNCTIONS
+--
+-- Meant to be used by org admin. See CDB_Organization_AddAdmin.
+----------------------------------
+
+-- Creates a new group
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Group_CreateGroup(group_name text)
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+BEGIN
+    group_role := cartodb._CDB_Group_GroupRole(group_name);
+    EXECUTE format('CREATE ROLE %I NOLOGIN;', group_role);
+    PERFORM cartodb._CDB_Group_CreateGroup_API(group_name, group_role);
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+-- Drops group and everything that role owns
+-- TODO: LIMITATION: in order to drop a role all its owned objects must be dropped before.
+-- Right now this is done with DROP OWNED, which can only be done by a superadmin.
+-- Not even the role creator can drop the role and the objects it owns.
+-- All group owned objects by the group are permissions.
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Group_DropGroup(group_name text)
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+BEGIN
+    group_role := cartodb._CDB_Group_GroupRole(group_name);
+    EXECUTE format('DROP OWNED BY %I', group_role);
+    EXECUTE format('DROP ROLE IF EXISTS %I', group_role);
+    PERFORM cartodb._CDB_Group_DropGroup_API(group_name);
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+-- Renames a group
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Group_RenameGroup(old_group_name text, new_group_name text)
+    RETURNS VOID AS $$
+DECLARE
+    old_group_role TEXT;
+    new_group_role TEXT;
+BEGIN
+    old_group_role = cartodb._CDB_Group_GroupRole(old_group_name);
+    new_group_role = cartodb._CDB_Group_GroupRole(new_group_name);
+    EXECUTE format('ALTER ROLE %I RENAME TO %I', old_group_role, new_group_role);
+    PERFORM cartodb._CDB_Group_RenameGroup_API(old_group_name, new_group_name, new_group_role);
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+-- Adds users to a group
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Group_AddUsers(group_name text, usernames text[])
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+    user_role TEXT;
+    username TEXT;
+BEGIN
+    group_role := cartodb._CDB_Group_GroupRole(group_name);
+    foreach username in array usernames
+    loop
+      user_role := cartodb._CDB_User_RoleFromUsername(username);
+      IF(group_role IS NULL OR user_role IS NULL)
+      THEN
+        RAISE EXCEPTION 'Group role (%) and user role (%) must be already existing', group_role, user_role;
+      END IF;
+      EXECUTE format('GRANT %I TO %I', group_role, user_role);
+    end loop;
+    PERFORM cartodb._CDB_Group_AddUsers_API(group_name, usernames);
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+-- Removes users from a group
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Group_RemoveUsers(group_name text, usernames text[])
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+    user_role TEXT;
+    username TEXT;
+BEGIN
+    group_role := cartodb._CDB_Group_GroupRole(group_name);
+    foreach username in array usernames
+    loop
+      user_role := cartodb._CDB_User_RoleFromUsername(username);
+      EXECUTE format('REVOKE %I FROM %I', group_role, user_role);
+    end loop;
+    PERFORM cartodb._CDB_Group_RemoveUsers_API(group_name, usernames);
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+----------------------------------
+-- TABLE MANAGEMENT FUNCTIONS
+--
+-- Meant to be used by table owners.
+----------------------------------
+
+-- Grants table read permission to a group
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Group_Table_GrantRead(group_name text, username text, table_name text)
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+BEGIN
+    PERFORM cartodb._CDB_Group_Table_GrantRead(group_name, username, table_name, true);
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_Table_GrantRead(group_name text, username text, table_name text, sync boolean)
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+BEGIN
+    group_role := cartodb._CDB_Group_GroupRole(group_name);
+    EXECUTE format('GRANT USAGE ON SCHEMA %I TO %I', username, group_role);
+    EXECUTE format('GRANT SELECT ON TABLE %I.%I TO %I', username, table_name, group_role );
+    IF(sync) THEN
+      PERFORM cartodb._CDB_Group_Table_GrantPermission_API(group_name, username, table_name, 'r');
+    END IF;
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+-- Grants table write permission to a group
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Group_Table_GrantReadWrite(group_name text, username text, table_name text)
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+BEGIN
+    PERFORM cartodb._CDB_Group_Table_GrantReadWrite(group_name, username, table_name, true);
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_Table_GrantReadWrite(group_name text, username text, table_name text, sync boolean)
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+BEGIN
+    group_role := cartodb._CDB_Group_GroupRole(group_name);
+    EXECUTE format('GRANT USAGE ON SCHEMA %I TO %I', username, group_role);
+    EXECUTE format('GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE %I.%I TO %I', username, table_name, group_role);
+    PERFORM cartodb._CDB_Group_TableSequences_Permission(group_name, username, table_name, true);
+    IF(sync) THEN
+      PERFORM cartodb._CDB_Group_Table_GrantPermission_API(group_name, username, table_name, 'w');
+    END IF;
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+-- Granting and revoking permissions on sequences
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_TableSequences_Permission(group_name text, username text, table_name text, do_grant bool)
+    RETURNS VOID AS $$
+DECLARE
+    column_name TEXT;
+    sequence_name TEXT;
+    group_role TEXT;
+BEGIN
+    group_role := cartodb._CDB_Group_GroupRole(group_name);
+    FOR column_name IN EXECUTE 'SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_CATALOG = current_database() AND TABLE_SCHEMA = $1 AND TABLE_NAME = $2 AND COLUMN_DEFAULT LIKE ''nextval%''' USING username, table_name
+    LOOP
+        EXECUTE format('SELECT PG_GET_SERIAL_SEQUENCE(''%I.%I'', ''%I'')', username, table_name, column_name) INTO sequence_name;
+        IF sequence_name IS NOT NULL THEN
+          IF do_grant THEN
+            -- Here %s is needed since sequence_name has quotes
+            EXECUTE format('GRANT USAGE, SELECT, UPDATE ON SEQUENCE %s TO %I', sequence_name, group_role);
+          ELSE
+            EXECUTE format('REVOKE ALL ON SEQUENCE %s FROM %I', sequence_name, group_role);
+          END IF;
+        END IF;
+    END LOOP;
+    RETURN;
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+-- Revokes all permissions on a table from a group
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Group_Table_RevokeAll(group_name text, username text, table_name text)
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+BEGIN
+    PERFORM cartodb._CDB_Group_Table_RevokeAll(group_name, username, table_name, true);
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_Table_RevokeAll(group_name text, username text, table_name text, sync boolean)
+    RETURNS VOID AS $$
+DECLARE
+    group_role TEXT;
+BEGIN
+    group_role := cartodb._CDB_Group_GroupRole(group_name);
+    EXECUTE format('REVOKE ALL ON TABLE %I.%I FROM %I', username, table_name, group_role);
+    PERFORM cartodb._CDB_Group_TableSequences_Permission(group_name, username, table_name, false);
+    IF(sync) THEN
+      PERFORM cartodb._CDB_Group_Table_RevokeAllPermission_API(group_name, username, table_name);
+    END IF;
+END
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+-----------------------
+-- Helper functions
+-----------------------
+-- Given a group name returns a role. group_name must be a valid PostgreSQL idenfifier. See http://www.postgresql.org/docs/9.2/static/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_GroupRole(group_name text)
+    RETURNS TEXT AS $$
+DECLARE
+    group_role TEXT;
+    prefix TEXT;
+    max_length constant INTEGER := 63;
+BEGIN
+    prefix = format('%s_g_', cartodb._CDB_Group_ShortDatabaseName());
+    group_role := format('%s%s', prefix, group_name);
+    IF LENGTH(group_role) > max_length
+    THEN
+        RAISE EXCEPTION 'Group name must be shorter. It can''t have more than % characters, but it is longer (%): %', max_length - LENGTH(prefix), length(group_name), group_name;
+    END IF;
+    RETURN group_role;
+END
+$$ LANGUAGE PLPGSQL;
+
+-- Returns the first owner of the schema matching username. Organization user schemas must have one only owner.
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_User_RoleFromUsername(username text)
+    RETURNS TEXT AS $$
+DECLARE
+    user_role TEXT;
+BEGIN
+    -- This was preferred, but non-superadmins won't get results
+    -- SELECT SCHEMA_OWNER FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = $1 LIMIT 1'
+    SELECT pg_get_userbyid(nspowner) FROM pg_namespace WHERE nspname = username INTO user_role;
+    RETURN user_role;
+END
+$$ LANGUAGE PLPGSQL;
+
+-- Database names are too long, we need a shorter version for composing role names
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_ShortDatabaseName()
+    RETURNS TEXT AS $$
+DECLARE
+    short_database_name TEXT;
+BEGIN
+    SELECT md5(current_database()) INTO short_database_name;
+    RETURN short_database_name;
+END
+$$ LANGUAGE PLPGSQL;
--- a/scripts-available/CDB_Groups_API.sql
+++ b/scripts-available/CDB_Groups_API.sql
@@ -0,0 +1,195 @@
+----------------------------------
+-- GROUP METADATA API FUNCTIONS
+--
+-- Meant to be used by CDB_Group_* functions to sync data with the editor.
+-- Requires configuration parameter. Example: SELECT cartodb.CDB_Conf_SetConf('groups_api', '{ "host": "127.0.0.1", "port": 3000, "timeout": 10, "username": "extension", "password": "elephant" }');
+----------------------------------
+
+-- TODO: delete this development cleanup before final merge
+DROP FUNCTION IF EXISTS cartodb.CDB_Group_AddMember(group_name text, username text);
+DROP FUNCTION IF EXISTS cartodb.CDB_Group_RemoveMember(group_name text, username text);
+DROP FUNCTION IF EXISTS cartodb._CDB_Group_AddMember_API(group_name text, username text);
+DROP FUNCTION IF EXISTS cartodb._CDB_Group_RemoveMember_API(group_name text, username text);
+
+-- Sends the create group request
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_CreateGroup_API(group_name text, group_role text)
+    RETURNS VOID AS
+$$
+    import string
+
+    url = '/api/v1/databases/{0}/groups'
+    body = '{ "name": "%s", "database_role": "%s" }' % (group_name, group_role)
+    query = "select cartodb._CDB_Group_API_Request('POST', '%s', '%s', '{200, 409}') as response_status" % (url, body)
+    plpy.execute(query)
+$$ LANGUAGE 'plpythonu' VOLATILE SECURITY DEFINER;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_DropGroup_API(group_name text)
+    RETURNS VOID AS
+$$
+    import string
+    import urllib
+
+    url = '/api/v1/databases/{0}/groups/%s' % (urllib.pathname2url(group_name))
+
+    query = "select cartodb._CDB_Group_API_Request('DELETE', '%s', '', '{204, 404}') as response_status" % url
+    plpy.execute(query)
+$$ LANGUAGE 'plpythonu' VOLATILE SECURITY DEFINER;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_RenameGroup_API(old_group_name text, new_group_name text, new_group_role text)
+    RETURNS VOID AS
+$$
+    import string
+    import urllib
+
+    url = '/api/v1/databases/{0}/groups/%s' % (urllib.pathname2url(old_group_name))
+    body = '{ "name": "%s", "database_role": "%s" }' % (new_group_name, new_group_role)
+    query = "select cartodb._CDB_Group_API_Request('PUT', '%s', '%s', '{200, 409}') as response_status" % (url, body)
+    plpy.execute(query)
+$$ LANGUAGE 'plpythonu' VOLATILE SECURITY DEFINER;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_AddUsers_API(group_name text, usernames text[])
+    RETURNS VOID AS
+$$
+    import string
+    import urllib
+
+    url = '/api/v1/databases/{0}/groups/%s/users' % (urllib.pathname2url(group_name))
+    body = "{ \"users\": [\"%s\"] }" % "\",\"".join(usernames)
+    query = "select cartodb._CDB_Group_API_Request('POST', '%s', '%s', '{200, 409}') as response_status" % (url, body)
+    plpy.execute(query)
+$$ LANGUAGE 'plpythonu' VOLATILE SECURITY DEFINER;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_RemoveUsers_API(group_name text, usernames text[])
+    RETURNS VOID AS
+$$
+    import string
+    import urllib
+
+    url = '/api/v1/databases/{0}/groups/%s/users' % (urllib.pathname2url(group_name))
+    body = "{ \"users\": [\"%s\"] }" % "\",\"".join(usernames)
+    query = "select cartodb._CDB_Group_API_Request('DELETE', '%s', '%s', '{200, 404}') as response_status" % (url, body)
+    plpy.execute(query)
+$$ LANGUAGE 'plpythonu' VOLATILE SECURITY DEFINER;
+
+DO LANGUAGE 'plpgsql' $$
+BEGIN
+    -- Needed for dropping type
+    DROP FUNCTION IF EXISTS cartodb._CDB_Group_API_Conf();
+    DROP TYPE IF EXISTS _CDB_Group_API_Params;
+END
+$$;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_Table_GrantPermission_API(group_name text, username text, table_name text, access text)
+    RETURNS VOID AS
+$$
+    import string
+    import urllib
+
+    url = '/api/v1/databases/{0}/groups/%s/permission/%s/tables/%s' % (urllib.pathname2url(group_name), username, table_name)
+    body = '{ "access": "%s" }' % access
+    query = "select cartodb._CDB_Group_API_Request('PUT', '%s', '%s', '{200, 409}') as response_status" % (url, body)
+    plpy.execute(query)
+$$ LANGUAGE 'plpythonu' VOLATILE SECURITY DEFINER;
+
+DO LANGUAGE 'plpgsql' $$
+BEGIN
+    -- Needed for dropping type
+    DROP FUNCTION IF EXISTS cartodb._CDB_Group_API_Conf();
+    DROP TYPE IF EXISTS _CDB_Group_API_Params;
+END
+$$;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_Table_RevokeAllPermission_API(group_name text, username text, table_name text)
+    RETURNS VOID AS
+$$
+    import string
+    import urllib
+
+    url = '/api/v1/databases/{0}/groups/%s/permission/%s/tables/%s' % (urllib.pathname2url(group_name), username, table_name)
+    query = "select cartodb._CDB_Group_API_Request('DELETE', '%s', '', '{200, 404}') as response_status" % url
+    plpy.execute(query)
+$$ LANGUAGE 'plpythonu' VOLATILE SECURITY DEFINER;
+
+DO LANGUAGE 'plpgsql' $$
+BEGIN
+    -- Needed for dropping type
+    DROP FUNCTION IF EXISTS cartodb._CDB_Group_API_Conf();
+    DROP TYPE IF EXISTS _CDB_Group_API_Params;
+END
+$$;
+
+CREATE TYPE _CDB_Group_API_Params AS (
+    host text,
+    port int,
+    timeout int,
+    auth text
+);
+
+-- This must be explicitally extracted because "composite types are currently not supported".
+-- See http://www.postgresql.org/docs/9.3/static/plpython-database.html.
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_API_Conf()
+    RETURNS _CDB_Group_API_Params AS
+$$
+    conf = plpy.execute("SELECT cartodb.CDB_Conf_GetConf('groups_api') conf")[0]['conf']
+    if conf is None:
+      return None
+    else:
+      import json
+      params = json.loads(conf)
+      auth = 'Basic %s' % plpy.execute("SELECT cartodb._CDB_Group_API_Auth('%s', '%s') as auth" % (params['username'], params['password']))[0]['auth']
+      return { "host": params['host'], "port": params['port'], 'timeout': params['timeout'], 'auth': auth }
+$$ LANGUAGE 'plpythonu' VOLATILE;
+
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_API_Auth(username text, password text)
+    RETURNS TEXT AS
+$$
+    import base64
+    return base64.encodestring('%s:%s' % (username, password)).replace('\n', '')
+$$ LANGUAGE 'plpythonu' VOLATILE;
+
+-- url must contain a '%s' placeholder that will be replaced by current_database, for security reasons.
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Group_API_Request(method text, url text, body text, valid_return_codes int[])
+    RETURNS int AS
+$$
+    import httplib
+
+    params = plpy.execute("select c.host, c.port, c.timeout, c.auth from cartodb._CDB_Group_API_Conf() c;")[0]
+    if params['host'] is None:
+      return None
+
+    headers = { 'Authorization': params['auth'], 'Content-Type': 'application/json', 'X-Forwarded-Proto': 'https' }
+
+    retry = 3
+
+    last_err = None
+    while retry > 0:
+      try:
+        client = SD['groups_api_client'] = httplib.HTTPConnection(params['host'], params['port'], False, params['timeout'])
+        database_name = plpy.execute("select current_database();")[0]['current_database']
+        client.request(method, url.format(database_name), body, headers)
+        response = client.getresponse()
+        assert response.status in valid_return_codes
+        return response.status
+      except Exception as err:
+        retry -= 1
+        last_err = err
+        plpy.warning('Retrying after: ' + str(err))
+        client = SD['groups_api_client'] = None
+
+    if last_err is not None:
+      plpy.error('Fatal Group API error: ' + str(last_err))
+      raise last_err
+
+    return None
+$$ LANGUAGE 'plpythonu' VOLATILE;
+revoke all on function cartodb._CDB_Group_API_Request(text, text, text, int[]) from public;
--- a/scripts-available/CDB_Helper.sql
+++ b/scripts-available/CDB_Helper.sql
@@ -0,0 +1,156 @@
+-- UTF8 safe and length aware. Find a unique identifier with a given prefix
+-- and/or suffix and withing a schema. If a schema is not specified, the identifier
+-- is guaranteed to be unique for all schemas.
+CREATE OR REPLACE FUNCTION cartodb._CDB_Unique_Identifier(prefix TEXT, relname TEXT, suffix TEXT, schema TEXT DEFAULT NULL)
+RETURNS TEXT
+AS $$
+DECLARE
+  maxlen CONSTANT INTEGER := 63;
+
+  rec RECORD;
+  usedspace INTEGER;
+  ident TEXT;
+  origident TEXT;
+  candrelname TEXT;
+
+  i INTEGER;
+BEGIN
+  -- Accounts for the _XX incremental suffix in case the identifier is taken
+  usedspace := 3;
+  usedspace := usedspace + coalesce(octet_length(prefix), 0);
+  usedspace := usedspace + coalesce(octet_length(suffix), 0);
+
+  candrelname := _CDB_Octet_Truncate(relname, maxlen - usedspace);
+
+  IF candrelname = '' THEN
+    PERFORM _CDB_Error('prefixes are to long to generate a valid identifier', '_CDB_Unique_Identifier');
+  END IF;
+
+  ident := coalesce(prefix, '') || candrelname || coalesce(suffix, '');
+
+  i := 0;
+  origident := ident;
+
+  WHILE i < 100 LOOP
+    IF schema IS NOT NULL THEN
+      SELECT c.relname, n.nspname
+      INTO rec
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      WHERE c.relname = ident
+      AND n.nspname = schema;
+    ELSE
+      SELECT c.relname, n.nspname
+      INTO rec
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      WHERE c.relname = ident;
+    END IF;
+
+    IF NOT FOUND THEN
+      RETURN ident;
+    END IF;
+
+    ident := origident || '_' || i;
+    i := i + 1;
+  END LOOP;
+
+  PERFORM _CDB_Error('looping too far', '_CDB_Unique_Identifier');
+END;
+$$ LANGUAGE 'plpgsql';
+
+
+-- UTF8 safe and length aware. Find a unique identifier for a column with a given prefix
+-- and/or suffix based on colname and within a relation specified via reloid.
+CREATE OR REPLACE FUNCTION cartodb._CDB_Unique_Column_Identifier(prefix TEXT, colname TEXT, suffix TEXT, reloid REGCLASS)
+RETURNS TEXT
+AS $$
+DECLARE
+  maxlen CONSTANT INTEGER := 63;
+
+  rec RECORD;
+  candcolname TEXT;
+  usedspace INTEGER;
+  ident TEXT;
+  origident TEXT;
+
+  i INTEGER;
+BEGIN
+  -- Accounts for the _XX incremental suffix in case the identifier is taken
+  usedspace := 3;
+  usedspace := usedspace + coalesce(octet_length(prefix), 0);
+  usedspace := usedspace + coalesce(octet_length(suffix), 0);
+
+  candcolname := _CDB_Octet_Truncate(colname, maxlen - usedspace);
+
+  IF candcolname = '' THEN
+    PERFORM _CDB_Error('prefixes are to long to generate a valid identifier', '_CDB_Unique_Column_Identifier');
+  END IF;
+
+  ident := coalesce(prefix, '') || candcolname || coalesce(suffix, '');
+
+  i := 0;
+  origident := ident;
+
+  WHILE i < 100 LOOP
+    SELECT a.attname
+    INTO rec
+    FROM pg_class c
+    JOIN pg_attribute a ON a.attrelid = c.oid
+    WHERE NOT a.attisdropped
+    AND a.attnum > 0
+    AND c.oid = reloid
+    AND a.attname = ident;
+
+    IF NOT FOUND THEN
+      RETURN ident;
+    END IF;
+
+    ident := origident || '_' || i;
+    i := i + 1;
+  END LOOP;
+
+  PERFORM _CDB_Error('looping too far', '_CDB_Unique_Column_Identifier');
+END;
+$$ LANGUAGE 'plpgsql';
+
+
+-- Truncates a given string to a max_octets octets taking care
+-- not to leave characters in half. UTF8 safe.
+CREATE OR REPLACE FUNCTION cartodb._CDB_Octet_Truncate(string TEXT, max_octets INTEGER)
+RETURNS TEXT
+AS $$
+DECLARE
+  extcharlen CONSTANT INTEGER := octet_length('ñ');
+
+  expected INTEGER;
+  examined INTEGER;
+  strlen INTEGER;
+
+  i INTEGER;
+BEGIN
+
+  IF max_octets <= 0 THEN
+    RETURN '';
+  ELSIF max_octets >= octet_length(string) THEN
+    RETURN string;
+  END IF;
+
+  strlen := char_length(string);
+
+  expected := char_length(string);
+  examined := octet_length(string);
+
+  IF expected = examined THEN
+    RETURN left(string, max_octets);
+  END IF;
+
+  i := max_octets / extcharlen;
+
+  WHILE octet_length(left(string, i)) <= max_octets LOOP
+    i := i + 1;
+  END LOOP;
+
+  RETURN left(string, (i - 1));
+END;
+$$ LANGUAGE 'plpgsql';
--- a/scripts-available/CDB_LatLng.sql
+++ b/scripts-available/CDB_LatLng.sql
@@ -8,16 +8,12 @@
 --

 CREATE OR REPLACE FUNCTION CDB_LatLng (lat NUMERIC, lng NUMERIC) RETURNS geometry as $$ 
-BEGIN 
    -- this function is silly
-    RETURN ST_SetSRID(ST_MakePoint(lng,lat),4326); 
-END; 
-$$ language plpgsql IMMUTABLE;
+    SELECT ST_SetSRID(ST_MakePoint(lng,lat),4326);
+$$ language SQL IMMUTABLE;

 CREATE OR REPLACE FUNCTION CDB_LatLng (lat FLOAT8, lng FLOAT8) RETURNS geometry as $$ 
-BEGIN 
    -- this function is silly
-    RETURN ST_SetSRID(ST_MakePoint(lng,lat),4326); 
-END; 
-$$ language plpgsql IMMUTABLE;
+    SELECT ST_SetSRID(ST_MakePoint(lng,lat),4326);
+$$ language SQL IMMUTABLE;

--- a/scripts-available/CDB_Math.sql
+++ b/scripts-available/CDB_Math.sql
@@ -0,0 +1,26 @@
+-- CartoDB Math SQL functions
+
+
+-- Mode
+-- https://wiki.postgresql.org/wiki/Aggregate_Mode
+
+CREATE OR REPLACE FUNCTION cartodb._CDB_Math_final_mode(anyarray)
+  RETURNS anyelement AS
+$BODY$
+    SELECT a
+    FROM unnest($1) a
+    GROUP BY 1 
+    ORDER BY COUNT(1) DESC, 1
+    LIMIT 1;
+$BODY$
+LANGUAGE 'sql' IMMUTABLE;
+
+DROP AGGREGATE IF EXISTS cartodb.CDB_Math_Mode(anyelement);
+
+CREATE AGGREGATE cartodb.CDB_Math_Mode(anyelement) (
+  SFUNC=array_append,
+  STYPE=anyarray,
+  FINALFUNC=_CDB_Math_final_mode,
+  INITCOND='{}'
+);
+
--- a/scripts-available/CDB_Organizations.sql
+++ b/scripts-available/CDB_Organizations.sql
@@ -1,14 +1,16 @@
 CREATE OR REPLACE
 FUNCTION cartodb.CDB_Organization_Member_Group_Role_Member_Name()
    RETURNS TEXT
-AS 'SELECT ''cdb_org_member''::text || ''_'' || md5(current_database());'
+AS $$
+    SELECT 'cdb_org_member'::text || '_' || md5(current_database());
+$$
 LANGUAGE SQL IMMUTABLE;

 DO LANGUAGE 'plpgsql' $$
 DECLARE
    cdb_org_member_role_name TEXT;
 BEGIN
-    cdb_org_member_role_name := cartodb.CDB_Organization_Member_Group_Role_Member_Name();
+  cdb_org_member_role_name := cartodb.CDB_Organization_Member_Group_Role_Member_Name();
  IF NOT EXISTS ( SELECT * FROM pg_roles WHERE rolname= cdb_org_member_role_name )
  THEN
    EXECUTE 'CREATE ROLE "' || cdb_org_member_role_name || '" NOLOGIN;';
@@ -25,6 +27,60 @@ BEGIN
 END
 $$ LANGUAGE PLPGSQL VOLATILE;

+-------------------------------------------------------------------------------
+-- Administrator
+-------------------------------------------------------------------------------
+CREATE OR REPLACE
+FUNCTION cartodb._CDB_Organization_Admin_Role_Name()
+    RETURNS TEXT
+AS $$
+    SELECT current_database() || '_a'::text;
+$$
+LANGUAGE SQL IMMUTABLE;
+
+-- Administrator role creation on extension install
+DO LANGUAGE 'plpgsql' $$
+DECLARE
+    cdb_org_admin_role_name TEXT;
+BEGIN
+    cdb_org_admin_role_name := cartodb._CDB_Organization_Admin_Role_Name();
+    IF NOT EXISTS ( SELECT * FROM pg_roles WHERE rolname= cdb_org_admin_role_name )
+    THEN
+        EXECUTE format('CREATE ROLE %I CREATEROLE NOLOGIN;', cdb_org_admin_role_name);
+    END IF;
+END
+$$;
+
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Organization_AddAdmin(username text)
+    RETURNS void
+AS $$
+DECLARE
+    cdb_user_role TEXT;
+    cdb_admin_role TEXT;
+BEGIN
+    cdb_admin_role := cartodb._CDB_Organization_Admin_Role_Name();
+    cdb_user_role := cartodb._CDB_User_RoleFromUsername(username);
+    EXECUTE format('GRANT %I TO %I WITH ADMIN OPTION', cdb_admin_role, cdb_user_role);
+    -- CREATEROLE is not inherited, and is needed for user creation
+    EXECUTE format('ALTER ROLE %I CREATEROLE', cdb_user_role);
+END
+$$ LANGUAGE PLPGSQL;
+
+CREATE OR REPLACE
+FUNCTION cartodb.CDB_Organization_RemoveAdmin(username text)
+    RETURNS void
+AS $$
+DECLARE
+    cdb_user_role TEXT;
+    cdb_admin_role TEXT;
+BEGIN
+    cdb_admin_role := cartodb._CDB_Organization_Admin_Role_Name();
+    cdb_user_role := cartodb._CDB_User_RoleFromUsername(username);
+    EXECUTE format('ALTER ROLE %I NOCREATEROLE', cdb_user_role);
+    EXECUTE format('REVOKE %I FROM %I', cdb_admin_role, cdb_user_role);
+END
+$$ LANGUAGE PLPGSQL;

 -------------------------------------------------------------------------------
 -- Sharing tables
@@ -35,7 +91,7 @@ FUNCTION cartodb.CDB_Organization_Add_Table_Read_Permission(from_schema text, ta
 AS $$
 BEGIN
    EXECUTE 'GRANT USAGE ON SCHEMA "' || from_schema || '" TO "' || to_role_name || '"';
-    EXECUTE 'GRANT SELECT ON "' || from_schema || '".' || table_name || ' TO "' || to_role_name || '"';
+    EXECUTE 'GRANT SELECT ON "' || from_schema || '"."' || table_name || '" TO "' || to_role_name || '"';
 END
 $$ LANGUAGE PLPGSQL VOLATILE;

@@ -54,7 +110,7 @@ FUNCTION cartodb.CDB_Organization_Add_Table_Read_Write_Permission(from_schema te
 AS $$
 BEGIN
    EXECUTE 'GRANT USAGE ON SCHEMA "' || from_schema || '" TO "' || to_role_name || '"';
-    EXECUTE 'GRANT SELECT, INSERT, UPDATE, DELETE ON "' || from_schema || '".' || table_name || ' TO "' || to_role_name || '"';
+    EXECUTE 'GRANT SELECT, INSERT, UPDATE, DELETE ON "' || from_schema || '"."' || table_name || '" TO "' || to_role_name || '"';
 END
 $$ LANGUAGE PLPGSQL VOLATILE;

@@ -73,7 +129,7 @@ FUNCTION cartodb.CDB_Organization_Remove_Access_Permission(from_schema text, tab
    RETURNS void
 AS $$
 BEGIN
-    EXECUTE 'REVOKE ALL PRIVILEGES ON TABLE "' || from_schema || '".' || table_name || ' FROM "' || to_role_name || '"';
+    EXECUTE 'REVOKE ALL PRIVILEGES ON TABLE "' || from_schema || '"."' || table_name || '" FROM "' || to_role_name || '"';
    -- EXECUTE 'REVOKE USAGE ON SCHEMA ' || from_schema || ' FROM "' || to_role_name || '"';
    -- We need to revoke usage on schema only if we are revoking privileges from the last table where to_role_name has
    -- any permission granted within the schema from_schema
--- a/scripts-available/CDB_Overviews.sql
+++ b/scripts-available/CDB_Overviews.sql
@@ -0,0 +1,926 @@
+-- Information about tables in a schema.
+-- If the schema name parameter is NULL, then tables from all schemas
+-- that may contain user tables are returned.
+-- For each table, the regclass, schema name and table name are returned.
+-- Scope: private.
+CREATE OR REPLACE FUNCTION _CDB_UserTablesInSchema(schema_name text DEFAULT NULL)
+RETURNS TABLE(table_regclass REGCLASS, schema_name TEXT, table_name TEXT)
+AS $$
+  SELECT
+    c.oid::regclass AS table_regclass,
+    n.nspname::text AS schema_name,
+    c.relname::text AS table_relname
+  FROM pg_class c
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  WHERE c.relkind = 'r'
+  AND c.relname NOT IN ('cdb_tablemetadata', 'spatial_ref_sys')
+  AND CASE WHEN schema_name IS NULL
+             THEN n.nspname NOT IN ('pg_catalog', 'information_schema', 'topology', 'cartodb')
+           ELSE n.nspname = schema_name
+           END;
+$$ LANGUAGE 'sql';
+
+-- Pattern that can be used to detect overview tables and Extract
+-- the intended zoom level from the table name.
+-- Scope: private.
+CREATE OR REPLACE FUNCTION _CDB_OverviewTableDiscriminator()
+RETURNS TEXT
+AS $$
+  BEGIN
+    RETURN '\A_vovw_(\d+)_';
+  END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+-- substring(tablename from _CDB_OverviewTableDiscriminator())
+
+
+-- Pattern matched by the overview tables of a given base table name.
+-- Scope: private.
+CREATE OR REPLACE FUNCTION _CDB_OverviewTablePattern(base_table TEXT)
+RETURNS TEXT
+AS $$
+  BEGIN
+    RETURN _CDB_OverviewTableDiscriminator() || base_table;
+  END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+-- tablename SIMILAR TO _CDB_OverviewTablePattern(base_table)
+
+-- Name of an overview table, given the base table name and the Z level
+-- Scope: private.
+CREATE OR REPLACE FUNCTION _CDB_OverviewTableName(base_table TEXT, z INTEGER)
+RETURNS TEXT
+AS $$
+  BEGIN
+    RETURN '_vovw_' || z::text || '_' || base_table;
+  END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+-- Condition to check if a tabla is an overview table of some base table
+-- Scope: private.
+CREATE OR REPLACE FUNCTION _CDB_IsOverviewTableOf(base_table TEXT, otable TEXT)
+RETURNS BOOLEAN
+AS $$
+  BEGIN
+    RETURN otable SIMILAR TO _CDB_OverviewTablePattern(base_table);
+  END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+-- Extract the Z level from an overview table name
+-- Scope: private.
+CREATE OR REPLACE FUNCTION _CDB_OverviewTableZ(otable TEXT)
+RETURNS INTEGER
+AS $$
+  BEGIN
+    RETURN substring(otable from _CDB_OverviewTableDiscriminator())::integer;
+  END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+-- Name of the base table corresponding to an overview table
+-- Scope: private.
+CREATE OR REPLACE FUNCTION _CDB_OverviewBaseTableName(overview_table TEXT)
+RETURNS TEXT
+AS $$
+  BEGIN
+    IF _CDB_OverviewTableZ(overview_table) IS NULL THEN
+      RETURN overview_table;
+    ELSE
+      RETURN regexp_replace(overview_table, _CDB_OverviewTableDiscriminator(), '');
+    END IF;
+  END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+CREATE OR REPLACE FUNCTION _CDB_OverviewBaseTable(overview_table REGCLASS)
+RETURNS REGCLASS
+AS $$
+  DECLARE
+    table_name TEXT;
+    schema_name TEXT;
+    base_name TEXT;
+    base_table REGCLASS;
+  BEGIN
+    SELECT * FROM _cdb_split_table_name(overview_table) INTO schema_name, table_name;
+    base_name := _CDB_OverviewBaseTableName(table_name);
+    IF base_name != table_name THEN
+      base_table := Format('%I.%I', schema_name, base_name)::regclass;
+    ELSE
+      base_table := overview_table;
+    END IF;
+    RETURN base_table;
+  END;
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+-- Schema and relation names of a table given its reloid
+-- Scope: private.
+-- Parameters
+--   reloid: oid of the table.
+-- Return (schema_name, table_name)
+-- note that returned names will be quoted if necessary
+CREATE OR REPLACE FUNCTION _cdb_split_table_name(reloid REGCLASS, OUT schema_name TEXT, OUT table_name TEXT)
+AS $$
+  BEGIN
+    SELECT n.nspname, c.relname
+    INTO STRICT schema_name, table_name
+    FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid
+    WHERE c.oid = reloid;
+  END
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+-- Schema and relation names of a table given its reloid
+-- Scope: private.
+-- Parameters
+--   reloid: oid of the table.
+-- Return (schema_name, table_name)
+-- note that returned names will be quoted if necessary
+CREATE OR REPLACE FUNCTION _cdb_schema_name(reloid REGCLASS)
+RETURNS TEXT
+AS $$
+  DECLARE
+    schema_name TEXT;
+  BEGIN
+    SELECT n.nspname
+    INTO STRICT schema_name
+    FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid
+    WHERE c.oid = reloid;
+    RETURN schema_name;
+  END
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+-- Remove a dataset's existing  overview tables.
+-- Scope: public
+-- Parameters:
+--   reloid: oid of the table.
+CREATE OR REPLACE FUNCTION CDB_DropOverviews(reloid REGCLASS)
+RETURNS void
+AS $$
+DECLARE
+    row record;
+    schema_name TEXT;
+    table_name TEXT;
+BEGIN
+    SELECT * FROM _cdb_split_table_name(reloid) INTO schema_name, table_name;
+    FOR row IN
+        SELECT * FROM CDB_Overviews(reloid)
+    LOOP
+        EXECUTE Format('DROP TABLE %s;', row.overview_table);
+        RAISE NOTICE 'Dropped overview for level %: %', row.z, row.overview_table;
+    END LOOP;
+END;
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+
+
+-- Return existing overviews (if any) for a given dataset table
+-- Scope: public
+-- Parameters
+--   reloid: oid of the input table.
+-- Return relation of overviews for the table with
+-- the base table oid,
+-- z level of the overview and overview table oid, ordered by z.
+CREATE OR REPLACE FUNCTION CDB_Overviews(reloid REGCLASS)
+RETURNS TABLE(base_table REGCLASS, z integer, overview_table REGCLASS)
+AS $$
+  DECLARE
+    schema_name TEXT;
+    base_table_name TEXT;
+  BEGIN
+    SELECT * FROM _cdb_split_table_name(reloid) INTO schema_name, base_table_name;
+    RETURN QUERY SELECT
+      reloid AS base_table,
+      _CDB_OverviewTableZ(table_name) AS z,
+      table_regclass AS overview_table
+      FROM _CDB_UserTablesInSchema(schema_name)
+      WHERE _CDB_IsOverviewTableOf((SELECT relname FROM pg_class WHERE oid=reloid), table_name)
+      ORDER BY z;
+  END
+$$ LANGUAGE PLPGSQL;
+
+-- Return existing overviews (if any) for multiple dataset tables.
+-- Scope: public
+-- Parameters
+--   tables: Array of input tables oids
+-- Return relation of overviews for the table with
+-- the base table oid,
+-- z level of the overview and overview table oid, ordered by z.
+-- Note: CDB_Overviews can be applied to the result of CDB_QueryTablesText
+-- to obtain the overviews applicable to a query.
+CREATE OR REPLACE FUNCTION CDB_Overviews(tables regclass[])
+RETURNS TABLE(base_table REGCLASS, z integer, overview_table REGCLASS)
+AS $$
+  SELECT
+    base_table::regclass AS base_table,
+    _CDB_OverviewTableZ(table_name) AS z,
+    table_regclass AS overview_table
+    FROM
+      _CDB_UserTablesInSchema(), unnest(tables) base_table
+    WHERE
+      schema_name = _cdb_schema_name(base_table)
+      AND _CDB_IsOverviewTableOf((SELECT relname FROM pg_class WHERE oid=base_table), table_name)
+    ORDER BY base_table, z;
+$$ LANGUAGE SQL;
+
+-- Calculate the estimated extent of a cartodbfy'ed table.
+-- Scope: private.
+-- Parameters
+--   reloid: oid of the input table.
+-- Return value A box2d extent in 3857.
+CREATE OR REPLACE FUNCTION _cdb_estimated_extent(reloid REGCLASS)
+RETURNS box2d
+AS $$
+  DECLARE
+    ext box2d;
+    ext_query text;
+    table_id record;
+  BEGIN
+
+    SELECT n.nspname AS schema_name, c.relname table_name INTO STRICT table_id
+      FROM pg_class c JOIN pg_namespace n on n.oid = c.relnamespace WHERE c.oid = reloid::oid;
+
+    ext_query = format(
+      'SELECT ST_EstimatedExtent(''%1$I'', ''%2$I'', ''%3$I'');',
+      table_id.schema_name, table_id.table_name, 'the_geom_webmercator'
+    );
+
+    BEGIN
+      EXECUTE ext_query INTO ext;
+    EXCEPTION
+        -- This is the typical ERROR: stats for "mytable" do not exist
+        WHEN internal_error THEN
+          -- Get stats and execute again
+          EXECUTE format('ANALYZE %1$s', reloid);
+
+          -- We check the geometry type in case the error is due to empty geometries
+          IF _CDB_GeometryTypes(reloid) IS NULL THEN
+            RETURN NULL;
+          END IF;
+
+          EXECUTE ext_query INTO ext;
+    END;
+
+    RETURN ext;
+  END;
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+-- Determine the max feature density of a given dataset.
+-- Scope: private.
+-- Parameters
+--   reloid: oid of the input table. It must be a cartodbfy'ed table.
+--   nz: number of zoom levels to consider from z0 upward.
+-- Return value: feature density (num_features / webmercator_squared_meters).
+CREATE OR REPLACE FUNCTION _CDB_Feature_Density(reloid REGCLASS, nz integer)
+RETURNS FLOAT8
+AS $$
+  DECLARE
+    fd FLOAT8;
+    min_features TEXT;
+    n integer = 4;
+    c FLOAT8;
+  BEGIN
+  -- TODO: for small total count or extents we could just:
+  -- EXECUTE 'SELECT Count(*)/ST_Area(ST_Extent(the_geom_webmercator)) FROM ' || reloid::text || ';' INTO fd;
+
+  -- min_features is a SQL subexpression which can depend on z and represents
+  -- the minimum number of features to recursively consider a tile.
+  -- We can either use a fixed minimum number of features per tile
+  -- or a minimum feature density by dividing the number of features by
+  -- the area of tiles at level Z: c*c*power(2, -2*z)
+  -- with c = CDB_XYZ_Resolution(-8) (earth circumference)
+  min_features = '500';
+  SELECT CDB_XYZ_Resolution(-8) INTO c;
+
+  -- We first compute a set of *seed* tiles, of the minimum Z level, z0, such that
+  -- they cover the extent of the table and we have at least n of them in each
+  -- linear dimension (i.e. at least n*n tiles cover the extent).
+  -- We compute the number of features in these tiles, and recursively in
+  -- subtiles up to level z0 + nz. Then we compute the maximum of the feature
+  -- density (per tile area in webmercator squared meters) for all the
+  -- considered tiles.
+  EXECUTE Format('
+    WITH RECURSIVE t(x, y, z, e) AS (
+      WITH ext AS (SELECT _cdb_estimated_extent(%6$s) as g),
+      base AS (
+        SELECT (-floor(log(2, (greatest(ST_XMax(ext.g)-ST_XMin(ext.g), ST_YMax(ext.g)-ST_YMin(ext.g))/(%4$s*%5$s))::numeric)))::integer z
+        FROM ext
+      ),
+      lim AS (
+        SELECT
+          FLOOR((ST_XMin(ext.g)+CDB_XYZ_Resolution(0)*128)/(CDB_XYZ_Resolution(base.z)*256))::integer x0,
+          FLOOR((ST_XMax(ext.g)+CDB_XYZ_Resolution(0)*128)/(CDB_XYZ_Resolution(base.z)*256))::integer x1,
+          FLOOR((CDB_XYZ_Resolution(0)*128-ST_YMin(ext.g))/(CDB_XYZ_Resolution(base.z)*256))::integer y1,
+          FLOOR((CDB_XYZ_Resolution(0)*128-ST_YMax(ext.g))/(CDB_XYZ_Resolution(base.z)*256))::integer y0
+        FROM ext, base
+      ),
+      seed AS (
+        SELECT xt, yt, base.z, (
+          SELECT count(*) FROM %1$s
+            WHERE the_geom_webmercator && CDB_XYZ_Extent(xt, yt, base.z)
+        ) e
+        FROM base, lim, generate_series(lim.x0, lim.x1) xt, generate_series(lim.y0, lim.y1) yt
+      )
+      SELECT * from seed
+      UNION ALL
+      SELECT x*2 + xx, y*2 + yy, t.z+1, (
+        SELECT count(*) FROM %1$s
+          WHERE the_geom_webmercator && CDB_XYZ_Extent(x*2 + xx, y*2 + yy, t.z+1)
+      )
+      FROM t, base, (VALUES (0, 0), (0, 1), (1, 1), (1, 0)) AS c(xx, yy)
+      WHERE t.e > %2$s AND t.z < (base.z + %3$s)
+    )
+    SELECT MAX(e/ST_Area(CDB_XYZ_Extent(x,y,z))) FROM t where e > 0;
+  ', reloid::text, min_features, nz, n, c, reloid::oid)
+  INTO fd;
+  RETURN fd;
+  END
+$$ LANGUAGE PLPGSQL STABLE;
+
+-- Experimental default strategy to assign a reference base Z level
+-- to a cartodbfied table. The resulting Z level represents the
+-- minimum scale level at which the table data can be rendered
+-- without overcrowded results or loss of detail.
+-- Parameters:
+--   reloid: oid of the input table. It must be a cartodbfy'ed table.
+-- Return value: Z level as an integer
+CREATE OR REPLACE FUNCTION _CDB_Feature_Density_Ref_Z_Strategy(reloid REGCLASS, tolerance_px FLOAT8 DEFAULT NULL)
+RETURNS INTEGER
+AS $$
+  DECLARE
+    lim FLOAT8;
+    nz integer := 4;
+    fd FLOAT8;
+    c FLOAT8;
+  BEGIN
+    IF (tolerance_px IS NULL) OR tolerance_px = 0 THEN
+      lim := 500;
+    ELSE
+      lim := floor(power(256/tolerance_px, 2))/2;
+    END IF;
+
+    -- Compute fd as an estimation of the (maximum) number
+    -- of features per unit of tile area (in webmercator squared meters)
+    SELECT _CDB_Feature_Density(reloid, nz) INTO fd;
+    -- lim maximum number of (desiderable) features per tile
+    -- we have c = 2*Pi*R = CDB_XYZ_Resolution(-8) (earth circumference)
+    -- ta(z): tile area = power(c*power(2,-z), 2) = c*c*power(2,-2*z)
+    -- => fd*ta(z) is the average number of features per tile at level z
+    -- find minimum z so that fd*ta(z) <= lim
+    -- compute a rough 'feature density' value
+    SELECT CDB_XYZ_Resolution(-8) INTO c;
+    RETURN ceil(log(2.0, (c*c*fd/lim)::numeric)/2);
+  END;
+$$ LANGUAGE PLPGSQL STABLE;
+
+-- Overview table name for a given Z level and base dataset or overview table
+-- Scope: private.
+-- Parameters:
+--   ref reference table (can be the base table of the dataset or an existing
+--   overview) from which the overview is being generated.
+--   ref_z Z level of the reference table
+--   overview_z Z level of the overview to be named, must be smaller than ref_z
+-- Return value: the name to be used for the overview. The name is always
+-- unqualified (does not include a schema name).
+CREATE OR REPLACE FUNCTION _CDB_Overview_Name(ref REGCLASS, ref_z INTEGER, overview_z INTEGER)
+RETURNS TEXT
+AS $$
+  DECLARE
+    schema_name TEXT;
+    base TEXT;
+    suffix TEXT;
+    is_overview BOOLEAN;
+  BEGIN
+    SELECT * FROM _cdb_split_table_name(ref) INTO schema_name, base;
+    SELECT _CDB_OverviewBaseTableName(base) INTO base;
+    RETURN _CDB_OverviewTableName(base, overview_z);
+  END
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+-- Sampling reduction method.
+-- Valid for any kind of geometry.
+-- Scope: private.
+--   reloid original table (can be the base table of the dataset or an existing
+--   overview) from which the overview is being generated.
+--   ref_z Z level assigned to the original table
+--   overview_z Z level of the overview to be generated, must be smaller than ref_z
+-- Return value: Name of the generated overview table
+CREATE OR REPLACE FUNCTION _CDB_Sampling_Reduce_Strategy(reloid REGCLASS, ref_z INTEGER, overview_z INTEGER, tolerance_px FLOAT8 DEFAULT NULL)
+RETURNS REGCLASS
+AS $$
+  DECLARE
+    overview_rel TEXT;
+    fraction FLOAT8;
+    base_name TEXT;
+    class_info RECORD;
+    num_samples INTEGER;
+    schema_name TEXT;
+    table_name TEXT;
+  BEGIN
+    overview_rel := _CDB_Overview_Name(reloid, ref_z, overview_z);
+    -- TODO: compute fraction from tolerance_px if not NULL
+    fraction := power(2, 2*(overview_z - ref_z));
+
+    SELECT * FROM _cdb_split_table_name(reloid) INTO schema_name, table_name;
+
+    EXECUTE Format('DROP TABLE IF EXISTS %I.%I CASCADE;', schema_name, overview_rel);
+
+    -- Estimate number of rows
+    SELECT reltuples, relpages FROM pg_class INTO STRICT class_info
+      WHERE oid = reloid::oid;
+
+    IF class_info.relpages < 2 OR fraction > 0.5 THEN
+      -- We'll avoid possible CDB_RandomTids problems
+      EXECUTE Format('
+        CREATE TABLE %I AS SELECT * FROM %s WHERE random() < %s;
+      ', overview_rel, reloid, fraction);
+    ELSE
+      num_samples := ceil(class_info.reltuples*fraction);
+      EXECUTE Format('
+        CREATE TABLE %4$I.%1$I AS SELECT * FROM %2$s
+          WHERE ctid = ANY (
+            ARRAY[
+              (SELECT CDB_RandomTids(''%2$s'', %3$s))
+            ]
+          );
+      ', overview_rel, reloid, num_samples, schema_name);
+    END IF;
+
+    RETURN Format('%I.%I', schema_name, overview_rel)::regclass;
+  END;
+$$ LANGUAGE PLPGSQL;
+
+-- Register new overview table (post-creation chores)
+-- Scope: private
+-- Parameters:
+--   dataset: oid of the input dataset table,  It must be a cartodbfy'ed table.
+--   overview_table: oid of the overview table to be registered.
+--   overview_z: intended Z level for the overview table
+-- This function is declared SECURITY DEFINER so it executes with the privileges
+-- of the function creator to have a chance to alter the privileges of the
+-- overview table to match those of the dataset. It will only perform any change
+-- if the overview table belgons to the same scheme as the dataset and it
+-- matches the scheme naming for overview tables.
+CREATE OR REPLACE FUNCTION _CDB_Register_Overview(dataset REGCLASS, overview_table REGCLASS, overview_z INTEGER)
+RETURNS VOID
+AS $$
+  DECLARE
+    sql TEXT;
+    table_owner TEXT;
+    dataset_scheme TEXT;
+    dataset_name TEXT;
+    overview_scheme TEXT;
+    overview_name TEXT;
+  BEGIN
+    -- This function will only register a table as an overview table if it matches
+    -- the overviews naming scheme for the dataset and z level and the table belongs
+    -- to the same scheme as the the dataset
+    SELECT * FROM _cdb_split_table_name(dataset) INTO dataset_scheme, dataset_name;
+    SELECT * FROM _cdb_split_table_name(overview_table) INTO overview_scheme, overview_name;
+    IF dataset_scheme = overview_scheme AND
+       overview_name = _CDB_OverviewTableName(dataset_name, overview_z) THEN
+
+      -- preserve the owner of the base table
+      SELECT u.usename
+        FROM pg_catalog.pg_class c
+          JOIN pg_catalog.pg_user u ON (c.relowner=u.usesysid)
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = dataset_name::text AND n.nspname = dataset_scheme
+        INTO table_owner;
+
+      EXECUTE Format('ALTER TABLE IF EXISTS %s OWNER TO %I;', overview_table::text, table_owner);
+
+      -- preserve the table privileges
+      UPDATE pg_class c_to
+        SET  relacl = c_from.relacl
+        FROM  pg_class c_from
+        WHERE c_from.oid  = dataset
+        AND   c_to.oid    = overview_table;
+
+      PERFORM _CDB_Add_Indexes(overview_table);
+
+      -- TODO: If metadata about existing overviews is to be stored
+      -- it should be done here (CDB_Overviews would consume such metadata)
+    END IF;
+  END
+$$ LANGUAGE PLPGSQL SECURITY DEFINER;
+
+-- Dataset attributes (column names other than the
+-- CartoDB primary key and geometry columns) which should be aggregated
+-- in aggregated overviews.
+-- Scope: private.
+-- Parameters
+--   reloid: oid of the input table. It must be a cartodbfy'ed table.
+-- Return value: set of attribute names
+CREATE OR REPLACE FUNCTION _CDB_Aggregable_Attributes(reloid REGCLASS)
+RETURNS SETOF information_schema.sql_identifier
+AS $$
+  SELECT c FROM CDB_ColumnNames(reloid) c, _CDB_Columns() cdb
+    WHERE c NOT IN (
+      cdb.pkey, cdb.geomcol, cdb.mercgeomcol
+    )
+$$ LANGUAGE SQL STABLE;
+
+-- List of dataset attributes to be aggregated in aggregated overview
+-- as a comma-separated SQL expression.
+-- Scope: private.
+-- Parameters
+--   reloid: oid of the input table. It must be a cartodbfy'ed table.
+-- Return value: SQL subexpression as text
+CREATE OR REPLACE FUNCTION _CDB_Aggregable_Attributes_Expression(reloid REGCLASS)
+RETURNS TEXT
+AS $$
+DECLARE
+  attr_list TEXT;
+BEGIN
+  SELECT string_agg(s.c, ',') FROM (
+    SELECT * FROM _CDB_Aggregable_Attributes(reloid) c
+  ) AS s INTO attr_list;
+
+  RETURN attr_list;
+END
+$$ LANGUAGE PLPGSQL STABLE;
+
+-- Check if a column of a table is of an unlimited-length text type
+CREATE OR REPLACE FUNCTION _cdb_unlimited_text_column(reloid REGCLASS, col_name TEXT)
+RETURNS BOOLEAN
+AS $$
+  SELECT EXISTS (
+    SELECT a.attname
+    FROM pg_class c
+         LEFT JOIN pg_attribute a ON a.attrelid = c.oid
+         LEFT JOIN pg_type t ON t.oid = a.atttypid
+    WHERE c.oid = reloid
+      AND a.attname = col_name
+      AND format_type(a.atttypid, NULL) IN ('text', 'character varying', 'character')
+      AND format_type(a.atttypid, NULL) = format_type(a.atttypid, a.atttypmod)
+  );
+$$ LANGUAGE SQL STABLE;
+
+CREATE OR REPLACE FUNCTION _cdb_categorical_column(reloid REGCLASS, col_name TEXT)
+RETURNS BOOLEAN
+AS $$
+DECLARE
+    schema_name TEXT;
+    table_name TEXT;
+    available BOOLEAN;
+    categorical BOOLEAN;
+BEGIN
+    SELECT * FROM _cdb_split_table_name(reloid) INTO schema_name, table_name;
+    SELECT n_distinct IS NOT NULL
+    FROM pg_stats
+    WHERE pg_stats.schemaname = schema_name
+      AND pg_stats.tablename = table_name
+      AND pg_stats.attname = col_name
+    INTO available;
+    IF available IS NULL OR NOT available THEN
+      EXECUTE Format('ANALYZE %s;', reloid);
+    END IF;
+    SELECT n_distinct > 0 AND n_distinct <= 20
+    FROM pg_stats
+    WHERE pg_stats.schemaname = schema_name
+      AND pg_stats.tablename = table_name
+      AND pg_stats.attname = col_name
+    INTO categorical;
+    RETURN categorical;
+END;
+$$ LANGUAGE PLPGSQL VOLATILE;
+
+CREATE OR REPLACE FUNCTION _cdb_mode_of_array(anyarray)
+  RETURNS anyelement AS
+$$
+    SELECT a
+    FROM unnest($1) a
+    GROUP BY 1
+    ORDER BY COUNT(1) DESC, 1
+    LIMIT 1;
+$$
+LANGUAGE SQL IMMUTABLE;
+
+-- Tell Postgres how to use our aggregate
+CREATE AGGREGATE _cdb_mode(anyelement) (
+  SFUNC=array_append,
+  STYPE=anyarray,
+  FINALFUNC=_cdb_mode_of_array,
+  INITCOND='{}'
+);
+
+-- SQL Aggregation expression for a datase attribute
+-- Scope: private.
+-- Parameters
+--   reloid: oid of the input table. It must be a cartodbfy'ed table.
+--   column_name: column to be aggregated
+--   table_alias: (optional) table qualifier for the column to be aggregated
+-- Return SQL subexpression as text with aggregated attribute aliased
+-- with its original name.
+CREATE OR REPLACE FUNCTION _CDB_Attribute_Aggregation_Expression(reloid REGCLASS, column_name TEXT, table_alias TEXT DEFAULT '')
+RETURNS TEXT
+AS $$
+DECLARE
+  column_type TEXT;
+  qualified_column TEXT;
+  has_counter_column BOOLEAN;
+  feature_count TEXT;
+  total_feature_count TEXT;
+  base_table REGCLASS;
+BEGIN
+  IF table_alias <> '' THEN
+    qualified_column := Format('%I.%I', table_alias, column_name);
+  ELSE
+    qualified_column := Format('%I', column_name);
+  END IF;
+
+  column_type := CDB_ColumnType(reloid, column_name);
+
+  SELECT EXISTS (
+    SELECT * FROM CDB_ColumnNames(reloid)  as colname WHERE colname = '_feature_count'
+  ) INTO has_counter_column;
+  IF has_counter_column THEN
+    feature_count := '_feature_count';
+    total_feature_count := 'SUM(_feature_count)';
+  ELSE
+    feature_count := '1';
+    total_feature_count := 'count(*)';
+  END IF;
+
+  base_table := _CDB_OverviewBaseTable(reloid);
+
+  CASE column_type
+  WHEN 'double precision', 'real', 'integer', 'bigint', 'numeric' THEN
+    IF column_name = '_feature_count' THEN
+      RETURN 'SUM(_feature_count)';
+    ELSE
+      IF column_type = 'integer' AND _cdb_categorical_column(base_table, column_name) THEN
+        RETURN Format('CDB_Math_Mode(%s)::', qualified_column) || column_type;
+      ELSE
+        RETURN Format('SUM(%s*%s)/%s::' || column_type, qualified_column, feature_count, total_feature_count);
+      END IF;
+    END IF;
+  WHEN 'text', 'character varying', 'character' THEN
+    IF _cdb_categorical_column(base_table, column_name) THEN
+      RETURN Format('_cdb_mode(%s)::', qualified_column) || column_type;
+    ELSE
+      IF _cdb_unlimited_text_column(base_table, column_name) THEN
+        -- TODO: this should not be applied to columns containing largish text;
+        -- it is intended only to short names/identifiers
+        RETURN  'CASE WHEN count(distinct ' || qualified_column || ') = 1 THEN MIN(' || qualified_column || ') WHEN ' || total_feature_count || ' < 5 THEN string_agg(distinct ' || qualified_column || ','' / '') ELSE ''*'' END::' || column_type;
+      ELSE
+        RETURN 'CASE count(*) WHEN 1 THEN MIN(' || qualified_column || ') ELSE NULL END::' || column_type;
+      END IF;
+    END IF;
+  WHEN 'boolean' THEN
+    RETURN 'CASE count(*) WHEN 1 THEN BOOL_AND(' || qualified_column || ') ELSE NULL END::' || column_type;
+  ELSE
+    RETURN 'CASE count(*) WHEN 1 THEN MIN(' || qualified_column || ') ELSE NULL END::' || column_type;
+  END CASE;
+END
+$$ LANGUAGE PLPGSQL IMMUTABLE;
+
+-- List of dataset aggregated attributes as a comma-separated SQL expression.
+-- Scope: private.
+-- Parameters
+--   reloid: oid of the input table. It must be a cartodbfy'ed table.
+--   table_alias: (optional) table qualifier for the columns to be aggregated
+-- Return value: SQL subexpression as text
+CREATE OR REPLACE FUNCTION _CDB_Aggregated_Attributes_Expression(reloid REGCLASS, table_alias TEXT DEFAULT '')
+RETURNS TEXT
+AS $$
+DECLARE
+  attr_list TEXT;
+BEGIN
+  SELECT string_agg(_CDB_Attribute_Aggregation_Expression(reloid, s.c, table_alias) || Format(' AS %s', s.c), ',')
+  FROM (
+    SELECT * FROM _CDB_Aggregable_Attributes(reloid) c
+  ) AS s INTO attr_list;
+
+  RETURN attr_list;
+END
+$$ LANGUAGE PLPGSQL STABLE;
+
+-- Array of geometry types detected in a cartodbfied table
+-- For effciency only look at a limited number of rwos.
+-- Parameters
+--   reloid: oid of the input table. It must be a cartodbfy'ed table.
+-- Return value: array of geometry type names
+CREATE OR REPLACE FUNCTION _CDB_GeometryTypes(reloid REGCLASS)
+RETURNS TEXT[]
+AS $$
+DECLARE
+  gtypes TEXT[];
+BEGIN
+  EXECUTE Format('
+    SELECT array_agg(DISTINCT ST_GeometryType(the_geom)) FROM (
+      SELECT the_geom FROM %s
+        WHERE (the_geom is not null) LIMIT 10
+    ) as geom_types
+  ', reloid)
+  INTO gtypes;
+  RETURN gtypes;
+END
+$$ LANGUAGE PLPGSQL STABLE;
+
+-- Experimental Overview reduction method for point datasets.
+-- It clusters the points using a grid, then aggregates the point in each
+-- cluster into a point at the centroid of the clustered records.
+-- Scope: private.
+-- Parameters:
+--   reloid original table (can be the base table of the dataset or an existing
+--   overview) from which the overview is being generated.
+--   ref_z Z level assigned to the original table
+--   overview_z Z level of the overview to be generated, must be smaller than ref_z
+-- Return value: Name of the generated overview table
+CREATE OR REPLACE FUNCTION _CDB_GridCluster_Reduce_Strategy(reloid REGCLASS, ref_z INTEGER, overview_z INTEGER, grid_px FLOAT8 DEFAULT NULL)
+RETURNS REGCLASS
+AS $$
+  DECLARE
+    overview_rel TEXT;
+    reduction FLOAT8;
+    base_name TEXT;
+    pixel_m FLOAT8;
+    grid_m FLOAT8;
+    offset_m FLOAT8;
+    offset_x TEXT;
+    offset_y TEXT;
+    cell_x TEXT;
+    cell_y TEXT;
+    aggr_attributes TEXT;
+    attributes TEXT;
+    columns TEXT;
+    gtypes TEXT[];
+    schema_name TEXT;
+    table_name TEXT;
+    point_geom TEXT;
+  BEGIN
+    SELECT _CDB_GeometryTypes(reloid) INTO gtypes;
+    IF gtypes IS NULL OR array_upper(gtypes, 1) <> 1 OR gtypes[1] <> 'ST_Point' THEN
+      -- This strategy only supports datasets with point geomety
+      RETURN NULL;
+    END IF;
+
+    --TODO: check applicability: geometry type, minimum number of points...
+
+    overview_rel := _CDB_Overview_Name(reloid, ref_z, overview_z);
+
+    -- Grid size in pixels at Z level overview_z
+    IF grid_px IS NULL THEN
+      grid_px := 1.0;
+    END IF;
+
+    SELECT * FROM _cdb_split_table_name(reloid) INTO schema_name, table_name;
+
+    -- pixel_m: size of a pixel in webmercator units (meters)
+    SELECT CDB_XYZ_Resolution(overview_z) INTO pixel_m;
+    -- grid size in meters
+    grid_m = grid_px * pixel_m;
+
+    attributes := _CDB_Aggregable_Attributes_Expression(reloid);
+    aggr_attributes := _CDB_Aggregated_Attributes_Expression(reloid);
+    IF attributes <> '' THEN
+      attributes := ', ' || attributes;
+    END IF;
+    IF aggr_attributes <> '' THEN
+      aggr_attributes := aggr_attributes || ', ';
+    END IF;
+
+    -- Center of each cell:
+    cell_x := Format('gx*%1$s + %2$s', grid_m, grid_m/2);
+    cell_y := Format('gy*%1$s + %2$s', grid_m, grid_m/2);
+
+    -- Displacement to the nearest pixel center:
+    IF MOD(grid_px::numeric, 1.0::numeric) = 0 THEN
+      offset_m := pixel_m/2 - MOD((grid_m/2)::numeric, pixel_m::numeric)::float8;
+      offset_x := Format('%s', offset_m);
+      offset_y := Format('%s', offset_m);
+    ELSE
+      offset_x := Format('%2$s/2 - MOD((%1$s)::numeric, (%2$s)::numeric)::float8', cell_x, pixel_m);
+      offset_y := Format('%2$s/2 - MOD((%1$s)::numeric, (%2$s)::numeric)::float8', cell_y, pixel_m);
+    END IF;
+
+    point_geom := Format('ST_SetSRID(ST_MakePoint(%1$s + %3$s, %2$s + %4$s), 3857)', cell_x, cell_y, offset_x, offset_y);
+
+    -- compute the resulting columns in the same order as in the base table
+    WITH cols AS (
+      SELECT
+        CASE c
+        WHEN 'cartodb_id' THEN 'cartodb_id'
+        WHEN 'the_geom' THEN
+          Format('ST_Transform(%s, 4326) AS the_geom', point_geom)
+        WHEN 'the_geom_webmercator' THEN
+           Format('%s AS the_geom_webmercator', point_geom)
+        ELSE c
+        END AS column
+        FROM CDB_ColumnNames(reloid) c
+    )
+    SELECT string_agg(s.column, ',') FROM (
+      SELECT * FROM cols
+    ) AS s INTO columns;
+
+    IF NOT columns LIKE '%_feature_count%' THEN
+      columns := columns || ', n AS _feature_count';
+    END IF;
+
+    EXECUTE Format('DROP TABLE IF EXISTS %I.%I CASCADE;', schema_name, overview_rel);
+
+    -- Now we cluster the data using a grid of size grid_m
+    -- and selecte the centroid (average coordinates) of each cluster.
+    -- If we had a selected numeric attribute of interest we could use it
+    -- as a weight for the average coordinates.
+    EXECUTE Format('
+      CREATE TABLE %7$I.%3$I AS
+         WITH clusters AS (
+           SELECT
+             %5$s
+             count(*) AS n,
+             Floor(ST_X(f.the_geom_webmercator)/%2$s)::int AS gx,
+             Floor(ST_Y(f.the_geom_webmercator)/%2$s)::int AS gy,
+             MIN(cartodb_id) AS cartodb_id
+          FROM %1$s f
+          GROUP BY gx, gy
+         )
+         SELECT %6$s FROM clusters
+    ', reloid::text, grid_m, overview_rel, attributes, aggr_attributes, columns, schema_name);
+
+    RETURN Format('%I.%I', schema_name, overview_rel)::regclass;
+  END;
+$$ LANGUAGE PLPGSQL;
+
+-- Create overview tables for a dataset.
+-- Scope: public
+-- Parameters:
+--   reloid: oid of the input table. It must be a cartodbfy'ed table with
+--           vector features.
+--   refscale_strategy: function that computes the reference Z of the dataset
+--   reduce_strategy: function that generates overviews from a base table
+--                    or higher level overview. The overview tables
+--                    created by the strategy must have the same columns
+--                    as the base table and in the same order.
+-- Return value: Array with the names of the generated overview tables
+CREATE OR REPLACE FUNCTION CDB_CreateOverviews(reloid REGCLASS, refscale_strategy regproc DEFAULT '_CDB_Feature_Density_Ref_Z_Strategy(REGCLASS,FLOAT8)'::regprocedure, reduce_strategy regproc DEFAULT '_CDB_GridCluster_Reduce_Strategy(REGCLASS,INTEGER,INTEGER,FLOAT8)'::regprocedure)
+RETURNS text[]
+AS $$
+DECLARE
+  tolerance_px FLOAT8;
+BEGIN
+  -- Use the default tolerance
+  tolerance_px := 1.0;
+  RETURN CDB_CreateOverviewsWithToleranceInPixels(reloid, tolerance_px, refscale_strategy, reduce_strategy);
+END;
+$$ LANGUAGE PLPGSQL;
+
+-- Create overviews with additional parameter to define the desired detail/tolerance in pixels
+CREATE OR REPLACE FUNCTION CDB_CreateOverviewsWithToleranceInPixels(reloid REGCLASS, tolerance_px FLOAT8, refscale_strategy regproc DEFAULT '_CDB_Feature_Density_Ref_Z_Strategy(REGCLASS,FLOAT8)'::regprocedure, reduce_strategy regproc DEFAULT  '_CDB_GridCluster_Reduce_Strategy(REGCLASS,INTEGER,INTEGER,FLOAT8)'::regprocedure)
+RETURNS text[]
+AS $$
+DECLARE
+  ref_z integer;
+  overviews_z integer[];
+  base_z integer;
+  base_rel REGCLASS;
+  overview_z integer;
+  overview_tables REGCLASS[];
+  overviews_step integer := 1;
+  has_counter_column boolean;
+BEGIN
+  -- Determine the referece zoom level
+  EXECUTE 'SELECT ' || quote_ident(refscale_strategy::text) || Format('(''%s'', %s);', reloid, tolerance_px) INTO ref_z;
+
+  IF ref_z < 0 OR ref_z IS NULL THEN
+    RETURN NULL;
+  END IF;
+
+  -- Determine overlay zoom levels
+  -- TODO: should be handled by the refscale_strategy?
+  overview_z := ref_z - 1;
+  WHILE overview_z >= 0 LOOP
+    SELECT array_append(overviews_z, overview_z) INTO overviews_z;
+    overview_z := overview_z - overviews_step;
+  END LOOP;
+
+  -- Create overlay tables
+  base_z := ref_z;
+  base_rel := reloid;
+  FOREACH overview_z IN ARRAY overviews_z LOOP
+    EXECUTE 'SELECT ' || quote_ident(reduce_strategy::text) || Format('(''%s'', %s, %s, %s);', base_rel, base_z, overview_z, tolerance_px) INTO base_rel;
+    IF base_rel IS NULL THEN
+      EXIT;
+    END IF;
+    base_z := overview_z;
+    PERFORM _CDB_Register_Overview(reloid, base_rel, base_z);
+    SELECT array_append(overview_tables, base_rel) INTO overview_tables;
+  END LOOP;
+
+  IF overview_tables IS NOT NULL AND array_length(overview_tables, 1) > 0 THEN
+    SELECT EXISTS (
+      SELECT * FROM CDB_ColumnNames(reloid)  as colname WHERE colname = '_feature_count'
+    ) INTO has_counter_column;
+    IF NOT has_counter_column THEN
+      EXECUTE Format('
+        ALTER TABLE %s ADD COLUMN _feature_count integer DEFAULT 1;
+      ', reloid);
+    END IF;
+  END IF;
+
+  RETURN overview_tables;
+END;
+$$ LANGUAGE PLPGSQL;
+
+-- Here are some older signatures of these functions, no longar in use.
+-- They must be droped here, after the (new) definition of the function `CDB_CreateOverviews`
+-- because that function used to contain references to them in the default argument values.
+DROP FUNCTION IF EXISTS _CDB_Feature_Density_Ref_Z_Strategy(REGCLASS);
+DROP FUNCTION IF EXISTS _CDB_GridCluster_Reduce_Strategy(REGCLASS,INTEGER,INTEGER);
+DROP FUNCTION IF EXISTS _CDB_Sampling_Reduce_Strategy(REGCLASS,INTEGER,INTEGER);
--- a/scripts-available/CDB_QuantileBins.sql
+++ b/scripts-available/CDB_QuantileBins.sql
@@ -15,18 +15,29 @@ DECLARE
    i INT := 1; 
    reply numeric[]; 
 BEGIN 
-    -- get our unique values
-    SELECT array_agg(e) INTO in_array FROM (SELECT unnest(in_array) e GROUP BY e ORDER BY e ASC) x;
-    -- get the total size of our row
-    element_count := array_upper(in_array, 1) - array_lower(in_array, 1); 
+    -- sort our values
+    SELECT array_agg(e) INTO in_array FROM (SELECT unnest(in_array) e ORDER BY e ASC) x;
+    -- get the total size of our data
+    element_count := array_length(in_array, 1); 
    break_size :=  element_count::numeric / breaks;
    -- slice our bread
    LOOP  
-        IF i > breaks THEN  EXIT;  END IF;  
-        SELECT e INTO tmp_val FROM ( SELECT unnest(in_array) e LIMIT 1 OFFSET round(break_size * i)) x;
+        IF i < breaks THEN
+            IF break_size * i % 1 > 0 THEN
+                SELECT e INTO tmp_val FROM ( SELECT unnest(in_array) e LIMIT 1 OFFSET ceil(break_size * i) - 1) x;
+            ELSE
+                SELECT avg(e) INTO tmp_val FROM ( SELECT unnest(in_array) e LIMIT 2 OFFSET ceil(break_size * i) - 1 ) x;
+            END IF;
+        ELSIF i = breaks THEN
+            -- select the last value
+            SELECT max(e) INTO tmp_val FROM ( SELECT unnest(in_array) e ) x;
+        ELSE
+            EXIT;
+        END IF;
+
        reply = array_append(reply, tmp_val);
-        i := i+1; 
-    END LOOP; 
-    RETURN reply; 
+        i := i+1;
+    END LOOP;
+    RETURN reply;
 END; 
-$$ language plpgsql IMMUTABLE;
+$$ language plpgsql IMMUTABLE;
--- a/scripts-available/CDB_QueryTables.sql
+++ b/scripts-available/CDB_QueryTables.sql
@@ -2,12 +2,12 @@
 --
 -- Requires PostgreSQL 9.x+
 --
-CREATE OR REPLACE FUNCTION CDB_QueryTables(query text)
-RETURNS name[]
+CREATE OR REPLACE FUNCTION CDB_QueryTablesText(query text)
+RETURNS text[]
 AS $$
 DECLARE
  exp XML;
-  tables NAME[];
+  tables text[];
  rec RECORD;
  rec2 RECORD;
 BEGIN
@@ -16,9 +16,9 @@ BEGIN

  FOR rec IN SELECT CDB_QueryStatements(query) q LOOP

-    IF NOT ( rec.q ilike 'select %' or rec.q ilike 'with %' ) THEN
-      --RAISE WARNING 'Skipping %', rec.q;
-      CONTINUE;
+    IF NOT ( rec.q ilike 'select%' or rec.q ilike 'with%' ) THEN
+        --RAISE WARNING 'Skipping %', rec.q;
+        CONTINUE;
    END IF;

    BEGIN
@@ -41,11 +41,11 @@ BEGIN
          xpath('//x:Relation-Name/text()', exp, ARRAY[ARRAY['x', 'http://www.postgresql.org/2009/explain']]) as x,
          xpath('//x:Relation-Name/../x:Schema/text()', exp, ARRAY[ARRAY['x', 'http://www.postgresql.org/2009/explain']]) as s
      )
-      SELECT unnest(x)::name as p, unnest(s)::name as sc from inp
+      SELECT unnest(x)::text as p, unnest(s)::text as sc from inp
    LOOP
      -- RAISE DEBUG 'tab: %', rec2.p;
      -- RAISE DEBUG 'sc: %', rec2.sc;
-      tables := array_append(tables, (rec2.sc || '.' || rec2.p)::name);
+      tables := array_append(tables, format('%s.%s', quote_ident(rec2.sc), quote_ident(rec2.p)));
    END LOOP;

    -- RAISE DEBUG 'Tables: %', tables;
@@ -65,3 +65,14 @@ BEGIN
  return tables;
 END
 $$ LANGUAGE 'plpgsql' VOLATILE STRICT;
+
+
+-- Keep CDB_QueryTables with same signature for backwards compatibility.
+-- It should probably be removed in the future.
+CREATE OR REPLACE FUNCTION CDB_QueryTables(query text)
+RETURNS name[]
+AS $$
+BEGIN
+  RETURN CDB_QueryTablesText(query)::name[];
+END
+$$ LANGUAGE 'plpgsql' VOLATILE STRICT;
--- a/scripts-available/CDB_Quota.sql
+++ b/scripts-available/CDB_Quota.sql
@@ -1,21 +1,62 @@
+CREATE OR REPLACE FUNCTION cartodb._CDB_total_relation_size(_schema_name TEXT, _table_name TEXT)
+RETURNS bigint AS
+$$
+DECLARE relation_size bigint := 0;
+BEGIN
+  BEGIN
+    SELECT pg_total_relation_size(format('"%s"."%s"', _schema_name, _table_name)) INTO relation_size;
+  EXCEPTION
+    WHEN undefined_table OR OTHERS THEN
+      RAISE NOTICE 'cartodb._CDB_total_relation_size(''%'', ''%'') caught error: % (%)', _schema_name, _table_name, SQLERRM, SQLSTATE;
+  END;
+  RETURN relation_size;
+END;
+$$
+LANGUAGE 'plpgsql' VOLATILE;
+
 -- Return the estimated size of user data. Used for quota checking.
 CREATE OR REPLACE FUNCTION CDB_UserDataSize(schema_name TEXT)
 RETURNS bigint AS
 $$
-  -- TODO: double check this query. Maybe use CDB_TableMetadata for lookup ?
-  --       also, it's "table_name" sounds sensible to search_path
-  --
-  -- NOTE: division by 2 is an hack for the_geom_webmercator
-  --
-  SELECT coalesce(int8(sum(pg_total_relation_size(schema_name || '.' || table_name)) / 2), 0)
-    AS quota
-  FROM information_schema.tables
-  WHERE table_catalog = current_database() AND table_schema = schema_name
+DECLARE
+  total_size INT8;
+BEGIN
+  WITH raster_tables AS (
+    SELECT o_table_name, r_table_name FROM raster_overviews
+      WHERE o_table_schema = schema_name AND o_table_catalog = current_database()
+  ),
+  user_tables AS (
+    SELECT table_name FROM information_schema.tables
+      WHERE table_catalog = current_database() AND table_schema = schema_name
        AND table_name != 'spatial_ref_sys'
        AND table_name != 'cdb_tablemetadata'
-        AND table_type = 'BASE TABLE';
+        AND table_type = 'BASE TABLE'
+  ),
+  table_cat AS (
+    SELECT
+      table_name,
+      EXISTS(select * from raster_tables where o_table_name = table_name) AS is_overview,
+      EXISTS(SELECT * FROM raster_tables WHERE r_table_name = table_name) AS is_raster
+    FROM user_tables
+  ),
+  sizes AS (
+    SELECT COALESCE(INT8(SUM(cartodb._CDB_total_relation_size(schema_name, table_name)))) table_size,
+      CASE
+        WHEN is_overview THEN 0
+	WHEN is_raster THEN 1
+	ELSE 0.5 -- Division by 2 is for not counting the_geom_webmercator
+      END AS multiplier FROM table_cat GROUP BY is_overview, is_raster
+  )
+  SELECT sum(table_size*multiplier)::int8 INTO total_size FROM sizes;
+
+  IF total_size IS NOT NULL THEN
+    RETURN total_size;
+  ELSE
+    RETURN 0;
+  END IF;
+END;
 $$
-LANGUAGE 'sql' VOLATILE;
+LANGUAGE 'plpgsql' VOLATILE;


 -- Return the estimated size of user data. Used for quota checking.
@@ -46,16 +87,20 @@ BEGIN
  ELSE
    schema_name := 'public';
  END IF;
-  -- Hack to support old versions of CDB_CheckQuota with 2 params but without schema_name
-  IF TG_NARGS >= 2 AND TG_ARGV[1] <> '-1' THEN
-    qmax := TG_ARGV[1];
-  ELSE
+
+  -- By default try to use quota function, and if not present then rely on the one specified by params
+  BEGIN
+    EXECUTE FORMAT('SELECT %I._CDB_UserQuotaInBytes();', schema_name) INTO qmax;
+  EXCEPTION WHEN undefined_function THEN
    BEGIN
-      EXECUTE FORMAT('SELECT %I._CDB_UserQuotaInBytes();', schema_name) INTO qmax;
-      EXCEPTION WHEN undefined_function THEN
-      RAISE EXCEPTION 'Missing "%"._CDB_UserQuotaInBytes()', schema_name;
+      IF TG_NARGS >= 2 AND TG_ARGV[1] <> '-1' THEN
+        qmax := TG_ARGV[1];
+      ELSE
+        RAISE EXCEPTION 'Missing "%"._CDB_UserQuotaInBytes()', schema_name;
+      END IF;
    END;
-  END IF;
+  END;
+
  pbfact := TG_ARGV[0];

  dice := random();
--- a/scripts-available/CDB_Stats.sql
+++ b/scripts-available/CDB_Stats.sql
@@ -0,0 +1,47 @@
+--
+-- Calculate basic statistics of a given dataset
+--
+-- @param in_array A numeric array of numbers
+--
+-- Returns: statistical quantity chosen
+-- 
+-- References: http://www.itl.nist.gov/div898/handbook/eda/section3/eda35b.htm
+--
+
+-- Calculate kurtosis
+CREATE OR REPLACE FUNCTION CDB_Kurtosis ( in_array NUMERIC[] ) RETURNS NUMERIC as $$
+DECLARE
+    a numeric;
+    c numeric;
+    s numeric;
+    k numeric;
+BEGIN
+    SELECT AVG(e), COUNT(e)::numeric, stddev(e) INTO a, c, s FROM ( SELECT unnest(in_array) e ) x;
+
+    EXECUTE 'SELECT sum(power($1 - e, 4)) / ( $2 * power($3, 4)) - 3
+             FROM (SELECT unnest($4) e ) x'
+    INTO k
+    USING a, c, s, in_array;
+
+    RETURN k;
+END;
+$$ language plpgsql IMMUTABLE;
+
+-- Calculate skewness
+CREATE OR REPLACE FUNCTION CDB_Skewness ( in_array NUMERIC[] ) RETURNS NUMERIC as $$
+DECLARE
+    a numeric;
+    c numeric;
+    s numeric;
+    sk numeric;
+BEGIN
+    SELECT AVG(e), COUNT(e)::numeric, stddev(e) INTO a, c, s FROM ( SELECT unnest(in_array) e ) x;
+
+    EXECUTE 'SELECT sum(power($1 - e, 3)) / ( $2 * power($3, 3))
+             FROM (SELECT unnest($4) e ) x'
+    INTO sk
+    USING a, c, s, in_array;
+
+    RETURN sk;
+END;
+$$ language plpgsql IMMUTABLE;
--- a/scripts-available/CDB_StringToDate.sql
+++ b/scripts-available/CDB_StringToDate.sql
@@ -1,8 +1,9 @@
 -- Convert string to date
 --
+DROP FUNCTION IF EXISTS CDB_StringToDate(character varying);
 CREATE OR REPLACE FUNCTION CDB_StringToDate(input character varying)
-RETURNS date AS $$
-DECLARE output DATE;
+RETURNS TIMESTAMP AS $$
+DECLARE output TIMESTAMP;
 BEGIN
    BEGIN
        output := input::date;
--- a/scripts-available/CDB_TableMetadata.sql
+++ b/scripts-available/CDB_TableMetadata.sql
@@ -5,9 +5,14 @@ CREATE TABLE IF NOT EXISTS
    updated_at timestamp with time zone not null default now()
  );

-- Anyone can see this, but updates are only possible trough
-- the security definer trigger
-GRANT SELECT ON public.CDB_TableMetadata TO public;
+CREATE OR REPLACE VIEW public.CDB_TableMetadata_Text AS
+       SELECT FORMAT('%I.%I', n.nspname::text, c.relname::text) tabname, updated_at
+       FROM public.CDB_TableMetadata, pg_catalog.pg_class c
+       LEFT JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid;
+
+-- No one can see this
+-- Updates are only possible trough the security definer trigger
+-- GRANT SELECT ON public.CDB_TableMetadata TO public;

 --
 -- Trigger logging updated_at in the CDB_TableMetadata
@@ -61,9 +66,11 @@ CREATE OR REPLACE FUNCTION _CDB_TableMetadata_Updated()
 RETURNS trigger AS
 $$
 DECLARE
-  tabname TEXT;
+  tabname regclass;
  rec RECORD;
  found BOOL;
+  schema_name TEXT;
+  table_name TEXT;
 BEGIN

  IF TG_OP = 'UPDATE' or TG_OP = 'INSERT' THEN
@@ -98,9 +105,10 @@ BEGIN
               AND u.usesuper
             ORDER BY n.nspname
  LOOP
+    SELECT n.nspname, c.relname FROM pg_class c, pg_namespace n WHERE c.oid=tabname AND c.relnamespace = n.oid INTO schema_name, table_name;
    EXECUTE 'SELECT ' || quote_ident(rec.nspname) || '.'
            || quote_ident(rec.proname)
-            || '(' || quote_literal(tabname) || ')';
+            || '(' || quote_literal(quote_ident(schema_name) || '.' || quote_ident(table_name)) || ')';
    found := true;
    EXIT;
  END LOOP;
@@ -111,10 +119,28 @@ END;
 $$
 LANGUAGE plpgsql VOLATILE SECURITY DEFINER;

-DROP TRIGGER IF EXISTS table_modified ON CDB_TableMetadata;
+DROP TRIGGER IF EXISTS table_modified ON public.CDB_TableMetadata;
 -- NOTE: on DELETE we would be unable to convert the table
 --       oid (regclass) to its name
 CREATE TRIGGER table_modified AFTER INSERT OR UPDATE
-ON CDB_TableMetadata FOR EACH ROW EXECUTE PROCEDURE
+ON public.CDB_TableMetadata FOR EACH ROW EXECUTE PROCEDURE
 _CDB_TableMetadata_Updated();

+
+-- similar to TOUCH(1) in unix filesystems but for table in cdb_tablemetadata
+CREATE OR REPLACE FUNCTION public.CDB_TableMetadataTouch(tablename regclass)
+    RETURNS void AS
+    $$
+    BEGIN
+        WITH upsert AS (
+            UPDATE public.cdb_tablemetadata
+            SET updated_at = NOW()
+            WHERE tabname = tablename
+            RETURNING *
+        )
+        INSERT INTO public.cdb_tablemetadata (tabname, updated_at)
+            SELECT tablename, NOW()
+            WHERE NOT EXISTS (SELECT * FROM upsert);
+    END;
+    $$
+LANGUAGE 'plpgsql' VOLATILE STRICT;
--- a/scripts-available/CDB_UserTables.sql
+++ b/scripts-available/CDB_UserTables.sql
@@ -5,35 +5,22 @@
 --
 -- Currently accepted permissions are: 'public', 'private' or 'all'
 --
+DROP FUNCTION IF EXISTS CDB_UserTables(text);
 CREATE OR REPLACE FUNCTION CDB_UserTables(perm text DEFAULT 'all')
-RETURNS SETOF information_schema.sql_identifier
+RETURNS SETOF name
 AS $$
-  WITH usertables AS ( 
-    -- TODO: query CDB_TableMetadata for this ?
-    -- See http://github.com/CartoDB/cartodb/issues/254#issuecomment-26044777
-    SELECT table_name as t
-    FROM information_schema.tables
-    WHERE
-         table_type='BASE TABLE'
-     AND table_schema='public'
-     AND table_name NOT IN (
-      'cdb_tablemetadata',
-      'spatial_ref_sys'
-     )
-  ), perms AS (
-    SELECT t, has_table_privilege('public', 'public'||'.'||t, 'SELECT') as p
-    FROM usertables
-  )
-  SELECT t FROM perms
-  WHERE (
-    p = CASE WHEN $1 = 'private' THEN false
-                 WHEN $1 = 'public' THEN true
-                 ELSE not p -- none
-            END
-    OR $1 = 'all'
-  )
-  AND has_table_privilege('public'||'.'||t, 'SELECT')
-   ;
+
+SELECT c.relname 
+FROM pg_class c 
+JOIN pg_namespace n ON n.oid = c.relnamespace
+WHERE c.relkind = 'r' 
+AND c.relname NOT IN ('cdb_tablemetadata', 'spatial_ref_sys')
+AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'topology', 'cartodb')
+AND CASE WHEN perm = 'public' THEN has_table_privilege('publicuser', c.oid, 'SELECT')
+         WHEN perm = 'private' THEN has_table_privilege(current_user, c.oid, 'SELECT') AND NOT has_table_privilege('publicuser', c.oid, 'SELECT')
+         WHEN perm = 'all' THEN has_table_privilege(current_user, c.oid, 'SELECT') OR has_table_privilege('publicuser', c.oid, 'SELECT')
+         ELSE false END;
+
 $$ LANGUAGE 'sql';

 -- This is to migrate from pre-0.2.0 version
--- a/scripts-available/CDB_XYZ.sql
+++ b/scripts-available/CDB_XYZ.sql
@@ -5,24 +5,9 @@
 CREATE OR REPLACE FUNCTION CDB_XYZ_Resolution(z INTEGER)
 RETURNS FLOAT8
 AS $$
-DECLARE
-  earth_circumference FLOAT8;
-  tile_size INTEGER;
-  full_resolution FLOAT8;
-BEGIN
-
-  -- Earth equatorial circumference in meters (according to wikipedia)
-  earth_circumference := 40075017;
-
-  -- Size of each tile in pixels (1:1 aspect ratio)
-  tile_size := 256;
-
-  full_resolution := earth_circumference/tile_size;
-
-  RETURN full_resolution / (power(2,z));
-
-END
-$$ LANGUAGE 'plpgsql' IMMUTABLE STRICT;
+  -- circumference divided by 256 is z0 resolution, then divide by 2^z
+  SELECT 6378137.0*2.0*pi() / 256.0 / power(2.0, z);
+$$ LANGUAGE SQL IMMUTABLE STRICT;
 -- }

 -- {
--- a/scripts-available/CDB_ZoomFromScale.sql
+++ b/scripts-available/CDB_ZoomFromScale.sql
@@ -0,0 +1,30 @@
+CREATE OR REPLACE FUNCTION cartodb.CDB_ZoomFromScale(scaleDenominator numeric) RETURNS int AS $$
+BEGIN
+  CASE
+    WHEN scaleDenominator > 500000000 THEN RETURN 0;
+    WHEN scaleDenominator <= 500000000 AND scaleDenominator > 200000000 THEN RETURN 1;
+    WHEN scaleDenominator <= 200000000 AND scaleDenominator > 100000000 THEN RETURN 2;
+    WHEN scaleDenominator <= 100000000 AND scaleDenominator > 50000000 THEN RETURN 3;
+    WHEN scaleDenominator <= 50000000 AND scaleDenominator > 25000000 THEN RETURN 4;
+    WHEN scaleDenominator <= 25000000 AND scaleDenominator > 12500000 THEN RETURN 5;
+    WHEN scaleDenominator <= 12500000 AND scaleDenominator > 6500000 THEN RETURN 6;
+    WHEN scaleDenominator <= 6500000 AND scaleDenominator > 3000000 THEN RETURN 7;
+    WHEN scaleDenominator <= 3000000 AND scaleDenominator > 1500000 THEN RETURN 8;
+    WHEN scaleDenominator <= 1500000 AND scaleDenominator > 750000 THEN RETURN 9;
+    WHEN scaleDenominator <= 750000 AND scaleDenominator > 400000 THEN RETURN 10;
+    WHEN scaleDenominator <= 400000 AND scaleDenominator > 200000 THEN RETURN 11;
+    WHEN scaleDenominator <= 200000 AND scaleDenominator > 100000 THEN RETURN 12;
+    WHEN scaleDenominator <= 100000 AND scaleDenominator > 50000 THEN RETURN 13;
+    WHEN scaleDenominator <= 50000 AND scaleDenominator > 25000 THEN RETURN 14;
+    WHEN scaleDenominator <= 25000 AND scaleDenominator > 12500 THEN RETURN 15;
+    WHEN scaleDenominator <= 12500 AND scaleDenominator > 5000 THEN RETURN 16;
+    WHEN scaleDenominator <= 5000 AND scaleDenominator > 2500 THEN RETURN 17;
+    WHEN scaleDenominator <= 2500 AND scaleDenominator > 1500 THEN RETURN 18;
+    WHEN scaleDenominator <= 1500 AND scaleDenominator > 750 THEN RETURN 19;
+    WHEN scaleDenominator <= 750 AND scaleDenominator > 500 THEN RETURN 20;
+    WHEN scaleDenominator <= 500 AND scaleDenominator > 250 THEN RETURN 21;
+    WHEN scaleDenominator <= 250 AND scaleDenominator > 100 THEN RETURN 22;
+    WHEN scaleDenominator <= 100 THEN RETURN 23;
+  END CASE;
+END
+$$ LANGUAGE plpgsql IMMUTABLE;
--- a/scripts-enabled/220-CDB_Math.sql
+++ b/scripts-enabled/220-CDB_Math.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_Math.sql
--- a/scripts-enabled/230-CDB_ZoomFromScale.sql
+++ b/scripts-enabled/230-CDB_ZoomFromScale.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_ZoomFromScale.sql
--- a/scripts-enabled/240-CDB_EqualIntervalBins.sql
+++ b/scripts-enabled/240-CDB_EqualIntervalBins.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_EqualIntervalBins.sql
--- a/scripts-enabled/241-CDB_GreatCircle.sql
+++ b/scripts-enabled/241-CDB_GreatCircle.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_GreatCircle.sql
--- a/scripts-enabled/242-CDB_Overviews.sql
+++ b/scripts-enabled/242-CDB_Overviews.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_Overviews.sql
--- a/scripts-enabled/250-CDB_ForeignTable.sql
+++ b/scripts-enabled/250-CDB_ForeignTable.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_ForeignTable.sql
--- a/scripts-enabled/260-CDB_AnalysisCatalog.sql
+++ b/scripts-enabled/260-CDB_AnalysisCatalog.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_AnalysisCatalog.sql
--- a/scripts-enabled/CDB_Conf.sql
+++ b/scripts-enabled/CDB_Conf.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_Conf.sql
--- a/scripts-enabled/CDB_DistType.sql
+++ b/scripts-enabled/CDB_DistType.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_DistType.sql
--- a/scripts-enabled/CDB_DistinctMeasure.sql
+++ b/scripts-enabled/CDB_DistinctMeasure.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_DistinctMeasure.sql
--- a/scripts-enabled/CDB_Groups.sql
+++ b/scripts-enabled/CDB_Groups.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_Groups.sql
--- a/scripts-enabled/CDB_Groups_API.sql
+++ b/scripts-enabled/CDB_Groups_API.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_Groups_API.sql
--- a/scripts-enabled/CDB_Stats.sql
+++ b/scripts-enabled/CDB_Stats.sql
@@ -0,0 +1 @@
+../scripts-available/CDB_Stats.sql
--- a/sql/test_ddl_triggers.sql
+++ b/sql/test_ddl_triggers.sql
@@ -1,128 +0,0 @@
-\set VERBOSITY terse
-
-- Set user quota to infinite
-SELECT CDB_SetUserQuotaInBytes(0);
-
-- Enable ddl triggers
-SELECT cartodb.cdb_enable_ddl_hooks();
-
-create schema c;
-
-CREATE USER cartodb_postgresql_unpriv_user;
-GRANT ALL ON SCHEMA c to cartodb_postgresql_unpriv_user;
-SET SESSION AUTHORIZATION 'cartodb_postgresql_unpriv_user';
--SELECT session_user, current_user;
-
----------------------
-- CREATE TABLE
----------------------
-
-select 1 as i INTO c.t3;
-
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i
-from c.t3;
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)) as age
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
-
-- Table with cartodb_id field, see
-- http://github.com/CartoDB/cartodb-postgresql/issues/32
-select 1 as cartodb_id INTO c.t4;
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator
-from c.t4;
-select
- tabname::text,
- round(extract('secs' from now() - updated_at)) as age
-FROM CDB_TableMetadata WHERE tabname = 'c.t4'::regclass;
-
----------------------------
-- ALTER TABLE RENAME COLUMN
----------------------------
-
-select pg_sleep(.1);
-alter table c.t3 rename column the_geom_webmercator to webmerc;
-
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i, webmerc
-from c.t3;
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)*10) as agecs
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
-
-select pg_sleep(.1);
-alter table c.t3 rename column the_geom_webmercator to webmerc2;
-
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i, webmerc, webmerc2
-from c.t3;
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)*10) as agecs
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
-
----------------------------
-- ALTER TABLE DROP COLUMN
----------------------------
-
-select pg_sleep(.1);
-alter table c.t3 drop column the_geom_webmercator;
-
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i, webmerc, webmerc2
-from c.t3;
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)*10) as agecs
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
-
----------------------------
-- ALTER TABLE ADD COLUMN
----------------------------
-
-select pg_sleep(.1);
-alter table c.t3 add column id2 int;
-
-select
- cartodb_id, created_at=updated_at as "c=u",
- NOW() - updated_at < '1 secs' as "u<1s",
- the_geom, the_geom_webmercator,
- i, webmerc, webmerc2, id2
-from c.t3;
-
-select
- tabname::text,
- round(extract('secs' from now()  - updated_at)*10) as agecs
-FROM CDB_TableMetadata WHERE tabname = 'c.t3'::regclass;
-
----------------------------
-- DROP TABLE
----------------------------
-
-RESET SESSION AUTHORIZATION;
-drop schema c cascade;
-select count(*) from CDB_TableMetadata;
-
-DROP USER cartodb_postgresql_unpriv_user;
-DROP FUNCTION _CDB_UserQuotaInBytes();
--- a/sql/test_setup.sql
+++ b/sql/test_setup.sql
@@ -1,5 +1,4 @@
 CREATE EXTENSION postgis;
-CREATE EXTENSION schema_triggers;
 CREATE EXTENSION plpythonu;
 CREATE EXTENSION cartodb;
 CREATE FUNCTION public.cdb_invalidate_varnish(table_name text)
--- a/test/CDB_CartodbfyTableTest.sql
+++ b/test/CDB_CartodbfyTableTest.sql
@@ -1,5 +1,5 @@
 SET client_min_messages TO error;
-\set VERBOSITY terse;
+\set VERBOSITY terse

 CREATE OR REPLACE FUNCTION CDB_CartodbfyTableCheck(tabname regclass, label text)
 RETURNS text AS
@@ -12,11 +12,12 @@ DECLARE
  tmp INTEGER;
  ogc_geom geometry_columns; -- old the_geom record in geometry_columns
  ogc_merc geometry_columns; -- old the_geom_webmercator record in geometry_columns
+  tabtext TEXT;
 BEGIN

  -- Save current constraints on geometry columns, if any
-  ogc_geom = ('','','','',0,0,'GEOMETRY'); 
-  ogc_merc = ogc_geom; 
+  ogc_geom = ('','','','',0,0,'GEOMETRY');
+  ogc_merc = ogc_geom;
  sql := 'SELECT gc.* FROM geometry_columns gc, pg_class c, pg_namespace n '
    || 'WHERE c.oid = ' || tabname::oid || ' AND n.oid = c.relnamespace'
    || ' AND gc.f_table_schema = n.nspname AND gc.f_table_name = c.relname'
@@ -30,24 +31,17 @@ BEGIN
    END IF;
  END LOOP;

+  tabtext := Format('%s.%s','public',tabname);
+  RAISE NOTICE 'CARTODBFYING % !!!!', tabtext;
  PERFORM CDB_CartodbfyTable('public', tabname);
+  tabname := tabtext::regclass;

  sql := 'INSERT INTO ' || tabname::text || '(the_geom) values ( CDB_LatLng(2,1) ) RETURNING cartodb_id';
  EXECUTE sql INTO STRICT id;
-  sql := 'SELECT created_at,updated_at,the_geom_webmercator FROM '
+  sql := 'SELECT the_geom_webmercator FROM '
    || tabname::text || ' WHERE cartodb_id = ' || id;
  EXECUTE sql INTO STRICT rec;

-  -- Check created_at and updated_at at creation time
-  lag = rec.created_at - now();
-  IF lag > '1 second' THEN
-    RAISE EXCEPTION 'created_at not defaulting to now() after insert [ valued % ago ]', lag;
-  END IF;
-  lag = rec.updated_at - now();
-  IF lag > '1 second' THEN
-    RAISE EXCEPTION 'updated_at not defaulting to now() after insert [ valued % ago ]', lag;
-  END IF;
-
  -- Check the_geom_webmercator trigger
  IF round(st_x(rec.the_geom_webmercator)) != 111319 THEN
    RAISE EXCEPTION 'the_geom_webmercator X is % (expecting 111319)', round(st_x(rec.the_geom_webmercator));
@@ -72,7 +66,7 @@ BEGIN
           ELSE 3857 END as expsrid,
      CASE WHEN gc.f_geometry_column = 'the_geom' THEN ogc_geom.type
           ELSE ogc_merc.type END as exptype, gc.*
-    FROM geometry_columns gc, pg_class c, pg_namespace n 
+    FROM geometry_columns gc, pg_class c, pg_namespace n
    WHERE c.oid = tabname::oid AND n.oid = c.relnamespace
          AND gc.f_table_schema = n.nspname AND gc.f_table_name = c.relname
          AND gc.f_geometry_column IN ( 'the_geom', 'the_geom_webmercator')
@@ -84,7 +78,7 @@ BEGIN
        rec.f_geometry_column, rec.srid, rec.expsrid;
    END IF;
    -- Check TYPE constraint didn't change
-    IF rec.type != rec.exptype THEN
+    IF (rec.type != 'GEOMETRY') AND (rec.type != 'POINT') THEN
      RAISE EXCEPTION 'type of % in geometry_columns is %, expected %',
        rec.f_geometry_column, rec.type, rec.exptype;
    END IF;
@@ -94,7 +88,7 @@ BEGIN
      RAISE EXCEPTION '% entries found for table % in geometry_columns, expected 2', tmp, tabname;
  END IF;

-  -- Check GiST index 
+  -- Check GiST index
  sql := 'SELECT a.attname, count(ri.relname) FROM'
    || ' pg_index i, pg_class c, pg_class ri, pg_attribute a, pg_opclass o'
    || ' WHERE i.indrelid = c.oid AND ri.oid = i.indexrelid'
@@ -115,10 +109,10 @@ BEGIN
  -- Check null constraint on cartodb_id, created_at, updated_at
  SELECT count(*) FROM pg_attribute a, pg_class c WHERE c.oid = tabname::oid
    AND a.attrelid = c.oid AND NOT a.attisdropped AND a.attname in
-      ( 'cartodb_id', 'created_at', 'updated_at' )
+      ( 'cartodb_id' )
    AND NOT a.attnotnull INTO strict tmp;
  IF tmp > 0 THEN
-      RAISE EXCEPTION 'cartodb_id or created_at or updated_at are missing not-null constraint';
+      RAISE EXCEPTION 'cartodb_id is missing not-null constraint';
  END IF;

  -- Cleanup
@@ -130,13 +124,21 @@ END;
 $$
 LANGUAGE 'plpgsql';

-- table with single non-geometrical column
+-- check cartodbfytable idempotence
 CREATE TABLE t AS SELECT 1::int as a;
 SELECT CDB_CartodbfyTable('public', 't'); -- should fail
 SELECT CDB_SetUserQuotaInBytes(0); -- Set user quota to infinite
 SELECT CDB_CartodbfyTableCheck('t', 'single non-geometrical column');
 DROP TABLE t;

+-- table with single non-geometrical column
+CREATE TABLE t AS SELECT ST_SetSRID(ST_MakePoint(-1,-1),4326) as the_geom, 1::int as cartodb_id, 'this is a sentence' as description;
+SELECT CDB_CartodbfyTableCheck('t', 'check function idempotence');
+SELECT * FROM t;
+SELECT CDB_CartodbfyTableCheck('t', 'check function idempotence');
+SELECT * FROM t;
+DROP TABLE t;
+
 -- table with existing srid-unconstrained (but type-constrained) the_geom
 CREATE TABLE t AS SELECT ST_SetSRID(ST_MakePoint(0,0),4326)::geometry(point) as the_geom;
 SELECT CDB_CartodbfyTableCheck('t', 'srid-unconstrained the_geom');
@@ -170,34 +172,51 @@ SELECT CDB_CartodbfyTableCheck('t', 'trigger-protected the_geom');
 SELECT 'extent',ST_Extent(ST_SnapToGrid(the_geom,0.2)) FROM t;
 DROP TABLE t;

-- table with existing updated_at and created_at fields ot type text
-CREATE TABLE t AS SELECT NOW()::text as created_at,
-                         NOW()::text as updated_at,
-                         NOW() as reftime;
-SELECT CDB_CartodbfyTableCheck('t', 'text timestamps');
-SELECT extract(secs from reftime-created_at),
-       extract(secs from reftime-updated_at) FROM t;
-CREATE VIEW v AS SELECT * FROM t;
-SELECT CDB_CartodbfyTableCheck('t', 'cartodbfied with view');
-DROP VIEW v;
-DROP TABLE t;
-
 -- table with existing cartodb_id field of type text
 CREATE TABLE t AS SELECT 10::text as cartodb_id;
 SELECT CDB_CartodbfyTableCheck('t', 'text cartodb_id');
-select cartodb_id/2 FROM t; 
+select cartodb_id/2 FROM t;
 DROP TABLE t;

 -- table with existing cartodb_id field of type text not casting
-CREATE TABLE t AS SELECT 'nan' as cartodb_id;
+CREATE TABLE t AS SELECT 'nan'::text as cartodb_id;
 SELECT CDB_CartodbfyTableCheck('t', 'uncasting text cartodb_id');
-select cartodb_id,_cartodb_id0 FROM t; 
+DROP TABLE t;
+
+-- table with empty cartodb_id field of type text
+CREATE TABLE t AS SELECT null::text as cartodb_id;
+SELECT CDB_CartodbfyTableCheck('t', 'empty text cartodb_id');
+SELECT cartodb_id from t;
 DROP TABLE t;

 -- table with existing cartodb_id field of type int4 not sequenced
 CREATE TABLE t AS SELECT 1::int4 as cartodb_id;
 SELECT CDB_CartodbfyTableCheck('t', 'unsequenced cartodb_id');
-select cartodb_id FROM t; 
+SELECT cartodb_id FROM t;
+DROP TABLE t;
+
+-- table with text geometry column
+CREATE TABLE t AS SELECT 'SRID=4326;POINT(1 1)'::text AS the_geom, 1::int4 as cartodb_id;
+SELECT CDB_CartodbfyTableCheck('t', 'text the_geom column');
+SELECT cartodb_id FROM t;
+DROP TABLE t;
+
+-- table with text geometry column, no SRS
+CREATE TABLE t AS SELECT 'POINT(1 1)'::text AS the_geom, 1::int4 as cartodb_id;
+SELECT CDB_CartodbfyTableCheck('t', 'text the_geom column, no srs');
+SELECT cartodb_id FROM t;
+DROP TABLE t;
+
+-- table with text geometry column, unusual SRS
+CREATE TABLE t AS SELECT 'SRID=26910;POINT(1 1)'::text AS the_geom, 1::int4 as cartodb_id;
+SELECT CDB_CartodbfyTableCheck('t', 'text the_geom column, srs = 26819');
+SELECT cartodb_id FROM t;
+DROP TABLE t;
+
+-- table with text unparseable geometry column
+CREATE TABLE t AS SELECT 'SRID=26910;PONT(1 1)'::text AS the_geom, 1::int4 as cartodb_id;
+SELECT CDB_CartodbfyTableCheck('t', 'text the_geom column, unparseable content');
+SELECT cartodb_id FROM t;
 DROP TABLE t;

 -- table with existing cartodb_id serial primary key
@@ -208,21 +227,150 @@ WHERE c.conrelid = 't'::regclass and a.attrelid = c.conrelid
 AND c.conkey[1] = a.attnum AND NOT a.attisdropped;
 DROP TABLE t;

-- table with existing the_geom and created_at and containing null values
-- Really, a test for surviving an longstanding PostgreSQL bug:
-- http://www.postgresql.org/message-id/20140530143150.GA11051@localhost
-CREATE TABLE t (
-    the_geom geometry(Geometry,4326),
-    created_at timestamptz,
-    updated_at timestamptz
+-- tables can be renamed and there's no index name clashing #123
+CREATE TABLE original();
+SELECT CDB_CartodbfyTable('original');
+ALTER TABLE original RENAME TO original_renamed;
+CREATE TABLE original();
+SELECT CDB_CartodbfyTable('original');
+DROP TABLE original_renamed;
+DROP TABLE original;
+
+-- Table always have a default seq value after cartodbfy #138
+CREATE TABLE bug_empty_table_no_seq (
+  cartodb_id integer,
+  the_geom geometry(Geometry,4326),
+  the_geom_webmercator geometry(Geometry,3857),
+  name text,
+  description text
 );
-COPY t (the_geom, created_at, updated_at) FROM stdin;
-0106000020E610000001000000010300000001000000050000009EB8244146435BC017B65E062AD343409EB8244146435BC0F51AF6E2708044400B99891683765AC0F51AF6E2708044400B99891683765AC017B65E062AD343409EB8244146435BC017B65E062AD34340	2012-06-06 21:59:08	2013-06-10 20:17:20
-0106000020E61000000100000001030000000100000005000000DA7763431A1A5CC0FBCEE869313C3A40DA7763431A1A5CC09C1B8F55BC494440F9F4A9C7993356C09C1B8F55BC494440F9F4A9C7993356C0FBCEE869313C3A40DA7763431A1A5CC0FBCEE869313C3A40	2012-06-06 21:59:08	2013-06-10 20:17:20
-\N	\N	\N
-\.
-SELECT CDB_CartodbfyTableCheck('t', 'null geom and timestamp values');
-DROP TABLE t;
+SELECT CDB_CartodbfyTableCheck('bug_empty_table_no_seq', 'Table always have a default seq value after cartodbfy #138');
+INSERT INTO bug_empty_table_no_seq DEFAULT VALUES;
+DROP TABLE bug_empty_table_no_seq;
+
+-- Existing cartodb_id values are respected
+CREATE table existing_cartodb_id (
+  cartodb_id integer,
+  the_geom geometry(Geometry,4326),
+  the_geom_webmercator geometry(Geometry,3857),
+  name text,
+  description text
+);
+INSERT INTO existing_cartodb_id (cartodb_id, description) VALUES
+       (10, 'a'),
+       (20, 'b'),
+       (30, 'c');
+SELECT CDB_CartodbfyTableCheck('existing_cartodb_id', 'Existing cartodb_id values are respected #138');
+SELECT cartodb_id,the_geom,the_geom_webmercator,description,name from existing_cartodb_id;
+DROP TABLE existing_cartodb_id;
+
+-- Table with both the_geom and wkb_geometry
+CREATE TABLE many_geometry_columns (
+       the_geom geometry,
+       wkb_geometry geometry(MultiPoint,4326),
+       description varchar
+);
+INSERT INTO many_geometry_columns (the_geom, wkb_geometry) VALUES
+       ('0104000020E61000000100000001010000007108B023698052C03CEEA53A2E5D4440', '0104000020E61000000100000001010000007108B023698052C03CEEA53A2E5D4440'),
+       ('0104000020E6100000010000000101000000864C9E57618052C0994F0C7F3C5B4440', '0104000020E6100000010000000101000000864C9E57618052C0994F0C7F3C5B4440');
+SELECT CDB_CartodbfyTableCheck('many_geometry_columns', 'Table with both the_geom and wkb_geometry #141');
+SELECT * FROM many_geometry_columns;
+DROP TABLE many_geometry_columns;
+
+-- Many colliding geom columns
+CREATE TABLE many_colliding_columns (
+  the_geom varchar,
+  the_geom_webmercator varchar,
+  my_geom geometry,
+  my_mercgeom geometry(Point, 3857),
+  cartodb_id varchar,
+  my_pk integer primary key
+);
+INSERT INTO many_colliding_columns VALUES (
+ 'foo', 'bar', 'SRID=4326;POINT(0 0)', 'SRID=3857;POINT(0 0)', 'nerf', 1
+);
+SELECT CDB_CartodbfyTableCheck('many_colliding_columns', 'Many colliding columns #141');
+DROP TABLE many_colliding_columns;
+
+-- Table with null cartodb_id
+CREATE TABLE test (
+  cartodb_id integer
+);
+INSERT INTO test VALUES
+  (1),
+  (2),
+  (NULL),
+  (3);
+SELECT CDB_CartodbfyTableCheck('test', 'Table with null cartodb_id #148');
+SELECT cartodb_id from test;
+DROP TABLE test;
+
+-- Table with non unique cartodb_id
+CREATE TABLE test (
+  cartodb_id integer
+);
+INSERT INTO test VALUES
+  (1),
+  (2),
+  (2);
+SELECT CDB_CartodbfyTableCheck('test', 'Table with non unique cartodb_id #148');
+SELECT cartodb_id from test;
+DROP TABLE test;
+
+-- Table with non unique and null cartodb_id
+CREATE TABLE test (
+  cartodb_id integer
+);
+INSERT INTO test VALUES
+  (1),
+  (2),
+  (NULL),
+  (2);
+SELECT CDB_CartodbfyTableCheck('test', 'Table with non unique and null cartodb_id #148');
+SELECT cartodb_id from test;
+DROP TABLE test;
+
+CREATE TABLE test (
+  cartodb_id integer
+);
+CREATE UNIQUE INDEX "test_cartodb_id_key" ON test (cartodb_id);
+CREATE UNIQUE INDEX "test_cartodb_id_pkey" ON test (cartodb_id);
+ALTER TABLE test ADD CONSTRAINT "test_pkey" PRIMARY KEY USING INDEX test_cartodb_id_pkey;
+INSERT INTO test VALUES
+  (1),
+  (2),
+  (3);
+SELECT CDB_CartodbfyTableCheck('test', 'Table with primary key and unique index on it #174');
+SELECT cartodb_id from test;
+DROP TABLE test;
+
+CREATE TABLE test (
+  name varchar,
+  "first.value" integer,
+  "second.value" integer
+);
+INSERT INTO test VALUES ('one', 1, 2), ('two', 3, 4);
+SELECT CDB_CartodbfyTableCheck('test', 'Table with dots in name columns (cartodb #6114)');
+SELECT name, "first.value" from test;
+DROP TABLE test;
+
+SET client_min_messages TO notice;
+-- _CDB_create_cartodb_id_column with cartodb_id integer already present
+CREATE TABLE test (cartodb_id integer);
+
+SELECT _CDB_Create_Cartodb_ID_Column('test'::regclass);
+SELECT column_name FROM information_schema.columns WHERE table_name = 'test' AND column_name = '_cartodb_id0';
+
+DROP TABLE test;
+
+-- _CDB_create_cartodb_id_column with cartodb_id text already present
+CREATE TABLE test (cartodb_id text);
+
+SELECT _CDB_Create_Cartodb_ID_Column('test'::regclass);
+SELECT column_name FROM information_schema.columns WHERE table_name = 'test' AND column_name = '_cartodb_id0';
+
+DROP TABLE test;
+SET client_min_messages TO error;

 -- TODO: table with existing custom-triggered the_geom

--- a/test/CDB_CartodbfyTableTest_expect
+++ b/test/CDB_CartodbfyTableTest_expect
@@ -2,12 +2,16 @@ SET
 CREATE FUNCTION
 SELECT 1
 ERROR:  Please set user quota before cartodbfying tables.
-CONTEXT:  SQL statement "SELECT cartodb._CDB_check_prerequisites(schema_name, reloid)"
-PL/pgSQL function cdb_cartodbfytable(text,regclass) line 6 at PERFORM
 0
 single non-geometrical column cartodbfied fine
 DROP TABLE
 SELECT 1
+check function idempotence cartodbfied fine
+1|0101000020E6100000000000000000F0BF000000000000F0BF|0101000020110F0000DB0B4ADA772DFBC077432E49D22DFBC0|this is a sentence
+check function idempotence cartodbfied fine
+1|0101000020E6100000000000000000F0BF000000000000F0BF|0101000020110F0000DB0B4ADA772DFBC077432E49D22DFBC0|this is a sentence
+DROP TABLE
+SELECT 1
 srid-unconstrained the_geom cartodbfied fine
 DROP TABLE
 SELECT 2
@@ -28,30 +32,120 @@ trigger-protected the_geom cartodbfied fine
 extent|BOX(1 1,2 2)
 DROP TABLE
 SELECT 1
-text timestamps cartodbfied fine
-0|0
-CREATE VIEW
-cartodbfied with view cartodbfied fine
-DROP VIEW
-DROP TABLE
-SELECT 1
 text cartodb_id cartodbfied fine
 5
 DROP TABLE
 SELECT 1
-uncasting text cartodb_id cartodbfied fine
-1|nan
+ERROR:  CDB(_CDB_Has_Usable_Primary_ID: Error: invalid cartodb_id, cartodb_id): ALTER TABLE t ADD CONSTRAINT cartodb_id_pk PRIMARY KEY (cartodb_id), ADD CONSTRAINT cartodb_id_integer CHECK (cartodb_id::integer >=0);
+DROP TABLE
+SELECT 1
+ERROR:  CDB(_CDB_Has_Usable_Primary_ID: Error: invalid cartodb_id, cartodb_id): ALTER TABLE t ADD CONSTRAINT cartodb_id_pk PRIMARY KEY (cartodb_id), ADD CONSTRAINT cartodb_id_integer CHECK (cartodb_id::integer >=0);
+
 DROP TABLE
 SELECT 1
 unsequenced cartodb_id cartodbfied fine
 1
 DROP TABLE
+SELECT 1
+text the_geom column cartodbfied fine
+1
+DROP TABLE
+SELECT 1
+text the_geom column, no srs cartodbfied fine
+1
+DROP TABLE
+SELECT 1
+text the_geom column, srs = 26819 cartodbfied fine
+1
+DROP TABLE
+SELECT 1
+text the_geom column, unparseable content cartodbfied fine
+1
+DROP TABLE
 CREATE TABLE
 cartodb_id serial primary key cartodbfied fine
 t_pkey|cartodb_id
 DROP TABLE
 CREATE TABLE
-null geom and timestamp values cartodbfied fine
+original
+ALTER TABLE
+CREATE TABLE
+original
 DROP TABLE
+DROP TABLE
+CREATE TABLE
+Table always have a default seq value after cartodbfy #138 cartodbfied fine
+INSERT 0 1
+DROP TABLE
+CREATE TABLE
+INSERT 0 3
+Existing cartodb_id values are respected #138 cartodbfied fine
+10|||a|
+20|||b|
+30|||c|
+DROP TABLE
+CREATE TABLE
+INSERT 0 2
+Table with both the_geom and wkb_geometry #141 cartodbfied fine
+1|0104000020E61000000100000001010000007108B023698052C03CEEA53A2E5D4440|0104000020110F00000100000001010000004A9F662B456D5FC11392690DC3F75241|
+2|0104000020E6100000010000000101000000864C9E57618052C0994F0C7F3C5B4440|0104000020110F00000100000001010000002858E0EC376D5FC1CAE8DB4B95F55241|
+DROP TABLE
+CREATE TABLE
+INSERT 0 1
+ERROR:  CDB(_CDB_Has_Usable_Primary_ID: multiple primary keys for table "many_colliding_columns" are not allowed): ALTER TABLE many_colliding_columns ADD CONSTRAINT cartodb_id_pk PRIMARY KEY (cartodb_id), ADD CONSTRAINT cartodb_id_integer CHECK (cartodb_id::integer >=0);
+DROP TABLE
+CREATE TABLE
+INSERT 0 4
+ERROR:  CDB(_CDB_Has_Usable_Primary_ID: Error: invalid cartodb_id, cartodb_id): ALTER TABLE test ADD CONSTRAINT cartodb_id_pk PRIMARY KEY (cartodb_id), ADD CONSTRAINT cartodb_id_integer CHECK (cartodb_id::integer >=0);
+1
+2
+
+3
+DROP TABLE
+CREATE TABLE
+INSERT 0 3
+ERROR:  CDB(_CDB_Has_Usable_Primary_ID: Error: invalid cartodb_id, cartodb_id): ALTER TABLE test ADD CONSTRAINT cartodb_id_pk PRIMARY KEY (cartodb_id), ADD CONSTRAINT cartodb_id_integer CHECK (cartodb_id::integer >=0);
+1
+2
+2
+DROP TABLE
+CREATE TABLE
+INSERT 0 4
+ERROR:  CDB(_CDB_Has_Usable_Primary_ID: Error: invalid cartodb_id, cartodb_id): ALTER TABLE test ADD CONSTRAINT cartodb_id_pk PRIMARY KEY (cartodb_id), ADD CONSTRAINT cartodb_id_integer CHECK (cartodb_id::integer >=0);
+1
+2
+
+2
+DROP TABLE
+CREATE TABLE
+CREATE INDEX
+CREATE INDEX
+ALTER TABLE
+INSERT 0 3
+Table with primary key and unique index on it #174 cartodbfied fine
+1
+2
+3
+DROP TABLE
+CREATE TABLE
+INSERT 0 2
+Table with dots in name columns (cartodb #6114) cartodbfied fine
+one|1
+two|3
+DROP TABLE
+SET
+CREATE TABLE
+NOTICE:  Column cartodb_id already exists
+NOTICE:  Existing cartodb_id field does not have an associated sequence, renaming
+NOTICE:  Trying to recover data from _cartodb_id0 column
+
+DROP TABLE
+CREATE TABLE
+NOTICE:  Column cartodb_id already exists
+NOTICE:  Existing cartodb_id field is of invalid type text (need int2, int4 or int8), renaming
+NOTICE:  Trying to recover data from _cartodb_id0 column
+
+DROP TABLE
+SET
 DROP FUNCTION
 DROP FUNCTION
--- a/test/CDB_DateToNumberTest.sql
+++ b/test/CDB_DateToNumberTest.sql
@@ -0,0 +1,2 @@
+SELECT * FROM CDB_DateToNumber('1999-01-08 00:00:00'::timestamp);
+SELECT * FROM CDB_DateToNumber('1999-01-08 00:00:00+05'::timestamp with time zone);
--- a/test/CDB_DateToNumberTest_expect
+++ b/test/CDB_DateToNumberTest_expect
@@ -0,0 +1,2 @@
+915753600
+915735600
--- a/test/CDB_DistTypeTest.sql
+++ b/test/CDB_DistTypeTest.sql
@@ -0,0 +1,4 @@
+WITH data AS (
+    SELECT pow(x,3)::numeric x FROM generate_series(-100,100) x
+    ) 
+SELECT CDB_DistType(array_agg(x)) FROM data
--- a/test/CDB_DistTypeTest_expect
+++ b/test/CDB_DistTypeTest_expect
@@ -0,0 +1 @@
+A
--- a/test/CDB_DistinctMeasureTest.sql
+++ b/test/CDB_DistinctMeasureTest.sql
@@ -0,0 +1,20 @@
+-- a - j add up to 89%, k-m add up to 11%
+WITH a As (
+	SELECT (
+		repeat('a',12) || 
+		repeat('b',11) || 
+		repeat('c',11) || 
+		repeat('d',10) || 
+		repeat('e',10) || 
+		repeat('f',9) || 
+		repeat('g',8) || 
+		repeat('h',7) || 
+		repeat('i',6) || 
+		repeat('j',5) || 
+		repeat('k',4) || 
+		repeat('l',4) || 
+		repeat('m',3)
+		)::text AS x 
+	) 
+
+SELECT CDB_DistinctMeasure(string_to_array(x,null),0.90) from a
--- a/test/CDB_DistinctMeasureTest_expect
+++ b/test/CDB_DistinctMeasureTest_expect
@@ -0,0 +1 @@
+0
--- a/test/CDB_EqualIntervalBinsTest.sql
+++ b/test/CDB_EqualIntervalBinsTest.sql
@@ -0,0 +1,5 @@
+WITH data AS (
+    SELECT array_agg(x::numeric) s FROM generate_series(1,300) x 
+        WHERE x % 5 != 0 AND x % 7 != 0
+    ) 
+SELECT round(unnest(CDB_EqualIntervalBins(s, 7)),7) FROM data
--- a/test/CDB_EqualIntervalBinsTest_expect
+++ b/test/CDB_EqualIntervalBinsTest_expect
@@ -0,0 +1,7 @@
+43.5714286
+86.1428571
+128.7142857
+171.2857143
+213.8571429
+256.4285714
+299.0000000
--- a/test/CDB_GreatCircle.sql
+++ b/test/CDB_GreatCircle.sql
@@ -0,0 +1,2 @@
+select ST_AsText(CDB_GreatCircle(CDB_LatLng(55.8580,4.2590), CDB_LatLng(40.7127,74.0059)));
+select ST_AsText(CDB_GreatCircle(CDB_LatLng(55.8580,4.2590), CDB_LatLng(40.7127,74.0059), 50000));
--- a/test/CDB_GreatCircle_expect
+++ b/test/CDB_GreatCircle_expect
@@ -0,0 +1,2 @@
+LINESTRING(4.259 55.858,5.6692453115051 56.0150275120673,7.10720375678704 56.157400475677,8.5718366560563 56.2842986378254,10.0619272412891 56.3949153508462,11.5760785994189 56.4884642014437,13.1127142001617 56.564185934303,14.6700812655504 56.6213555706215,16.2462571744128 56.6592896061102,17.8391590143095 56.6773531596105,19.4465562981665 56.6749669334121,21.0660867567155 56.6516138405427,22.6952750058883 56.6068451534252,24.3315537765309 56.540286032869,25.9722872888145 56.4516403065472,27.6147962622065 56.3406943817481,29.2563839799455 56.207320197769,30.8943627796619 56.0514771479657,32.5260803224591 55.8732129290618,34.1489450028345 55.6726633044968,35.7604499005266 55.4500507979281,37.3581947399686 55.2056823610616,38.9399054089486 54.9399460854786,40.5034506895044 54.6533070499613,42.0468559644411 54.3463024122038,43.5683137754523 54.0195358662507,45.066191217402 53.673671594382,46.5390342525062 53.3094278446298,47.9855691138079 52.9275702630659,49.4047010366934 52.5289051040742,50.7955106088955 52.1142724327331,52.1572480633875 51.6845394219955,53.4893258557794 51.2405938343407,54.7913098701049 50.7833377637432,56.0629095865715 50.3136816997865,57.3039675245588 49.8325389621027,58.5144482465496 49.3408205404538,59.6944271762829 48.8394303639846,60.8440794494795 48.329261012675,61.9636689799149 47.811189874886,63.0535378889196 47.2860757471582,64.1140964137264 46.7547558660385,65.1458133802427 46.2180433565989,66.1492072992903 45.676725078361,67.1248381223566 45.131559846414,68.0732996734468 44.583277003498,68.9952127576034 44.0325753175597,69.8912189338183 43.4801221786776,70.7619749300985 42.9265530691612,71.6081476710291 42.3724712809595,72.4304098829428 41.8184478551838,73.2294362384225 41.2650217194684,74.0059 40.7127)
+LINESTRING(4.259 55.858,4.96060044865294 55.9382939511593,5.6692453115051 56.0150275120673,6.38482117645567 56.0880973218335,7.10720375678705 56.157400475677,7.83625773770865 56.2228347173136,8.5718366560563 56.2842986378254,9.31378281572326 56.3416918804739,10.0619272412891 56.3949153508462,10.8160896721679 56.4438714316548,11.5760785994189 56.4884642014437,12.3416913471456 56.528599656387,13.1127142001617 56.5641859343031,13.8889225793161 56.5951335399513,14.6700812655504 56.6213555706215,15.4559446734179 56.6427679409819,16.2462571744128 56.6592896061102,17.0407534700619 56.6708427815999,17.8391590143095 56.6773531596105,18.6411904842936 56.6787501197174,19.4465562981665 56.6749669334121,20.2549571781681 56.6659409611101,21.0660867567155 56.6516138405428,21.8796322228404 56.6319316654367,22.6952750058883 56.6068451534252,23.5126914929996 56.5763098021872,24.3315537765309 56.5402860328691,25.1515304272452 56.4987393199198,25.9722872888145 56.4516403065472,26.7934882889404 56.3989649050969,27.6147962622065 56.3406943817482,28.4358737796488 56.2768154250305,29.2563839799456 56.207320197769,30.0759913971174 56.1322063721813,30.8943627796619 56.0514771479657,31.7111678961496 55.9651412533344,32.5260803224592 55.8732129290618,33.3387782060384 55.7757118957345,34.1489450028345 55.6726633044969,34.9562701828379 55.5640976716962,35.7604499005266 55.4500507979282,36.5611876268714 55.3305636720814,37.3581947399687 55.2056823610617,38.1511910717861 55.0754578859583,38.9399054089486 54.9399460854787,39.7240759459355 54.7992074675415,40.5034506895044 54.6533070499613,41.277787813601 54.5023141912026,42.0468559644411 54.3463024122039,42.8104345158644 54.1853492102971,43.5683137754524 54.0195358662508,44.3202951422663 53.8489472454711,45.066191217402 53.6736715943821,45.8058258688602 53.4938003329924,46.5390342525062 53.3094278446299,47.2656627911282 53.1206512637978,47.985569113808 52.9275702630661,48.6986219579803 52.7302868398744,49.4047010366934 52.5289051040743,50.1036968736777 52.3235310669909,50.7955106088955 52.1142724327332,51.4800537772815 51.9012383924278,52.1572480633875 51.6845394219956,52.8270250346284 51.4642870840378,53.4893258557795 51.2405938343408,54.1441009873167 51.0135728334539,54.791309870105 50.7833377637434,55.4309205988438 50.5500026522693,56.0629095865715 50.3136816997866,56.6872612224038 50.0744891161178,57.3039675245588 49.8325389621028,57.9130277905821 49.5879449982851,58.5144482465496 49.3408205404539,59.1082416968843 49.091278322122,59.6944271762829 48.8394303639847,60.2730296051101 48.5853878503721,60.8440794494795 48.3292610126751,61.40761238711 48.0711590197009,61.9636689799149 47.8111898748862,62.5122943541616 47.5494603202768,63.0535378889195 47.2860757471584,63.5874529134047 47.0211401132109,64.1140964137264 46.7547558660387,64.6335287494427 46.4870238729191,65.1458133802426 46.2180433565991,65.6510166029904 45.9479118369597,66.1492072992903 45.6767250783612,66.6404566936622 45.4045770424768,67.1248381223566 45.1315598464143,67.6024268127789 44.8577637259253,68.0732996734467 44.5832770034983,68.5375350943572 44.3081860611283,68.9952127576034 44.0325753175599,69.4464134580461 43.7565272097974,69.8912189338183 43.4801221786779,70.3297117064144 43.2034386583077,70.7619749300985 42.9265530691615,71.1880922503468 42.6495398146493,71.6081476710291 42.3724712809597,72.0222254300221 42.0954178399905,72.4304098829428 41.8184478551841,72.8327853946822 41.5416276900883,73.2294362384225 41.2650217194687,73.6204465018146 40.9886923428039,74.0059 40.7127)
--- a/test/CDB_HelperTest.sql
+++ b/test/CDB_HelperTest.sql
@@ -0,0 +1,128 @@
+-- Test unique identifier creation with normal length normal relname
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'relname', NULL);
+
+-- Test unique identifier creation with prefix with normal length normal relname
+SELECT * FROM cartodb._CDB_Unique_Identifier('prefix_', 'relname', NULL);
+
+-- Test unique identifier creation with suffix with normal length normal relname
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'relname', '_suffix');
+
+-- Test unique identifier creation with long length normal relname
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'largolargolargolargolargolargolargolargolargolargolargolargolar', NULL);
+
+-- Test unique identifier creation with prefix with long length normal relname
+SELECT * FROM cartodb._CDB_Unique_Identifier('prefix_', 'largolargolargolargolargolargolargolargolargolargolargolargolar', NULL);
+
+-- Test new identifier is found when name is taken from previous case
+CREATE TABLE prefix_largolargolargolargolargolargolargolargolargolargolar (name text);
+SELECT * FROM cartodb._CDB_Unique_Identifier('prefix_', 'largolargolargolargolargolargolargolargolargolargolargolargolar', NULL);
+DROP TABLE prefix_largolargolargolargolargolargolargolargolargolargolar;
+
+-- Test unique identifier creation with suffix with long length normal relname
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'largolargolargolargolargolargolargolargolargolargolargolargolar', '_suffix');
+
+-- Test new identifier is found when name is taken from previous case
+CREATE TABLE largolargolargolargolargolargolargolargolargolargolar_suffix (name text);
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'largolargolargolargolargolargolargolargolargolargolargolargolar', '_suffix');
+DROP TABLE largolargolargolargolargolargolargolargolargolargolar_suffix;
+
+-- Test unique identifier creation with normal length UTF8 relname
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'piraña', NULL);
+
+-- Test unique identifier creation with prefix with normal length UTF8 relname
+SELECT * FROM cartodb._CDB_Unique_Identifier('prefix_', 'piraña', NULL);
+
+-- Test unique identifier creation with suffix with normal length UTF8 relname
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'piraña', '_suffix');
+
+-- Test unique identifier creation with long length UTF8 relname
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', NULL);
+
+-- Test unique identifier creation with prefix with long length UTF8 relname
+SELECT * FROM cartodb._CDB_Unique_Identifier('prefix_', 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', NULL);
+
+-- Test new identifier is found when name is taken from previous case
+CREATE TABLE prefix_piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi (name text);
+SELECT * FROM cartodb._CDB_Unique_Identifier('prefix_', 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', NULL);
+DROP TABLE prefix_piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi;
+
+-- Test unique identifier creation with suffix with long length UTF8 relname
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', '_suffix');
+
+-- Test new identifier is found when name is taken from previous case
+CREATE TABLE piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi_suffix (name text);
+SELECT * FROM cartodb._CDB_Unique_Identifier(NULL, 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', '_suffix');
+DROP TABLE piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi_suffix;
+
+CREATE TABLE test (name text);
+-- Test unique identifier creation with normal length normal colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'colname', NULL, 'test'::regclass);
+
+-- Test unique identifier creation with prefix with normal length normal colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier('prefix_', 'colname', NULL, 'test'::regclass);
+
+-- Test unique identifier creation with suffix with normal length normal colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'colname', '_suffix', 'test'::regclass);
+
+-- Test unique identifier creation with long length normal colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'largolargolargolargolargolargolargolargolargolargolargolargolar', NULL, 'test'::regclass);
+
+-- Test unique identifier creation with prefix with long length normal colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier('prefix_', 'largolargolargolargolargolargolargolargolargolargolargolargolar', NULL, 'test'::regclass);
+DROP TABLE test;
+
+-- Test new identifier is found when name is taken from previous case
+CREATE TABLE test (prefix_largolargolargolargolargolargolargolargolargolargolar text);
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier('prefix_', 'largolargolargolargolargolargolargolargolargolargolargolargolar', NULL, 'test'::regclass);
+DROP TABLE test;
+
+-- Test unique identifier creation with suffix with long length normal colname
+CREATE TABLE test (name text);
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'largolargolargolargolargolargolargolargolargolargolargolargolar', '_suffix', 'test'::regclass);
+DROP TABLE test;
+
+-- Test new identifier is found when name is taken from previous case
+CREATE TABLE test (largolargolargolargolargolargolargolargolargolargolar_suffix text);
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'largolargolargolargolargolargolargolargolargolargolargolargolar', '_suffix', 'test'::regclass);
+DROP TABLE test;
+
+CREATE TABLE test (name text);
+-- Test unique identifier creation with normal length UTF8 colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'piraña', NULL, 'test'::regclass);
+
+-- Test unique identifier creation with prefix with normal length UTF8 colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier('prefix_', 'piraña', NULL, 'test'::regclass);
+
+-- Test unique identifier creation with suffix with normal length UTF8 colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'piraña', '_suffix', 'test'::regclass);
+
+-- Test unique identifier creation with long length UTF8 colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', NULL, 'test'::regclass);
+
+-- Test unique identifier creation with prefix with long length UTF8 colname
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier('prefix_', 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', NULL, 'test'::regclass);
+DROP TABLE test;
+
+-- Test new identifier is found when name is taken from previous case
+CREATE TABLE test (prefix_piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi text);
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier('prefix_', 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', NULL, 'test'::regclass);
+DROP TABLE test;
+
+-- Test unique identifier creation with suffix with long length UTF8 colname
+CREATE TABLE test (name text);
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', '_suffix', 'test'::regclass);
+DROP TABLE test;
+
+-- Test new identifier is found when name is taken from previous case
+CREATE TABLE test (piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi_suffix text);
+SELECT * FROM cartodb._CDB_Unique_Column_Identifier(NULL, 'piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácidpin', '_suffix', 'test'::regclass);
+DROP TABLE test;
+
+-- Test _CDB_Octet_Truncate simple case
+SELECT * FROM cartodb._CDB_Octet_Truncate('piraña', 5);
+
+-- Test _CDB_Octet_Truncate UTF8 case
+SELECT * FROM cartodb._CDB_Octet_Truncate('piraña', 6);
+
+-- Test _CDB_Octet_Truncate UTF8 case
+SELECT * FROM cartodb._CDB_Octet_Truncate('piraña', 7);
--- a/test/CDB_HelperTest_expect
+++ b/test/CDB_HelperTest_expect
@@ -0,0 +1,59 @@
+relname
+prefix_relname
+relname_suffix
+largolargolargolargolargolargolargolargolargolargolargolargo
+prefix_largolargolargolargolargolargolargolargolargolargolar
+CREATE TABLE
+prefix_largolargolargolargolargolargolargolargolargolargolar_0
+DROP TABLE
+largolargolargolargolargolargolargolargolargolargolar_suffix
+CREATE TABLE
+largolargolargolargolargolargolargolargolargolargolar_suffix_0
+DROP TABLE
+piraña
+prefix_piraña
+piraña_suffix
+piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácid
+prefix_piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi
+CREATE TABLE
+prefix_piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi_0
+DROP TABLE
+piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi_suffix
+CREATE TABLE
+piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi_suffix_0
+DROP TABLE
+CREATE TABLE
+colname
+prefix_colname
+colname_suffix
+largolargolargolargolargolargolargolargolargolargolargolargo
+prefix_largolargolargolargolargolargolargolargolargolargolar
+DROP TABLE
+CREATE TABLE
+prefix_largolargolargolargolargolargolargolargolargolargolar_0
+DROP TABLE
+CREATE TABLE
+largolargolargolargolargolargolargolargolargolargolar_suffix
+DROP TABLE
+CREATE TABLE
+largolargolargolargolargolargolargolargolargolargolar_suffix_0
+DROP TABLE
+CREATE TABLE
+piraña
+prefix_piraña
+piraña_suffix
+piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpiñaácid
+prefix_piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi
+DROP TABLE
+CREATE TABLE
+prefix_piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi_0
+DROP TABLE
+CREATE TABLE
+piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi_suffix
+DROP TABLE
+CREATE TABLE
+piñaácidpiñaácidpiñaácidpiñaácidpiñaácidpi_suffix_0
+DROP TABLE
+pira
+pirañ
+piraña
--- a/test/CDB_MathTest.sql
+++ b/test/CDB_MathTest.sql
@@ -0,0 +1,4 @@
+
+SELECT cdb_math_mode(a) from unnest(ARRAY[1,2,2,3]) a;
+SELECT cdb_math_mode(a) from unnest(ARRAY[1,2,3]) a;
+SELECT cdb_math_mode(a) from unnest(ARRAY[1]) a;
--- a/test/CDB_MathTest_expect
+++ b/test/CDB_MathTest_expect
@@ -0,0 +1,3 @@
+2
+1
+1
--- a/test/CDB_OverviewsTest.sql
+++ b/test/CDB_OverviewsTest.sql
@@ -0,0 +1,43 @@
+SET client_min_messages TO error;
+\set VERBOSITY default
+
+\i test/overviews/fixtures.sql
+
+SELECT _CDB_Aggregable_Attributes_Expression('base_bare_t'::regclass);
+SELECT _CDB_Aggregated_Attributes_Expression('base_bare_t'::regclass);
+SELECT _CDB_Aggregated_Attributes_Expression('base_bare_t'::regclass, 'tab');
+
+SELECT CDB_CreateOverviews('base_bare_t'::regclass);
+SELECT count(*) FROM _vovw_2_base_bare_t;
+
+
+SELECT _CDB_Aggregable_Attributes_Expression('base_t'::regclass);
+SELECT _CDB_Aggregated_Attributes_Expression('base_t'::regclass);
+SELECT _CDB_Aggregated_Attributes_Expression('base_t'::regclass, 'tab');
+
+SELECT CDB_CreateOverviews('base_t'::regclass);
+SELECT count(*) FROM _vovw_2_base_t;
+
+SELECT CDB_CreateOverviews('polyg_t'::regclass);
+
+SELECT CDB_CreateOverviews('column_types_t'::regclass);
+
+SELECT CDB_Overviews('base_t'::regclass);
+SELECT CDB_Overviews('"public"."base_t"'::regclass);
+SELECT CDB_Overviews(ARRAY['base_t'::regclass, 'base_bare_t'::regclass]);
+SELECT CDB_Overviews('polyg_t'::regclass);
+SELECT CDB_Overviews('column_types_t'::regclass);
+
+SELECT CDB_DropOverviews('column_types_t'::regclass);
+SELECT CDB_DropOverviews('base_bare_t'::regclass);
+SELECT CDB_DropOverviews('base_t'::regclass);
+SELECT count(*) FROM _vovw_2_base_t;
+
+SELECT CDB_CreateOverviewsWithToleranceInPixels('base_t'::regclass, 7.5);
+SELECT count(*) FROM _vovw_2_base_t;
+SELECT CDB_DropOverviews('base_t'::regclass);
+
+DROP TABLE column_types_t;
+DROP TABLE base_bare_t;
+DROP TABLE base_t;
+DROP TABLE polyg_t;
--- a/test/CDB_OverviewsTest_expect
+++ b/test/CDB_OverviewsTest_expect
@@ -0,0 +1,48 @@
+SET
+CREATE TABLE
+INSERT 0 1114
+CREATE TABLE
+INSERT 0 1114
+CREATE TABLE
+INSERT 0 5
+SELECT 1114
+
+
+
+{_vovw_2_base_bare_t,_vovw_1_base_bare_t,_vovw_0_base_bare_t}
+126
+number,int_number,name,start
+SUM(number*1)/count(*)::double precision AS number,SUM(int_number*1)/count(*)::integer AS int_number,CASE WHEN count(distinct name) = 1 THEN MIN(name) WHEN count(*) < 5 THEN string_agg(distinct name,' / ') ELSE '*' END::text AS name,CASE count(*) WHEN 1 THEN MIN(start) ELSE NULL END::date AS start
+SUM(tab.number*1)/count(*)::double precision AS number,SUM(tab.int_number*1)/count(*)::integer AS int_number,CASE WHEN count(distinct tab.name) = 1 THEN MIN(tab.name) WHEN count(*) < 5 THEN string_agg(distinct tab.name,' / ') ELSE '*' END::text AS name,CASE count(*) WHEN 1 THEN MIN(tab.start) ELSE NULL END::date AS start
+{_vovw_2_base_t,_vovw_1_base_t,_vovw_0_base_t}
+126
+
+{_vovw_2_column_types_t,_vovw_1_column_types_t,_vovw_0_column_types_t}
+(base_t,0,_vovw_0_base_t)
+(base_t,1,_vovw_1_base_t)
+(base_t,2,_vovw_2_base_t)
+(base_t,0,_vovw_0_base_t)
+(base_t,1,_vovw_1_base_t)
+(base_t,2,_vovw_2_base_t)
+(base_bare_t,0,_vovw_0_base_bare_t)
+(base_bare_t,1,_vovw_1_base_bare_t)
+(base_bare_t,2,_vovw_2_base_bare_t)
+(base_t,0,_vovw_0_base_t)
+(base_t,1,_vovw_1_base_t)
+(base_t,2,_vovw_2_base_t)
+(column_types_t,0,_vovw_0_column_types_t)
+(column_types_t,1,_vovw_1_column_types_t)
+(column_types_t,2,_vovw_2_column_types_t)
+
+
+
+ERROR:  relation "_vovw_2_base_t" does not exist
+LINE 1: SELECT count(*) FROM _vovw_2_base_t;
+                             ^
+{_vovw_5_base_t,_vovw_4_base_t,_vovw_3_base_t,_vovw_2_base_t,_vovw_1_base_t,_vovw_0_base_t}
+38
+
+DROP TABLE
+DROP TABLE
+DROP TABLE
+DROP TABLE
--- a/test/CDB_QuantileBinsTest_expect
+++ b/test/CDB_QuantileBinsTest_expect
@@ -1,7 +1,7 @@
-16
+13
 29
 43
 57
 71
-83
+86
 99
--- a/test/CDB_QueryTablesTest.sql
+++ b/test/CDB_QueryTablesTest.sql
@@ -31,3 +31,9 @@ create table sc.test (a int);
 insert into sc.test values (1);
 WITH inp AS ( select 'select * from sc.test'::text as q )
 SELECT q, CDB_QueryTables(q) from inp;
+DROP TABLE sc.test;
+DROP SCHEMA sc;
+
+WITH inp AS ( select 'SELECT
+* FROM geometry_columns'::text as q )
+ SELECT q, CDB_QueryTables(q) from inp;
--- a/test/CDB_QueryTablesTest_expect
+++ b/test/CDB_QueryTablesTest_expect
@@ -1,15 +1,23 @@
-SELECT * FROM geometry_columns|{pg_catalog.pg_attribute,pg_catalog.pg_class,pg_catalog.pg_namespace,pg_catalog.pg_type}
+SELECT * FROM geometry_columns|{pg_catalog.pg_attribute,pg_catalog.pg_class,pg_catalog.pg_constraint,pg_catalog.pg_namespace,pg_catalog.pg_type}
 SELECT a.attname FROM pg_class c JOIN pg_attribute a on (a.attrelid = c.oid)|{pg_catalog.pg_attribute,pg_catalog.pg_class}
 CREATE table "my'tab;le" as select 1|{}
 SELECT a.oid, b.oid FROM pg_class a, pg_class b|{pg_catalog.pg_class}
 SELECT 1 as col1; select 2 as col2|{}
 WARNING:  CDB_QueryTables cannot explain query: select 1 from nonexistant (42P01: relation "nonexistant" does not exist)
+CONTEXT:  PL/pgSQL function cdb_querytables(text) line 3 at RETURN
 ERROR:  relation "nonexistant" does not exist
+CONTEXT:  PL/pgSQL function cdb_querytables(text) line 3 at RETURN
 begin; select * from pg_class; commit;|{pg_catalog.pg_class}
 WARNING:  CDB_QueryTables cannot explain query: select * from test (42P01: relation "test" does not exist)
+CONTEXT:  PL/pgSQL function cdb_querytables(text) line 3 at RETURN
 ERROR:  relation "test" does not exist
+CONTEXT:  PL/pgSQL function cdb_querytables(text) line 3 at RETURN
 WITH a AS (select * from pg_class) select * from a|{pg_catalog.pg_class}
 CREATE SCHEMA
 CREATE TABLE
 INSERT 0 1
 select * from sc.test|{sc.test}
+DROP TABLE
+DROP SCHEMA
+SELECT
+* FROM geometry_columns|{pg_catalog.pg_attribute,pg_catalog.pg_class,pg_catalog.pg_constraint,pg_catalog.pg_namespace,pg_catalog.pg_type}
--- a/test/CDB_QuotaTest.sql
+++ b/test/CDB_QuotaTest.sql
@@ -1,19 +1,31 @@
-set client_min_messages to ERROR;
-\set VERBOSITY terse
+set client_min_messages to error;
+\set VERBOSITY default
+
+-- See the dice
+SELECT setseed(0.5);
+
 CREATE TABLE big(a int);
 -- Try the legacy interface
 -- See https://github.com/CartoDB/cartodb-postgresql/issues/13
 CREATE TRIGGER test_quota BEFORE UPDATE OR INSERT ON big
      EXECUTE PROCEDURE CDB_CheckQuota(1, 1, 'public');
 INSERT INTO big VALUES (1); -- allowed, check runs before
-INSERT INTO big VALUES (1); -- disallowed, quota exceeds before
+INSERT INTO big VALUES (2); -- disallowed, quota exceeds before
 SELECT CDB_SetUserQuotaInBytes(0);
 SELECT CDB_CartodbfyTable('big');
-INSERT INTO big SELECT generate_series(1,1024);
-SELECT CDB_SetUserQuotaInBytes(8);
-INSERT INTO big VALUES (1);
+INSERT INTO big SELECT generate_series(2049,4096);
+INSERT INTO big SELECT generate_series(4097,6144);
+INSERT INTO big SELECT generate_series(6145,8192);
+-- Test for #108: https://github.com/CartoDB/cartodb-postgresql/issues/108
+SELECT CDB_UserDataSize();
+SELECT cartodb._CDB_total_relation_size('public', 'big');
+SELECT cartodb._CDB_total_relation_size('public', 'nonexistent_table_name');
+-- END Test for #108
+SELECT setseed(0.9);
+SELECT CDB_SetUserQuotaInBytes(2);
+INSERT INTO big VALUES (8193);
 SELECT CDB_SetUserQuotaInBytes(0);
-INSERT INTO big VALUES (1);
+INSERT INTO big VALUES (8194);
 DROP TABLE big;
 set client_min_messages to NOTICE;
 DROP FUNCTION _CDB_UserQuotaInBytes();
--- a/test/CDB_QuotaTest_expect
+++ b/test/CDB_QuotaTest_expect
@@ -1,13 +1,20 @@
 SET
+
 CREATE TABLE
 CREATE TRIGGER
 INSERT 0 1
 ERROR:  Quota exceeded by 3.9990234375KB
 0
+big
+INSERT 0 2048
+INSERT 0 2048
+INSERT 0 2048
+454656
+909312
+0

-INSERT 0 1024
-8
-ERROR:  Quota exceeded by 103.9921875KB
+2
+ERROR:  Quota exceeded by 443.998046875KB
 0
 INSERT 0 1
 DROP TABLE
--- a/test/CDB_StatsTest.sql
+++ b/test/CDB_StatsTest.sql
@@ -0,0 +1,13 @@
+-- continuous uniform distribution has kurtosis = -6/5, skewness = 0.0
+-- http://mathworld.wolfram.com/UniformDistribution.html
+set client_min_messages to ERROR;
+
+WITH dist AS (
+  SELECT generate_series(0,10000)::numeric / 10000.0 i
+)
+SELECT
+  abs(CDB_Kurtosis(array_agg(i)) + 1.2) < 1e-3 AS kurtosis,
+  abs(CDB_Skewness(array_agg(i))) < 1e-3 AS skewness
+FROM dist;
+
+set client_min_messages to NOTICE;
--- a/test/CDB_StatsTest_expect
+++ b/test/CDB_StatsTest_expect
@@ -0,0 +1,3 @@
+SET
+t|t
+SET
--- a/test/CDB_UserTablesTest.sql
+++ b/test/CDB_UserTablesTest.sql
@@ -1,11 +1,19 @@
-create table pub(a int);
-create table prv(a int);
-GRANT SELECT ON TABLE pub TO public;
-REVOKE SELECT ON TABLE prv FROM public;
+CREATE ROLE publicuser LOGIN;
+CREATE TABLE pub(a int);
+CREATE TABLE prv(a int);
+GRANT SELECT ON TABLE pub TO publicuser;
+REVOKE SELECT ON TABLE prv FROM publicuser;
 SELECT CDB_UserTables() ORDER BY 1;
 SELECT 'all',CDB_UserTables('all') ORDER BY 2;
 SELECT 'public',CDB_UserTables('public') ORDER BY 2;
 SELECT 'private',CDB_UserTables('private') ORDER BY 2;
 SELECT '--unsupported--',CDB_UserTables('--unsupported--') ORDER BY 2;
-drop table pub;
-drop table prv;
+-- now tests with public user
+\c contrib_regression publicuser
+SELECT 'all_publicuser',CDB_UserTables('all') ORDER BY 2;
+SELECT 'public_publicuser',CDB_UserTables('public') ORDER BY 2;
+SELECT 'private_publicuser',CDB_UserTables('private') ORDER BY 2;
+\c contrib_regression postgres
+DROP TABLE pub;
+DROP TABLE prv;
+DROP ROLE publicuser;
--- a/test/CDB_UserTablesTest_expect
+++ b/test/CDB_UserTablesTest_expect
@@ -1,3 +1,4 @@
+CREATE ROLE
 CREATE TABLE
 CREATE TABLE
 GRANT
@@ -8,5 +9,10 @@ all|prv
 all|pub
 public|pub
 private|prv
+You are now connected to database "contrib_regression" as user "publicuser".
+all_publicuser|pub
+public_publicuser|pub
+You are now connected to database "contrib_regression" as user "postgres".
 DROP TABLE
 DROP TABLE
+DROP ROLE
--- a/test/CDB_XYZ_ExtentTest.sql
+++ b/test/CDB_XYZ_ExtentTest.sql
@@ -4,6 +4,6 @@ range AS ( select z, generate_series(0, pow(2,z)::int-1) as r FROM zoom),
 inp AS ( select z0.z, r1.r as x, r2.r as y FROM zoom z0, range r1, range r2 WHERE z0.z = r1.z and r1.z = r2.z ),
 ext AS ( select x,y,z,CDB_XYZ_Extent(x,y,z) as g from inp )
 select X::text || ',' || Y::text || ',' || Z::text as xyz,
-       st_xmin(g), st_xmax(g), st_ymin(g), st_ymax(g)
-       from ext;
+       round(st_xmin(g)), round(st_xmax(g)), round(st_ymin(g)), round(st_ymax(g))
+       from ext order by xyz;

--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`../scripts-available/CDB_EqualIntervalBins.sql`
				`@@ -0,0 +1 @@`
				`../scripts-available/CDB_AnalysisCatalog.sql`
				`@@ -0,0 +1 @@`
				`../scripts-available/CDB_DistinctMeasure.sql`